@tstdl/base 0.93.62 → 0.93.64

package/ai/genkit/helpers.d.ts

@@ -0,0 +1,10 @@
+import type { GenerateOptions, z } from 'genkit';
+import type { SchemaTestable } from '../../schema/index.js';
+import type { TypedOmit } from '../../types/types.js';
+export type TstdlGenkitGenerationOptions<T, O extends z.ZodTypeAny> = TypedOmit<GenerateOptions<z.ZodType<NoInfer<T>>, O>, 'output'> & {
+    output?: TypedOmit<NonNullable<GenerateOptions['output']>, 'schema'> & {
+        schema?: SchemaTestable<T>;
+    };
+};
+export declare function convertToGenkitSchema<T>(schema: SchemaTestable<T>): z.ZodType<T>;
+export declare function genkitGenerationOptions<T, O extends z.ZodTypeAny>(options: TstdlGenkitGenerationOptions<T, O>): GenerateOptions<z.ZodType<T>, z.ZodType<O>>;

package/ai/genkit/helpers.js

@@ -0,0 +1,14 @@
+import { convertToZodV3Schema } from '../../schema/converters/zod-v3-converter.js';
+import { isDefined } from '../../utils/type-guards.js';
+export function convertToGenkitSchema(schema) {
+    return convertToZodV3Schema(schema); // eslint-disable-line @typescript-eslint/no-unsafe-return
+}
+export function genkitGenerationOptions(options) {
+    return {
+        ...options,
+        output: {
+            ...options.output,
+            schema: isDefined(options.output?.schema) ? convertToGenkitSchema(options.output.schema) : undefined,
+        },
+    };
+}

package/ai/genkit/index.d.ts

@@ -0,0 +1,2 @@
+export * from './helpers.js';
+export * from './module.js';

package/ai/genkit/index.js

@@ -0,0 +1,2 @@
+export * from './helpers.js';
+export * from './module.js';

package/ai/genkit/module.d.ts

@@ -0,0 +1,35 @@
+import { vertexAI } from '@genkit-ai/google-genai';
+import { type Genkit, type GenkitOptions } from 'genkit';
+/**
+ * Options for configuring the AI Module.
+ */
+export declare class GenkitModuleOptions {
+    /** Gemini API specific options. */
+    gemini?: {
+        /** Gemini API key */
+        apiKey?: string;
+    };
+    /** Vertex AI specific options. If provided, the service will use Vertex AI endpoints. */
+    vertex?: {
+        /** Google Cloud API key */
+        apiKey?: string;
+        /** Google Cloud projectId */
+        projectId: string;
+        /** Google Cloud region  */
+        location: string;
+        /** Path to the Google Cloud credentials file */
+        keyFile?: string;
+    };
+    /** Plugins to register automatically */
+    plugins?: GenkitOptions['plugins'];
+    /** Default Genkit options */
+    options?: Omit<GenkitOptions, 'plugins'>;
+}
+/**
+ * Configures the {@link AiService}.
+ * @param options The configuration options for the AI services.
+ */
+export declare function configureGenkit(options: GenkitModuleOptions): void;
+export declare function injectGenkit(options?: GenkitOptions): Genkit;
+declare const _injectModel: typeof vertexAI.model;
+export { _injectModel as injectModel };

package/ai/genkit/module.js

@@ -0,0 +1,56 @@
+import { googleAI, vertexAI } from '@genkit-ai/google-genai';
+import { genkit } from 'genkit';
+import { inject } from '../../injector/inject.js';
+import { Injector } from '../../injector/injector.js';
+import { isDefined, isNotNull } from '../../utils/type-guards.js';
+/**
+ * Options for configuring the AI Module.
+ */
+export class GenkitModuleOptions {
+    /** Gemini API specific options. */
+    gemini;
+    /** Vertex AI specific options. If provided, the service will use Vertex AI endpoints. */
+    vertex;
+    /** Plugins to register automatically */
+    plugins;
+    /** Default Genkit options */
+    options;
+}
+/**
+ * Configures the {@link AiService}.
+ * @param options The configuration options for the AI services.
+ */
+export function configureGenkit(options) {
+    Injector.register(GenkitModuleOptions, { useValue: options });
+}
+export function injectGenkit(options) {
+    const { vertex, gemini, ...moduleOptions } = inject(GenkitModuleOptions, undefined, { optional: true }) ?? {};
+    const vertexPlugin = isDefined(vertex)
+        ? vertexAI({
+            apiKey: vertex.apiKey,
+            location: vertex.location,
+            projectId: vertex.projectId,
+            googleAuth: isDefined(vertex.keyFile) ? { keyFile: vertex.keyFile } : undefined,
+        })
+        : null;
+    const geminiPlugin = isDefined(gemini)
+        ? googleAI({ apiKey: gemini.apiKey })
+        : null;
+    return genkit({
+        ...moduleOptions.options,
+        ...options,
+        plugins: [
+            geminiPlugin,
+            vertexPlugin,
+            ...(moduleOptions.plugins ?? []),
+            ...(options?.plugins ?? []),
+        ].filter(isNotNull),
+    });
+}
+function injectModel(...args) {
+    const moduleOptions = inject(GenkitModuleOptions, undefined, { optional: true }) ?? {};
+    const provider = isDefined(moduleOptions.vertex) ? vertexAI : googleAI;
+    return provider.model(...args);
+}
+const _injectModel = injectModel;
+export { _injectModel as injectModel };

package/ai/index.d.ts

@@ -3,4 +3,5 @@ export * from './ai-session.js';
 export * from './ai.service.js';
 export * from './functions.js';
 export * from './module.js';
+export * from './prompts/index.js';
 export * from './types.js';

package/ai/index.js

@@ -3,4 +3,5 @@ export * from './ai-session.js';
 export * from './ai.service.js';
 export * from './functions.js';
 export * from './module.js';
+export * from './prompts/index.js';
 export * from './types.js';

package/ai/prompts/format.d.ts

@@ -0,0 +1,15 @@
+import type { Json } from '../../types/types.js';
+/**
+ * Formats objects and arrays for AI context. Requires values to be primitive types (or arrays of primitive types).
+ * Nesting of arrays is only supported one level deep and only recommended for a short list of items.
+ * If keys are not provided, all supported properties will be included. In case of arrays of objects, the keys of the first object will be used.
+ * @param data data to format
+ * @param dataTypeName name of the data type (e.g., "document", "users")
+ * @param keys keys to include in the output; can be property names or tuples of [property name, value extractor function]
+ * @returns formatted string representation of the data
+ */
+/**
+ * Format data as TOON string for AI context.
+ * @param data data to format
+ */
+export declare function formatData(data: Json): string;

package/ai/prompts/format.js

@@ -0,0 +1,17 @@
+import { encode } from '@toon-format/toon';
+/**
+ * Formats objects and arrays for AI context. Requires values to be primitive types (or arrays of primitive types).
+ * Nesting of arrays is only supported one level deep and only recommended for a short list of items.
+ * If keys are not provided, all supported properties will be included. In case of arrays of objects, the keys of the first object will be used.
+ * @param data data to format
+ * @param dataTypeName name of the data type (e.g., "document", "users")
+ * @param keys keys to include in the output; can be property names or tuples of [property name, value extractor function]
+ * @returns formatted string representation of the data
+ */
+/**
+ * Format data as TOON string for AI context.
+ * @param data data to format
+ */
+export function formatData(data) {
+    return encode(data, { keyFolding: 'safe', indent: 2 });
+}

package/ai/prompts/index.d.ts

@@ -0,0 +1,3 @@
+export * from './format.js';
+export * from './instructions-formatter.js';
+export * from './instructions.js';

package/ai/prompts/index.js

@@ -0,0 +1,3 @@
+export * from './format.js';
+export * from './instructions-formatter.js';
+export * from './instructions.js';

package/ai/prompts/instructions-formatter.d.ts

@@ -0,0 +1,25 @@
+export type ListStyle = 'sections' | 'ordered' | 'unordered';
+type InstructionsListContent = string[] | Instructions;
+export type InstructionsList = {
+    style: ListStyle;
+    instruction?: string;
+    items: InstructionsListContent;
+};
+export type Instructions = {
+    [key: string]: string | string[] | InstructionsList | Instructions;
+};
+export declare function sections(items: InstructionsListContent): InstructionsList;
+export declare function sections(instruction: string, items: InstructionsListContent): InstructionsList;
+export declare function orderedList(items: InstructionsListContent): InstructionsList;
+export declare function orderedList(instruction: string, items: InstructionsListContent): InstructionsList;
+export declare function unorderedList(items: InstructionsListContent): InstructionsList;
+export declare function unorderedList(instruction: string, items: InstructionsListContent): InstructionsList;
+/**
+ * Formats instructions into a string representation suitable for AI prompts.
+ * @param node
+ * @param options
+ */
+export declare function formatInstructions(node: Instructions | InstructionsList | string[], options?: {
+    initialDepth?: number;
+}): string;
+export {};

package/ai/prompts/instructions-formatter.js

@@ -0,0 +1,166 @@
+import { hasOwnProperty, objectEntries } from '../../utils/object/object.js';
+import { assertDefined, isArray, isDefined, isObject, isString } from '../../utils/type-guards.js';
+// --- Factories ---
+function list(style, instructionOrItems, itemsOrNothing) {
+    const instruction = isString(instructionOrItems) ? instructionOrItems : undefined;
+    const items = isString(instructionOrItems) ? itemsOrNothing : instructionOrItems;
+    assertDefined(items, 'Instructions list is empty.');
+    return { style, instruction, items };
+}
+export function sections(instructionOrItems, itemsOrNothing) {
+    return list('sections', instructionOrItems, itemsOrNothing);
+}
+export function orderedList(instructionOrItems, itemsOrNothing) {
+    return list('ordered', instructionOrItems, itemsOrNothing);
+}
+export function unorderedList(instructionOrItems, itemsOrNothing) {
+    return list('unordered', instructionOrItems, itemsOrNothing);
+}
+// --- Type Guards ---
+function isInstructionsList(obj) {
+    return isObject(obj) && hasOwnProperty(obj, 'style') && hasOwnProperty(obj, 'items');
+}
+// --- Formatter Logic ---
+const INDENT_SIZE = 2;
+function getPrefix(style, index, sectionDepth) {
+    switch (style) {
+        case 'ordered':
+            return `${index + 1}. `;
+        case 'unordered':
+            return '- ';
+        case 'sections':
+            return '#'.repeat(Math.max(1, sectionDepth)) + ' ';
+        default:
+            return '';
+    }
+}
+/**
+ * Formats a string that might span multiple lines.
+ * It calculates the hanging indent based on the length of the prefix used on the first line.
+ */
+function formatWithHangingIndent(text, baseIndent, prefix) {
+    const lines = text.split('\n');
+    if (lines.length == 0) {
+        return '';
+    }
+    const firstLine = `${baseIndent}${prefix}${lines[0]}`;
+    if (lines.length == 1) {
+        return firstLine;
+    }
+    // Create a spacer that exactly matches the visual length of "  1. " or "  - "
+    const hangingSpacer = ' '.repeat(baseIndent.length + prefix.length);
+    return [
+        firstLine,
+        ...lines.slice(1).map((line) => `${hangingSpacer}${line}`),
+    ].join('\n');
+}
+/**
+ * Main recursive formatter.
+ */
+function processNode(node, context) {
+    // 1. Unwrap InstructionsList (The Wrapper)
+    // If the node is a wrapper, we adopt its style and instruction, then process its items.
+    if (isInstructionsList(node)) {
+        // Note: We don't print the "instruction" here (e.g., "Use Markdown").
+        // If this Wrapper is a root node, the instruction is usually printed by the caller or ignored.
+        // If this Wrapper is a value of a key, the key printer handles the instruction.
+        // However, if we have a "Root Wrapper" with an instruction (rare in your example), handle it:
+        const header = node.instruction ? `${node.instruction}\n` : '';
+        // Determine next context
+        const nextContext = {
+            indentDepth: context.indentDepth, // Wrappers don't indent themselves, their content does
+            style: node.style,
+            sectionDepth: node.style == 'sections' ? context.sectionDepth : context.sectionDepth, // Section depth increments internally
+        };
+        return header + processNode(node.items, nextContext);
+    }
+    // Common Constants for this level
+    const isSection = context.style == 'sections';
+    const currentBaseIndent = ' '.repeat(isSection ? 0 : context.indentDepth * INDENT_SIZE);
+    const separator = isSection ? '\n\n' : '\n';
+    // 2. Handle Arrays (Simple Lists)
+    if (isArray(node)) {
+        return node.map((item, index) => {
+            const prefix = getPrefix(context.style, index, context.sectionDepth);
+            return formatWithHangingIndent(item, currentBaseIndent, prefix);
+        }).join(separator);
+    }
+    // 3. Handle Objects (Key-Value Maps)
+    return objectEntries(node).map(([key, value], index) => {
+        const prefix = getPrefix(context.style, index, context.sectionDepth);
+        // Detect if the Value is a Wrapper (e.g. `Key: ordered(...)`)
+        // This allows us to pull the wrapper's "instruction" up to the Key line.
+        const isValueWrapper = isInstructionsList(value);
+        const effectiveValue = isValueWrapper ? value.items : value;
+        const instruction = (isValueWrapper && isDefined(value.instruction)) ? ` ${value.instruction}` : '';
+        const childStyle = isValueWrapper ? value.style : (isSection ? 'unordered' : 'unordered');
+        // Formatting the Header Line (The Key)
+        let headerLine = '';
+        if (isSection) {
+            // Header format: "# Key" or "# Key\n\nInstruction"
+            const instructionPart = (instruction.length > 0) ? `\n\n${instruction.trim()}` : '';
+            headerLine = `${currentBaseIndent}${prefix}${key}${instructionPart}`;
+        }
+        else {
+            // List format: "- **Key:**" or "- **Key:** Instruction"
+            const keyPart = `**${key}:**`;
+            headerLine = `${currentBaseIndent}${prefix}${keyPart}${instruction}`;
+        }
+        // Determine context for the children
+        // If we are a Section, children reset indent to 0.
+        // If we are a List, children indent + 1.
+        const nextIndentDepth = isSection ? 0 : context.indentDepth + 1;
+        // If the child acts as a section (Wrapper was `sections(...)`), increment H-level.
+        const nextSectionDepth = (isValueWrapper && value.style == 'sections')
+            ? context.sectionDepth + 1
+            : context.sectionDepth;
+        // Recurse
+        // If the value is a simple string, we print it inline if possible, or block if it's long?
+        // Your requirement: Strings in objects are usually descriptions.
+        if (isString(effectiveValue)) {
+            // If it's a string, we treat it as content on the SAME line for lists (via hanging indent logic),
+            // or a new paragraph for Sections.
+            if (isSection) {
+                // Section: Header \n\n Content
+                return `${headerLine}\n\n${effectiveValue.trim()}`;
+            }
+            else {
+                // List: "- **Key:** Value"
+                // We need to construct the full string to calculate hanging indent correctly.
+                // headerLine already contains indentation + prefix + key.
+                // We strip the indentation to feed it into the formatting helper effectively.
+                const fullLine = `${headerLine} ${effectiveValue}`.trim();
+                return formatWithHangingIndent(fullLine, currentBaseIndent, '');
+            }
+        }
+        // If Value is Object/Array/Wrapper
+        const body = processNode(effectiveValue, {
+            indentDepth: nextIndentDepth,
+            style: childStyle,
+            sectionDepth: nextSectionDepth,
+        });
+        const bodySeparator = isSection ? '\n\n' : '\n';
+        // Edge case: If it's a section, we constructed the header, now append body.
+        // If it's a list, the header line serves as the parent item.
+        return `${headerLine}${bodySeparator}${body}`;
+    }).join(separator);
+}
+/**
+ * Formats instructions into a string representation suitable for AI prompts.
+ * @param node
+ * @param options
+ */
+export function formatInstructions(node, options = {}) {
+    // Heuristic: If passing a raw object, assume it's a Root Section unless specified otherwise.
+    // If passing a Wrapper, the Wrapper dictates the style.
+    const initialStyle = isInstructionsList(node)
+        ? node.style
+        : isArray(node)
+            ? 'unordered'
+            : 'sections';
+    return processNode(node, {
+        indentDepth: options.initialDepth ?? 0,
+        sectionDepth: 1,
+        style: initialStyle,
+    }).trim();
+}

package/ai/prompts/instructions.d.ts

@@ -0,0 +1,3 @@
+export declare const jsonOutputInstructions: {
+    'JSON Output': import("./instructions-formatter.js").InstructionsList;
+};

package/ai/prompts/instructions.js

@@ -0,0 +1,8 @@
+import { unorderedList } from './instructions-formatter.js';
+export const jsonOutputInstructions = {
+    'JSON Output': unorderedList({
+        'Schema Compliance': 'Generate valid JSON that strictly matches the provided schema.',
+        'Nullable fields with missing data': 'Must be set to literal `null`.',
+        'Optional fields with missing data': 'Omit the key entirely (sparse JSON).',
+    }),
+};

package/document-management/server/services/document-file.service.d.ts

@@ -29,6 +29,8 @@ export declare class DocumentFileService extends Transactional {
     getContent(document: Document): Promise<Uint8Array>;
     getContentStream(document: Document): ReadableStream<Uint8Array>;
     getContentUrl(document: Document, download?: boolean): Promise<string>;
+    /** Gets the underlying object storage object for the document file */
+    getObject(document: Document): Promise<import("../../../object-storage/index.js").ObjectStorageObject>;
     getPreview(document: Document, page?: number): Promise<Uint8Array>;
     getPreviewStream(document: Document, page?: number): ReadableStream<Uint8Array>;
     getPreviewUrl(document: Document, page?: number): Promise<string>;

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

@@ -56,8 +56,6 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     var e = new Error(message);
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
-var _a;
-var DocumentFileService_1;
 import sharp, {} from 'sharp';
 import { match } from 'ts-pattern';
 import { AiService } from '../../../ai/ai.service.js';
@@ -66,7 +64,6 @@ import { NotImplementedError } from '../../../errors/not-implemented.error.js';
 import { getMimeType, getMimeTypeExtensions, mimeTypes } from '../../../file/index.js';
 import { TemporaryFile } from '../../../file/server/index.js';
 import { inject } from '../../../injector/inject.js';
-import { Logger } from '../../../logger/logger.js';
 import { ObjectStorage } from '../../../object-storage/index.js';
 import { Transactional } from '../../../orm/server/index.js';
 import { pdfToImage } from '../../../pdf/index.js';
@@ -80,13 +77,12 @@ import { millisecondsPerMinute, secondsPerMinute } from '../../../utils/units.js
 import { Document } from '../../models/index.js';
 import { DocumentManagementConfiguration } from '../module.js';
 import { DocumentManagementSingleton } from './singleton.js';
-let DocumentFileService = DocumentFileService_1 = class DocumentFileService extends Transactional {
+let DocumentFileService = class DocumentFileService extends Transactional {
     #configuration = inject(DocumentManagementConfiguration);
     #aiService = inject(AiService);
     #fileObjectStorage = inject(ObjectStorage, this.#configuration.fileObjectStorageModule);
     #filePreviewObjectStorage = inject(ObjectStorage, this.#configuration.filePreviewObjectStorageModule);
     #fileUploadObjectStorage = inject(ObjectStorage, { module: this.#configuration.fileUploadObjectStorageModule, configuration: { lifecycle: { expiration: { after: 5 * secondsPerMinute } } } });
-    #logger = inject(Logger, DocumentFileService_1.name);
     #aiFilePartCache = new Map();
     /**
      * Initiates a file upload
@@ -145,6 +141,11 @@ let DocumentFileService = DocumentFileService_1 = class DocumentFileService exte
     async getContentUrl(document, download = false) {
         return await this.getDocumentFileContentObjectUrl(document, document.title ?? document.id, download);
     }
+    /** Gets the underlying object storage object for the document file */
+    async getObject(document) {
+        const objectKey = getObjectKey(document.id);
+        return await this.#fileObjectStorage.getObject(objectKey);
+    }
     async getPreview(document, page = 1) {
         const objectKey = getObjectKey(document.id);
         await this.createPreviewIfNotExists(document, page);
@@ -197,12 +198,12 @@ let DocumentFileService = DocumentFileService_1 = class DocumentFileService exte
             const content = await this.#fileObjectStorage.getContent(key);
             const image = await match(document.mimeType)
                 .with('application/pdf', async () => {
-                const imageBytes = await pdfToImage(content, page, 768, 'jpeg');
+                const imageBytes = await pdfToImage(content, page, 768, 'png');
                 return await imageToPreview(imageBytes);
             })
                 .with('image/*', async () => await imageToPreview(content))
                 .otherwise(() => { throw new NotImplementedError('Preview generation is not implemented for this file type.'); });
-            await this.#filePreviewObjectStorage.uploadObject(key, image, { contentLength: image.length, contentType: 'image/jpeg' });
+            await this.#filePreviewObjectStorage.uploadObject(key, image, { contentLength: image.length, contentType: 'image/webp' });
         }
     }
     async getDocumentFileContentObjectUrl(document, title, download) {
@@ -216,7 +217,7 @@ let DocumentFileService = DocumentFileService_1 = class DocumentFileService exte
         });
     }
 };
-DocumentFileService = DocumentFileService_1 = __decorate([
+DocumentFileService = __decorate([
     DocumentManagementSingleton()
 ], DocumentFileService);
 export { DocumentFileService };
@@ -233,6 +234,6 @@ async function imageToPreview(input) {
         withoutEnlargement: true,
         fastShrinkOnLoad: false,
     })
-        .toFormat('jpeg', { quality: 75 })
+        .toFormat('webp', { quality: 75 })
         .toBuffer();
 }

package/document-management/server/services/document-management-ai.service.d.ts

@@ -15,6 +15,7 @@ export type DocumentInformationExtractionResult = {
 };
 export declare class DocumentManagementAiService {
     #private;
+    extractDocumentContent(tenantId: string, documentId: string): Promise<string>;
     classifyDocumentType(tenantId: string, documentId: string): Promise<string>;
     extractDocumentInformation(tenantId: string, documentId: string): Promise<DocumentInformationExtractionResult>;
     findSuitableCollectionsForDocument(document: Document, collectionIds: string[]): Promise<string[]>;