@tstdl/base 0.92.2 → 0.92.4

package/ai/ai.service.d.ts

@@ -1,36 +1,53 @@
 import '../polyfills.js';
 import { GoogleGenerativeAI } from '@google/generative-ai';
 import { type FileMetadataResponse, GoogleAIFileManager } from '@google/generative-ai/server';
+import { LiteralUnion } from 'type-fest';
 import { Resolvable, type resolveArgumentType } from '../injector/interfaces.js';
-import { SchemaTestable } from '../schema/index.js';
+import { OneOrMany, SchemaTestable } from '../schema/index.js';
 import { Enumeration as EnumerationType, EnumerationValue } from '../types.js';
-import { LiteralUnion } from 'type-fest';
 export type FileInput = {
     path: string;
     mimeType: string;
 } | Blob;
 export type GenerativeAIModel = LiteralUnion<'gemini-2.0-flash-exp' | 'gemini-exp-1206' | 'gemini-2.0-flash-thinking-exp-1219', string>;
+export type GenerationOptions = {
+    model?: GenerativeAIModel;
+    maxOutputTokens?: number;
+    temperature?: number;
+    topP?: number;
+    topK?: number;
+    presencePenalty?: number;
+    frequencyPenalty?: number;
+};
+export type GenerationResult<T> = {
+    result: T;
+    usage?: {
+        promptTokenCount: number;
+        candidatesTokenCount: number;
+        totalTokenCount: number;
+    };
+};
 export type AiServiceOptions = {
     apiKey: string;
-    model?: GenerativeAIModel;
+    defaultModel?: GenerativeAIModel;
 };
 export type AiServiceArgument = AiServiceOptions;
 export declare class AiService implements Resolvable<AiServiceArgument> {
     #private;
     readonly genAI: GoogleGenerativeAI;
     readonly fileManager: GoogleAIFileManager;
-    readonly model: import("@google/generative-ai").GenerativeModel;
+    readonly defaultModel: GenerativeAIModel;
     readonly [resolveArgumentType]: AiServiceArgument;
     getFile(fileInput: FileInput): Promise<FileMetadataResponse>;
-    getFiles(files: FileInput[]): Promise<FileMetadataResponse[]>;
-    classify<T extends EnumerationType>(fileInput: FileInput, types: T): Promise<{
-        reasoning: string;
+    getFiles(files: readonly FileInput[]): Promise<FileMetadataResponse[]>;
+    classify<T extends EnumerationType>(fileInput: OneOrMany<FileInput>, types: T, options?: GenerationOptions): Promise<GenerationResult<{
         types: {
             type: EnumerationValue<T>;
             confidence: 'high' | 'medium' | 'low';
         }[] | null;
-    }>;
-    extractData<T>(fileInput: FileInput, schema: SchemaTestable<T>): Promise<T>;
-    waitForFileActive(fileMetadata: FileMetadataResponse): Promise<FileMetadataResponse>;
-    waitForFilesActive(...files: FileMetadataResponse[]): Promise<FileMetadataResponse[]>;
+    }>>;
+    extractData<T>(fileInput: OneOrMany<FileInput>, schema: SchemaTestable<T>, options?: GenerationOptions): Promise<GenerationResult<T>>;
+    private waitForFileActive;
+    private waitForFilesActive;
+    private getModel;
 }

package/ai/ai.service.js

@@ -65,10 +65,13 @@ import { GoogleGenerativeAI } from '@google/generative-ai';
 import { FileState, GoogleAIFileManager } from '@google/generative-ai/server';
 import { DetailsError } from '../errors/details.error.js';
 import { Singleton } from '../injector/decorators.js';
-import { injectArgument } from '../injector/inject.js';
+import { inject, injectArgument } from '../injector/inject.js';
+import { Logger } from '../logger/logger.js';
 import { convertToOpenApiSchema } from '../schema/converters/openapi-converter.js';
-import { array, enumeration, nullable, object, Schema, string } from '../schema/index.js';
+import { array, enumeration, nullable, object, Schema } from '../schema/index.js';
+import { toArray } from '../utils/array/array.js';
 import { digest } from '../utils/cryptography.js';
+import { formatBytes } from '../utils/format.js';
 import { timeout } from '../utils/timing.js';
 import { tryIgnoreAsync } from '../utils/try-ignore.js';
 import { isBlob } from '../utils/type-guards.js';
@@ -76,19 +79,21 @@ import { millisecondsPerSecond } from '../utils/units.js';
 let AiService = class AiService {
     #options = injectArgument(this);
     #fileCache = new Map();
+    #logger = inject(Logger, 'AiService');
     genAI = new GoogleGenerativeAI(this.#options.apiKey);
     fileManager = new GoogleAIFileManager(this.#options.apiKey);
-    model = this.genAI.getGenerativeModel({ model: this.#options.model ?? 'gemini-2.0-flash-exp' });
+    defaultModel = this.#options.defaultModel ?? 'gemini-2.0-flash-exp';
     async getFile(fileInput) {
         const path = isBlob(fileInput) ? join(tmpdir(), crypto.randomUUID()) : fileInput.path;
         const mimeType = isBlob(fileInput) ? fileInput.type : fileInput.mimeType;
         const blob = isBlob(fileInput) ? fileInput : await openAsBlob(path, { type: mimeType });
         const buffer = await blob.arrayBuffer();
         const byteArray = new Uint8Array(buffer);
-        const fileHash = await digest('SHA-256', byteArray).toBase64();
+        const fileHash = await digest('SHA-1', byteArray).toBase64();
         const fileKey = `${fileHash}:${byteArray.length}`;
         if (this.#fileCache.has(fileKey)) {
             try {
+                this.#logger.verbose(`Fetching file "${fileHash}" from cache...`);
                 const cachedFile = await this.#fileCache.get(fileKey);
                 return await this.fileManager.getFile(cachedFile.name);
             }
@@ -105,7 +110,9 @@ let AiService = class AiService {
                         stack.defer(async () => tryIgnoreAsync(async () => unlink(path)));
                         await writeFile(path, byteArray);
                     }
+                    this.#logger.verbose(`Uploading file "${fileHash}" (${formatBytes(byteArray.length)})...`);
                     const result = await this.fileManager.uploadFile(path, { mimeType });
+                    this.#logger.verbose(`Processing file "${fileHash}"...`);
                     return await this.waitForFileActive(result.file);
                 }
                 catch (e_1) {
@@ -129,20 +136,21 @@ let AiService = class AiService {
     async getFiles(files) {
         return Promise.all(files.map(async (file) => this.getFile(file)));
     }
-    async classify(fileInput, types) {
-        const file = await this.getFile(fileInput);
+    async classify(fileInput, types, options) {
+        const files = await this.getFiles(toArray(fileInput));
         const resultSchema = object({
-            reasoning: string({ description: 'Reasoning for classification. Use to be more confident, if unsure. Reason for every somewhat likely document type.' }),
             types: nullable(array(object({
                 type: enumeration(types, { description: 'Type of document' }),
                 confidence: enumeration(['high', 'medium', 'low'], { description: 'How sure/certain you are about the classficiation.' })
             }), { description: 'One or more document types that matches' }))
         });
         const responseSchema = convertToOpenApiSchema(resultSchema);
-        const result = await this.model.generateContent({
+        this.#logger.verbose('Classifying...');
+        const result = await this.getModel(options?.model ?? this.defaultModel).generateContent({
             generationConfig: {
-                maxOutputTokens: 1024,
-                temperature: 0.5,
+                maxOutputTokens: 2048,
+                temperature: 0.75,
+                ...options,
                 responseMimeType: 'application/json',
                 responseSchema
             },
@@ -151,18 +159,22 @@ let AiService = class AiService {
                 {
                     role: 'user',
                     parts: [
-                        { fileData: { mimeType: file.mimeType, fileUri: file.uri } },
+                        ...files.map((file) => ({ fileData: { mimeType: file.mimeType, fileUri: file.uri } })),
                         { text: `Classify the document. Output as JSON using the following schema:\n${JSON.stringify(responseSchema, null, 2)}\n\nIf none of the provided document types are a suitable match, return null for types.` }
                     ]
                 }
             ]
         });
-        return resultSchema.parse(JSON.parse(result.response.text()));
+        return {
+            usage: result.response.usageMetadata,
+            result: resultSchema.parse(JSON.parse(result.response.text()))
+        };
     }
-    async extractData(fileInput, schema) {
-        const file = await this.getFile(fileInput);
+    async extractData(fileInput, schema, options) {
+        const files = await this.getFiles(toArray(fileInput));
         const responseSchema = convertToOpenApiSchema(schema);
-        const result = await this.model.generateContent({
+        this.#logger.verbose('Extracting data...');
+        const result = await this.getModel(options?.model ?? this.defaultModel).generateContent({
             generationConfig: {
                 maxOutputTokens: 4096,
                 temperature: 0.5,
@@ -172,23 +184,21 @@ let AiService = class AiService {
             systemInstruction: `You are a highly skilled data extraction AI, specializing in accurately identifying and extracting information from unstructured text documents and converting it into a structured JSON format. Your primary goal is to meticulously follow the provided JSON schema and populate it with data extracted from the given document.
 
 **Instructions:**
-Carefully read and analyze the provided document. Identify relevant information that corresponds to each field in the JSON schema. Focus on accuracy and avoid making assumptions. If a field has multiple possible values, extract all relevant ones into the correct array structures ONLY IF the schema defines that field as an array; otherwise, extract only the single most relevant value.
-
-**Reasoning**
-Reason about every field in the json schema and find the best matching value. If there are multiple relevant values but the data type is not an array, reason about the values to find out which is the most relevant one.
-
-You *MUST* output the reasoning first.`,
+Carefully read and analyze the provided document. Identify relevant information that corresponds to each field in the JSON schema. Focus on accuracy and avoid making assumptions. If a field has multiple possible values, extract all relevant ones into the correct array structures ONLY IF the schema defines that field as an array; otherwise, extract only the single most relevant value.`,
             contents: [
                 {
                     role: 'user',
                     parts: [
-                        { fileData: { mimeType: file.mimeType, fileUri: file.uri } },
+                        ...files.map((file) => ({ fileData: { mimeType: file.mimeType, fileUri: file.uri } })),
                         { text: `Classify the document. Output as JSON using the following schema:\n${JSON.stringify(responseSchema, null, 2)}` }
                     ]
                 }
             ]
         });
-        return Schema.parse(schema, JSON.parse(result.response.text()));
+        return {
+            usage: result.response.usageMetadata,
+            result: Schema.parse(schema, JSON.parse(result.response.text()))
+        };
     }
     async waitForFileActive(fileMetadata) {
         let file = await this.fileManager.getFile(fileMetadata.name);
@@ -209,6 +219,9 @@ You *MUST* output the reasoning first.`,
         }
         return responses;
     }
+    getModel(model) {
+        return this.genAI.getGenerativeModel({ model });
+    }
 };
 AiService = __decorate([
     Singleton()

package/logger/logger.d.ts

@@ -9,7 +9,7 @@ export type LogErrorOptions = {
     includeRest?: boolean;
     includeStack?: boolean;
 };
-/** either string as a module shorthand or object */
+/** Either string as a module shorthand or object */
 export type LoggerArgument = string | undefined | {
     level?: LogLevel;
     module?: string | string[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.92.2",
+  "version": "0.92.4",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"