@tstdl/base 0.92.123 → 0.92.125

package/ai/ai-file.service.js

@@ -5,9 +5,9 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import '../polyfills.js';
-import { readFile } from 'node:fs/promises';
+import { openAsBlob } from 'node:fs';
 import { Storage } from '@google-cloud/storage';
-import { FileState, GoogleAIFileManager } from '@google/generative-ai/server';
+import { FileState, GoogleGenAI } from '@google/genai';
 import { AsyncEnumerable } from '../enumerable/async-enumerable.js';
 import { DetailsError } from '../errors/details.error.js';
 import { NotImplementedError } from '../errors/not-implemented.error.js';
@@ -21,7 +21,13 @@ import { assertDefinedPass, isBlob, isDefined, isUndefined } from '../utils/type
 import { millisecondsPerSecond } from '../utils/units.js';
 let AiFileService = class AiFileService {
     #options = injectArgument(this);
-    #fileManager = isUndefined(this.#options.vertex) ? new GoogleAIFileManager(assertDefinedPass(this.#options.apiKey, 'Api key not defined')) : undefined;
+    #genAI = new GoogleGenAI({
+        vertexai: isDefined(this.#options.vertex?.project),
+        project: this.#options.vertex?.project,
+        location: this.#options.vertex?.location,
+        googleAuthOptions: isDefined(this.#options.vertex?.project) ? { apiKey: this.#options.apiKey, keyFile: this.#options.keyFile } : undefined,
+        apiKey: isUndefined(this.#options.vertex?.project) ? assertDefinedPass(this.#options.apiKey, 'Api key not defined') : undefined,
+    });
     #storage = isDefined(this.#options.vertex) ? new Storage({ keyFile: assertDefinedPass(this.#options.keyFile, 'Key file not defined'), projectId: this.#options.vertex.project }) : undefined;
     #fileMap = new Map();
     #fileUriMap = new Map();
@@ -63,11 +69,10 @@ let AiFileService = class AiFileService {
     }
     async uploadFile(fileInput, id) {
         const inputIsBlob = isBlob(fileInput);
-        const buffer = inputIsBlob
-            ? Buffer.from(await fileInput.arrayBuffer())
-            : await readFile(fileInput.path);
-        const mimeType = inputIsBlob ? fileInput.type : fileInput.mimeType;
-        this.#logger.verbose(`Uploading file "${id}" (${formatBytes(buffer.length)})...`);
+        const blob = inputIsBlob
+            ? fileInput
+            : await openAsBlob(fileInput.path, { type: fileInput.mimeType });
+        this.#logger.verbose(`Uploading file "${id}" (${formatBytes(blob.size)})...`);
         if (isDefined(this.#storage)) {
             throw new NotImplementedError();
             /*
@@ -82,12 +87,12 @@ let AiFileService = class AiFileService {
             };
             */
         }
-        const response = await this.#fileManager.uploadFile(buffer, { mimeType });
+        const response = await this.#genAI.files.upload({ file: blob, config: { mimeType: blob.type } });
         return {
             id,
-            name: response.file.name,
-            uri: response.file.uri,
-            mimeType: response.file.mimeType
+            name: assertDefinedPass(response.name, 'Missing file name'),
+            uri: assertDefinedPass(response.uri, 'Missing file uri'),
+            mimeType: assertDefinedPass(response.mimeType, 'Missing file mime type'),
         };
     }
     async getBucket() {
@@ -105,22 +110,22 @@ let AiFileService = class AiFileService {
                 lifecycle: {
                     rule: [{
                             action: { type: 'Delete' },
-                            condition: { age: 1 }
-                        }]
-                }
+                            condition: { age: 1 },
+                        }],
+                },
             });
             this.#bucket = bucket;
         }
         return this.#bucket;
     }
     async waitForFileActive(file) {
-        if (isUndefined(this.#fileManager)) {
+        if (isUndefined(this.#genAI)) {
             return;
         }
-        let state = await this.#fileManager.getFile(file.name);
+        let state = await this.#genAI.files.get({ name: file.name });
         while (state.state == FileState.PROCESSING) {
             await timeout(millisecondsPerSecond);
-            state = await this.#fileManager.getFile(file.name);
+            state = await this.#genAI.files.get({ name: file.name });
         }
         if (state.state == FileState.FAILED) {
             throw new DetailsError(state.error?.message ?? `Failed to process file ${state.name}`, state.error?.details);

package/ai/ai.service.d.ts

@@ -1,8 +1,8 @@
 import type { Resolvable, resolveArgumentType } from '../injector/interfaces.js';
-import { type OneOrMany, type SchemaTestable } from '../schema/index.js';
+import { type SchemaTestable } from '../schema/index.js';
 import type { Enumeration as EnumerationType, EnumerationValue } from '../types.js';
 import { AiSession } from './ai-session.js';
-import { type AiModel, type Content, type ContentPart, type FileContentPart, type FileInput, type FunctionResultContentPart, type GenerationOptions, type GenerationRequest, type GenerationResult, type SchemaFunctionDeclarations, type SchemaFunctionDeclarationsResult } from './types.js';
+import { type AiModel, type FileContentPart, type FileInput, type FunctionResultContentPart, type GenerationOptions, type GenerationRequest, type GenerationResult, type SchemaFunctionDeclarations, type SchemaFunctionDeclarationsResult } from './types.js';
 export type SpecializedGenerationResult<T> = {
     result: T;
     raw: GenerationResult;
@@ -43,15 +43,6 @@ export declare class AiService implements Resolvable<AiServiceArgument> {
     processFile(fileInput: FileInput): Promise<FileContentPart>;
     processFiles(fileInputs: FileInput[]): Promise<FileContentPart[]>;
     getFileById(id: string): FileContentPart;
-    classify<T extends EnumerationType>(parts: OneOrMany<ContentPart>, types: T, options?: GenerationOptions & Pick<GenerationRequest, 'model'>): Promise<SpecializedGenerationResult<ClassificationResult<T>>>;
-    getClassifyContents(parts: OneOrMany<ContentPart>): Content[];
-    extractData<T>(parts: OneOrMany<ContentPart>, schema: SchemaTestable<T>, options?: GenerationOptions & Pick<GenerationRequest, 'model'>): Promise<SpecializedGenerationResult<T>>;
-    getExtractDataConents(parts: OneOrMany<ContentPart>): Content[];
-    analyzeContent<T extends EnumerationType>(parts: OneOrMany<ContentPart>, types: T, options?: GenerationOptions & {
-        targetLanguage?: string;
-        maximumNumberOfTags?: number;
-    }): Promise<SpecializedGenerationResult<AnalyzeContentResult<T>>>;
-    getAnalyzeContentConents(parts: OneOrMany<ContentPart>): Content[];
     callFunctions<const T extends SchemaFunctionDeclarations>(options: CallFunctionsOptions<T>): Promise<SpecializedGenerationResult<SchemaFunctionDeclarationsResult<T>[]> & {
         getFunctionResultContentParts: () => FunctionResultContentPart[];
     }>;
@@ -59,10 +50,11 @@ export declare class AiService implements Resolvable<AiServiceArgument> {
     generate<S>(request: GenerationRequest<S>): Promise<GenerationResult<S>>;
     generateStream<S>(request: GenerationRequest<S>): AsyncGenerator<GenerationResult<S>>;
     private _callFunctionsStream;
+    private getModelOutputTokenLimit;
+    private _getModelOutputTokenLimit;
     private convertContents;
     private convertContent;
     private convertFunctions;
     private convertGoogleContent;
-    private getModel;
 }
 export declare function mergeGenerationStreamItems<S>(items: GenerationResult<S>[], schema?: SchemaTestable<S>): GenerationResult<S>;

package/ai/ai.service.js

@@ -6,8 +6,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 var _a;
 var AiService_1;
-import { FinishReason, FunctionCallingMode as GoogleFunctionCallingMode, VertexAI } from '@google-cloud/vertexai';
-import { GoogleGenerativeAI } from '@google/generative-ai';
+import { FinishReason, FunctionCallingConfigMode as GoogleFunctionCallingMode, GoogleGenAI } from '@google/genai';
 import { NotSupportedError } from '../errors/not-supported.error.js';
 import { Singleton } from '../injector/decorators.js';
 import { inject, injectArgument } from '../injector/inject.js';
@@ -16,14 +15,14 @@ import { getShutdownSignal } from '../process-shutdown.js';
 import { DeferredPromise } from '../promise/deferred-promise.js';
 import { LazyPromise } from '../promise/lazy-promise.js';
 import { convertToOpenApiSchema } from '../schema/converters/openapi-converter.js';
-import { array, enumeration, nullable, object, Schema, string } from '../schema/index.js';
+import { Schema } from '../schema/index.js';
 import { 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 { lazyObject } from '../utils/object/lazy-property.js';
 import { hasOwnProperty, objectEntries } from '../utils/object/object.js';
 import { cancelableTimeout } from '../utils/timing.js';
-import { assertDefinedPass, assertNotNullPass, isDefined, isError, isNotNull, isNull, isUndefined } from '../utils/type-guards.js';
+import { assertDefinedPass, isDefined, isError, isNotNull, isNull, isUndefined } from '../utils/type-guards.js';
 import { millisecondsPerSecond } from '../utils/units.js';
 import { resolveValueOrAsyncProvider } from '../utils/value-or-provider.js';
 import { AiFileService } from './ai-file.service.js';
@@ -39,16 +38,21 @@ export class AiServiceOptions {
 const functionCallingModeMap = {
     auto: GoogleFunctionCallingMode.AUTO,
     force: GoogleFunctionCallingMode.ANY,
-    none: GoogleFunctionCallingMode.NONE
+    none: GoogleFunctionCallingMode.NONE,
 };
 let generationCounter = 0;
 let AiService = AiService_1 = class AiService {
     #options = injectArgument(this, { optional: true }) ?? inject(AiServiceOptions);
     #fileService = inject(AiFileService, this.#options);
     #logger = inject(Logger, AiService_1.name);
-    #genAI = (isDefined(this.#options.vertex)
-        ? new VertexAI({ project: this.#options.vertex.project, location: this.#options.vertex.location, googleAuthOptions: { apiKey: this.#options.apiKey, keyFile: this.#options.keyFile } })
-        : new GoogleGenerativeAI(assertDefinedPass(this.#options.apiKey, 'Api key not defined')));
+    #genAI = new GoogleGenAI({
+        vertexai: isDefined(this.#options.vertex?.project),
+        project: this.#options.vertex?.project,
+        location: this.#options.vertex?.location,
+        googleAuthOptions: isDefined(this.#options.vertex?.project) ? { apiKey: this.#options.apiKey, keyFile: this.#options.keyFile } : undefined,
+        apiKey: isUndefined(this.#options.vertex?.project) ? assertDefinedPass(this.#options.apiKey, 'Api key not defined') : undefined,
+    });
+    #maxOutputTokensCache = new Map();
     defaultModel = this.#options.defaultModel ?? 'gemini-2.0-flash';
     createSession() {
         return new AiSession(this);
@@ -62,117 +66,17 @@ let AiService = AiService_1 = class AiService {
     getFileById(id) {
         return { file: id };
     }
-    async classify(parts, types, options) {
-        const generationSchema = object({
-            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 generation = await this.generate({
-            model: options?.model,
-            generationOptions: {
-                maxOutputTokens: 1048,
-                temperature: 0.5,
-                ...options
-            },
-            generationSchema,
-            systemInstruction: 'You are a highly accurate document classification AI. Your task is to analyze the content of a given document and determine its type based on a predefined list of possible document types.',
-            contents: this.getClassifyContents(parts)
-        });
-        return {
-            result: JSON.parse(assertNotNullPass(generation.text, 'No text returned.')),
-            raw: generation
-        };
-    }
-    getClassifyContents(parts) {
-        return [{
-                role: 'user',
-                parts: [
-                    ...toArray(parts),
-                    { text: 'Classify the document. Output as JSON using the provided schema\n\nIf none of the provided document types are a suitable match, return null for types.' }
-                ]
-            }];
-    }
-    async extractData(parts, schema, options) {
-        const generation = await this.generate({
-            model: options?.model,
-            generationOptions: {
-                temperature: 0.5,
-                ...options
-            },
-            generationSchema: schema,
-            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.`,
-            contents: this.getExtractDataConents(parts)
-        });
-        return {
-            result: JSON.parse(assertNotNullPass(generation.text, 'No text returned.')),
-            raw: generation
-        };
-    }
-    getExtractDataConents(parts) {
-        return [{
-                role: 'user',
-                parts: [
-                    ...toArray(parts),
-                    { text: 'Extract the data as specified in the schema. Output as JSON.' }
-                ]
-            }];
-    }
-    async analyzeContent(parts, types, options) {
-        const schema = object({
-            content: string({ description: 'Content of the document with important details only' }),
-            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' })),
-            tags: array(string({ description: 'Tag which describes the content' }), { description: 'List of tags', maximum: options?.maximumNumberOfTags ?? 5 })
-        });
-        const generation = await this.generate({
-            generationOptions: {
-                maxOutputTokens: 2048,
-                temperature: 0.5,
-                ...options
-            },
-            generationSchema: schema,
-            systemInstruction: `You are a highly skilled data extraction AI, specializing in accurately identifying and extracting information from unstructured content 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 content.
-Identify key points and relevant information that describes the content. Focus on a general overview without providing specific details.
-Classify the content based on the provided list of types.
-Output up to ${options?.maximumNumberOfTags ?? 5} tags.
-Always output the content and tags in ${options?.targetLanguage ?? 'the same language as the content'}.`,
-            contents: this.getAnalyzeContentConents(parts)
-        });
-        return {
-            result: JSON.parse(assertNotNullPass(generation.text, 'No text returned.')),
-            raw: generation
-        };
-    }
-    getAnalyzeContentConents(parts) {
-        return [{
-                role: 'user',
-                parts: [
-                    ...toArray(parts),
-                    { text: 'Classify the document. Output as JSON.' }
-                ]
-            }];
-    }
     async callFunctions(options) {
         const generation = await this.generate({
             model: options.model,
             generationOptions: {
                 temperature: 0.5,
-                ...options
+                ...options,
             },
             systemInstruction: options.systemInstruction,
             functions: options.functions,
             functionCallingMode: options.functionCallingMode ?? 'force',
-            contents: options.contents
+            contents: options.contents,
         });
         const result = [];
         for (const call of generation.functionCalls) {
@@ -184,13 +88,13 @@ Always output the content and tags in ${options?.targetLanguage ?? 'the same lan
                 functionName: call.name,
                 parameters: parameters,
                 handlerResult: handlerResult,
-                getFunctionResultContentPart: () => ({ functionResult: { name: call.name, value: handlerResult } })
+                getFunctionResultContentPart: () => ({ functionResult: { name: call.name, value: handlerResult } }),
             });
         }
         return {
             result,
             raw: generation,
-            getFunctionResultContentParts: () => result.map((result) => result.getFunctionResultContentPart())
+            getFunctionResultContentParts: () => result.map((result) => result.getFunctionResultContentPart()),
         };
     }
     callFunctionsStream(options) {
@@ -209,17 +113,26 @@ Always output the content and tags in ${options?.targetLanguage ?? 'the same lan
     async *generateStream(request) {
         const generationNumber = ++generationCounter;
         const googleFunctionDeclarations = isDefined(request.functions) ? await this.convertFunctions(request.functions) : undefined;
-        const generationConfig = {
-            maxOutputTokens: request.generationOptions?.maxOutputTokens,
+        const config = {
+            systemInstruction: request.systemInstruction,
             temperature: request.generationOptions?.temperature,
             topP: request.generationOptions?.topP,
             topK: request.generationOptions?.topK,
+            presencePenalty: request.generationOptions?.presencePenalty,
+            frequencyPenalty: request.generationOptions?.frequencyPenalty,
             responseMimeType: isDefined(request.generationSchema) ? 'application/json' : undefined,
             responseSchema: isDefined(request.generationSchema) ? convertToOpenApiSchema(request.generationSchema) : undefined,
-            frequencyPenalty: request.generationOptions?.frequencyPenalty
+            safetySettings: [],
+            tools: (isDefined(googleFunctionDeclarations) && (googleFunctionDeclarations.length > 0)) ? [{ functionDeclarations: googleFunctionDeclarations }] : undefined,
+            toolConfig: isDefined(request.functionCallingMode)
+                ? { functionCallingConfig: { mode: functionCallingModeMap[request.functionCallingMode] } }
+                : undefined,
+            thinkingConfig: {
+                thinkingBudget: request.generationOptions?.thinkingBudget,
+            },
         };
         const model = request.model ?? this.defaultModel;
-        const maxModelTokens = model.includes('thinking') ? 65536 : 8192;
+        const maxModelTokens = await this.getModelOutputTokenLimit(model);
         const maxTotalOutputTokens = request.generationOptions?.maxOutputTokens ?? maxModelTokens;
         const inputContent = this.convertContents(request.contents);
         let iterations = 0;
@@ -231,17 +144,13 @@ Always output the content and tags in ${options?.targetLanguage ?? 'the same lan
             for (let i = 0;; i++) {
                 try {
                     this.#logger.verbose(`[C:${generationNumber}] [I:${iterations + 1}] Generating...`);
-                    generation = await this.getModel(model).generateContentStream({
-                        generationConfig: {
-                            ...generationConfig,
-                            maxOutputTokens: Math.min(maxModelTokens, maxTotalOutputTokens - totalOutputTokens)
+                    generation = await this.#genAI.models.generateContentStream({
+                        model,
+                        config: {
+                            ...config,
+                            maxOutputTokens: Math.min(maxModelTokens, maxTotalOutputTokens - totalOutputTokens),
                         },
-                        systemInstruction: request.systemInstruction,
-                        tools: (isDefined(googleFunctionDeclarations) && (googleFunctionDeclarations.length > 0)) ? [{ functionDeclarations: googleFunctionDeclarations }] : undefined,
-                        toolConfig: isDefined(request.functionCallingMode)
-                            ? { functionCallingConfig: { mode: functionCallingModeMap[request.functionCallingMode] } }
-                            : undefined,
-                        contents: inputContent
+                        contents: inputContent,
                     });
                     break;
                 }
@@ -259,12 +168,19 @@ Always output the content and tags in ${options?.targetLanguage ?? 'the same lan
             iterations++;
             let lastUsageMetadata;
             let candidate;
-            for await (const generationResponse of generation.stream) {
-                candidate = generationResponse.candidates.at(0);
-                inputContent.push(candidate.content);
+            for await (const generationResponse of generation) {
+                candidate = generationResponse.candidates?.at(0);
+                const rawContent = candidate?.content;
+                if (isUndefined(candidate)) {
+                    throw new Error('No candidate returned.');
+                }
+                if (isUndefined(rawContent)) {
+                    throw new Error('No content returned.');
+                }
+                inputContent.push(rawContent);
                 const { promptTokenCount = 0, candidatesTokenCount = 0 } = generationResponse.usageMetadata ?? {};
                 lastUsageMetadata = generationResponse.usageMetadata;
-                const content = this.convertGoogleContent(candidate.content);
+                const content = this.convertGoogleContent(rawContent);
                 let text;
                 let functionCallParts;
                 const result = {
@@ -294,13 +210,13 @@ Always output the content and tags in ${options?.targetLanguage ?? 'the same lan
                         iterations,
                         prompt: totalPromptTokens + promptTokenCount,
                         output: totalOutputTokens + candidatesTokenCount,
-                        total: totalTokens + promptTokenCount + candidatesTokenCount
-                    }
+                        total: totalTokens + promptTokenCount + candidatesTokenCount,
+                    },
                 };
                 yield result;
             }
             totalPromptTokens += lastUsageMetadata?.promptTokenCount ?? 0;
-            totalOutputTokens += lastUsageMetadata?.candidatesTokenCount ?? 0;
+            totalOutputTokens += lastUsageMetadata?.responseTokenCount ?? 0;
             totalTokens += lastUsageMetadata?.totalTokenCount ?? 0;
             if (candidate?.finishReason != FinishReason.MAX_TOKENS) {
                 break;
@@ -312,12 +228,12 @@ Always output the content and tags in ${options?.targetLanguage ?? 'the same lan
             model: options.model,
             generationOptions: {
                 temperature: 0.5,
-                ...options
+                ...options,
             },
             systemInstruction: options.systemInstruction,
             functions: options.functions,
             functionCallingMode: options.functionCallingMode ?? 'force',
-            contents: options.contents
+            contents: options.contents,
         });
         const items = [];
         for await (const generation of generationStream) {
@@ -331,12 +247,31 @@ Always output the content and tags in ${options?.targetLanguage ?? 'the same lan
                     functionName: call.name,
                     parameters: parameters,
                     handlerResult: handlerResult,
-                    getFunctionResultContentPart: () => ({ functionResult: { name: call.name, value: handlerResult } })
+                    getFunctionResultContentPart: () => ({ functionResult: { name: call.name, value: handlerResult } }),
                 };
             }
         }
         itemsPromise.resolve(items);
     }
+    async getModelOutputTokenLimit(model) {
+        const existingValue = this.#maxOutputTokensCache.get(model);
+        if (isDefined(existingValue)) {
+            return existingValue;
+        }
+        const promise = this._getModelOutputTokenLimit(model);
+        this.#maxOutputTokensCache.set(model, promise);
+        promise
+            .then((limit) => this.#maxOutputTokensCache.set(model, limit))
+            .catch(() => this.#maxOutputTokensCache.delete(model));
+        return promise;
+    }
+    async _getModelOutputTokenLimit(model) {
+        const modelInfo = await this.#genAI.models.get({ model });
+        if (isUndefined(modelInfo.outputTokenLimit)) {
+            throw new Error(`Model ${model} does not support maxOutputTokens`);
+        }
+        return modelInfo.outputTokenLimit;
+    }
     convertContents(contents) {
         return toArray(contents).map((content) => this.convertContent(content));
     }
@@ -358,7 +293,7 @@ Always output the content and tags in ${options?.targetLanguage ?? 'the same lan
                     return { functionCall: { name: part.functionCall.name, args: part.functionCall.parameters } };
                 }
                 throw new NotSupportedError('Unsupported content part.');
-            })
+            }),
         };
     }
     async convertFunctions(functions) {
@@ -371,7 +306,7 @@ Always output the content and tags in ${options?.targetLanguage ?? 'the same lan
             return {
                 name,
                 description: declaration.description,
-                parameters: isDefined(parametersSchema) ? convertToOpenApiSchema(parametersSchema) : undefined
+                parameters: isDefined(parametersSchema) ? convertToOpenApiSchema(parametersSchema) : undefined,
             };
         });
         const functionsArray = await toArrayAsync(mapped);
@@ -391,23 +326,20 @@ Always output the content and tags in ${options?.targetLanguage ?? 'the same lan
                         return { text: part.text };
                     }
                     if (isDefined(part.fileData)) {
-                        const file = assertDefinedPass(this.#fileService.getFileByUri(part.fileData.fileUri), 'File not found.');
+                        const file = assertDefinedPass(this.#fileService.getFileByUri(assertDefinedPass(part.fileData.fileUri, 'Missing file uri')), 'File not found.');
                         return { file: file.id };
                     }
                     if (isDefined(part.functionResponse)) {
-                        return { functionResult: { name: part.functionResponse.name, value: part.functionResponse.response } };
+                        return { functionResult: { name: assertDefinedPass(part.functionResponse.name, 'Missing function name'), value: part.functionResponse.response } };
                     }
                     if (isDefined(part.functionCall)) {
-                        return { functionCall: { name: part.functionCall.name, parameters: part.functionCall.args } };
+                        return { functionCall: { name: assertDefinedPass(part.functionCall.name, 'Missing function name'), parameters: part.functionCall.args } };
                     }
                     throw new NotSupportedError('Unsupported content part.');
                 })
-                    .filter(isNotNull)
+                    .filter(isNotNull),
         };
     }
-    getModel(model) {
-        return this.#genAI.getGenerativeModel({ model });
-    }
 };
 AiService = AiService_1 = __decorate([
     Singleton()
@@ -428,7 +360,7 @@ export function mergeGenerationStreamItems(items, schema) {
         },
         json() {
             if (isUndefined(schema)) {
-                return undefined;
+                return undefined; // eslint-disable-line @typescript-eslint/no-unsafe-return
             }
             if (isNull(this.text)) {
                 throw new Error('No text to parse available.');
@@ -442,6 +374,6 @@ export function mergeGenerationStreamItems(items, schema) {
             return functionCallParts;
         },
         finishReason: { value: items.at(-1).finishReason },
-        usage: { value: items.at(-1).usage }
+        usage: { value: items.at(-1).usage },
     });
 }

package/ai/functions.d.ts

@@ -1,3 +1,3 @@
-import type { FunctionDeclaration } from '@google/generative-ai';
+import type { FunctionDeclaration } from '@google/genai';
 import type { AbstractConstructor } from '../types.js';
 export declare function getFunctionDeclarations(type: AbstractConstructor): FunctionDeclaration[];

package/ai/types.d.ts

@@ -53,13 +53,15 @@ export type Content = {
 };
 export type FunctionCallingMode = 'auto' | 'force' | 'none';
 export type FinishReason = 'stop' | 'maxTokens' | 'unknown';
-export type AiModel = LiteralUnion<'gemini-2.0-flash' | 'gemini-2.0-flash-lite' | 'gemini-2.0-pro-exp-02-05' | 'gemini-2.0-flash-thinking-exp-01-21', string>;
+export type AiModel = LiteralUnion<'gemini-2.5-pro-exp-03-25' | 'gemini-2.5-flash-exp-04-17' | 'gemini-2.0-flash' | 'gemini-2.0-flash-lite', string>;
 export type GenerationOptions = {
     maxOutputTokens?: number;
     temperature?: number;
     topP?: number;
     topK?: number;
+    presencePenalty?: number;
     frequencyPenalty?: number;
+    thinkingBudget?: number;
 };
 export type GenerationRequest<S = unknown> = {
     model?: AiModel;

package/api/server/gateway.js

@@ -106,9 +106,9 @@ let ApiGateway = class ApiGateway {
                             hostname: '*',
                             port: '*',
                             search: '*',
-                            hash: '*'
+                            hash: '*',
                         }),
-                        endpoints: new Map()
+                        endpoints: new Map(),
                     };
                     this.apis.set(resource, resourceApis);
                 }
@@ -185,14 +185,14 @@ let ApiGateway = class ApiGateway {
             parameters: validatedParameters,
             body,
             request: context.request,
-            getToken: async () => this.requestTokenProvider.getToken(requestContext)
+            getToken: async () => this.requestTokenProvider.getToken(requestContext),
         };
         const result = await context.endpoint.implementation(requestContext);
         if (result instanceof HttpServerResponse) {
-            context.response.update(result); // eslint-disable-line require-atomic-updates
+            context.response.update(result);
         }
         else {
-            context.response.body = isUint8Array(result) ? { buffer: result } // eslint-disable-line require-atomic-updates
+            context.response.body = isUint8Array(result) ? { buffer: result }
                 : isBlob(result) ? { stream: result.stream() }
                     : isReadableStream(result) ? { stream: result }
                         : (result instanceof ServerSentEventsSource) ? { events: result }
@@ -204,7 +204,7 @@ let ApiGateway = class ApiGateway {
 };
 ApiGateway = __decorate([
     Singleton({
-        defaultArgumentProvider: (context) => context.resolve(API_MODULE_OPTIONS).gatewayOptions
+        defaultArgumentProvider: (context) => context.resolve(API_MODULE_OPTIONS).gatewayOptions,
     }),
     __param(1, ResolveArg('ApiGateway')),
     __param(2, InjectArg()),