@tstdl/base 0.92.29 → 0.92.31

package/ai/ai.service.d.ts

@@ -7,6 +7,9 @@ export type SpecializedGenerationResult<T> = {
     result: T;
     raw: GenerationResult;
 };
+export type SpecializedGenerationResultGenerator<T> = AsyncGenerator<T> & {
+    raw: Promise<GenerationResult>;
+};
 export declare class AiServiceOptions {
     apiKey: string;
     defaultModel?: AiModel;
@@ -44,10 +47,14 @@ export declare class AiService implements Resolvable<AiServiceArgument> {
     }): Promise<SpecializedGenerationResult<AnalyzeContentResult<T>>>;
     getAnalyzeContentConents(parts: OneOrMany<ContentPart>): Content[];
     callFunctions<const T extends SchemaFunctionDeclarations>(options: CallFunctionsOptions<T>): Promise<SpecializedGenerationResult<SchemaFunctionDeclarationsResult<T>[]>>;
+    callFunctionsStream<const T extends SchemaFunctionDeclarations>(options: CallFunctionsOptions<T>): SpecializedGenerationResultGenerator<SchemaFunctionDeclarationsResult<T>>;
     generate(request: GenerationRequest): Promise<GenerationResult>;
+    generateStream(request: GenerationRequest): AsyncGenerator<GenerationResult>;
+    private _callFunctionsStream;
     private convertContents;
     private convertContent;
     private convertFunctions;
     private convertGoogleContent;
     private getModel;
 }
+export declare function mergeGenerationStreamItems(items: GenerationResult[]): GenerationResult;

package/ai/ai.service.js

@@ -8,13 +8,15 @@ import { FinishReason, FunctionCallingMode as GoogleFunctionCallingMode, GoogleG
 import { NotSupportedError } from '../errors/not-supported.error.js';
 import { Singleton } from '../injector/decorators.js';
 import { inject, injectArgument } from '../injector/inject.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, string } 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 { hasOwnProperty, objectEntries } from '../utils/object/object.js';
-import { assertDefinedPass, assertNotNullPass, isDefined } from '../utils/type-guards.js';
+import { assertDefinedPass, assertNotNullPass, isDefined, isUndefined } from '../utils/type-guards.js';
 import { resolveValueOrAsyncProvider } from '../utils/value-or-provider.js';
 import { AiFileService } from './ai-file.service.js';
 import { AiSession } from './ai-session.js';
@@ -171,7 +173,20 @@ Always output the content and tags in ${options?.targetLanguage ?? 'the same lan
             raw: generation
         };
     }
+    callFunctionsStream(options) {
+        const itemsPromise = new DeferredPromise();
+        const generator = this._callFunctionsStream(options, itemsPromise);
+        generator.raw = new LazyPromise(async () => {
+            const items = await itemsPromise;
+            return mergeGenerationStreamItems(items);
+        });
+        return generator;
+    }
     async generate(request) {
+        const items = await toArrayAsync(this.generateStream(request));
+        return mergeGenerationStreamItems(items);
+    }
+    async *generateStream(request) {
         const googleFunctionDeclarations = isDefined(request.functions) ? await this.convertFunctions(request.functions) : undefined;
         const generationConfig = {
             maxOutputTokens: request.generationOptions?.maxOutputTokens,
@@ -183,15 +198,14 @@ Always output the content and tags in ${options?.targetLanguage ?? 'the same lan
             presencePenalty: request.generationOptions?.presencePenalty,
             frequencyPenalty: request.generationOptions?.frequencyPenalty
         };
-        const googleContent = this.convertContents(request.contents);
-        const generationContent = { role: 'model', parts: [] };
+        const inputContent = this.convertContents(request.contents);
         const maxTotalOutputTokens = request.generationOptions?.maxOutputTokens ?? 8192;
         let iterations = 0;
         let totalPromptTokens = 0;
         let totalOutputTokens = 0;
-        let candidate;
+        let totalTokens = 0;
         while (totalOutputTokens < maxTotalOutputTokens) {
-            const generation = await this.getModel(request.model ?? this.defaultModel).generateContent({
+            const generation = await this.getModel(request.model ?? this.defaultModel).generateContentStream({
                 generationConfig: {
                     ...generationConfig,
                     maxOutputTokens: Math.min(8192, maxTotalOutputTokens - totalOutputTokens)
@@ -201,40 +215,80 @@ Always output the content and tags in ${options?.targetLanguage ?? 'the same lan
                 toolConfig: isDefined(request.functionCallingMode)
                     ? { functionCallingConfig: { mode: functionCallingModeMap[request.functionCallingMode] } }
                     : undefined,
-                contents: googleContent
+                contents: inputContent
             });
             iterations++;
-            candidate = generation.response.candidates.at(0);
-            // On first generation only
-            if (generationContent.parts.length == 0) {
-                googleContent.push(generationContent);
+            let lastUsageMetadata;
+            let candidate;
+            for await (const generationResponse of generation.stream) {
+                candidate = generationResponse.candidates.at(0);
+                inputContent.push(candidate.content);
+                const { promptTokenCount = 0, candidatesTokenCount = 0 } = generationResponse.usageMetadata ?? {};
+                lastUsageMetadata = generationResponse.usageMetadata;
+                const content = this.convertGoogleContent(candidate.content);
+                let text;
+                let functionCallParts;
+                const result = {
+                    content,
+                    get text() {
+                        if (isUndefined(text)) {
+                            const textParts = content.parts.filter((part) => hasOwnProperty(part, 'text')).map((part) => part.text);
+                            text = (textParts.length > 0) ? textParts.join('') : null;
+                        }
+                        return text;
+                    },
+                    get functionCalls() {
+                        if (isUndefined(functionCallParts)) {
+                            functionCallParts = content.parts.filter((part) => hasOwnProperty(part, 'functionCall')).map((part) => part.functionCall);
+                        }
+                        return functionCallParts;
+                    },
+                    finishReason: candidate.finishReason == FinishReason.MAX_TOKENS
+                        ? 'maxTokens'
+                        : candidate.finishReason == FinishReason.STOP
+                            ? 'stop'
+                            : 'unknown',
+                    usage: {
+                        iterations,
+                        prompt: totalPromptTokens + promptTokenCount,
+                        output: totalOutputTokens + candidatesTokenCount,
+                        total: totalTokens + promptTokenCount + candidatesTokenCount
+                    }
+                };
+                yield result;
             }
-            generationContent.parts.push(...candidate.content.parts);
-            totalPromptTokens += generation.response.usageMetadata.promptTokenCount;
-            totalOutputTokens += generation.response.usageMetadata.candidatesTokenCount;
-            if (candidate.finishReason != FinishReason.MAX_TOKENS) {
+            totalPromptTokens += lastUsageMetadata?.promptTokenCount ?? 0;
+            totalOutputTokens += lastUsageMetadata?.candidatesTokenCount ?? 0;
+            totalTokens += lastUsageMetadata?.totalTokenCount ?? 0;
+            if (candidate?.finishReason != FinishReason.MAX_TOKENS) {
                 break;
             }
         }
-        const content = this.convertGoogleContent(generationContent);
-        const textParts = content.parts.filter((part) => hasOwnProperty(part, 'text')).map((part) => part.text);
-        const functionCallParts = content.parts.filter((part) => hasOwnProperty(part, 'functionCall')).map((part) => part.functionCall);
-        return {
-            content,
-            text: textParts.length > 0 ? textParts.join('') : null,
-            functionCalls: functionCallParts,
-            finishReason: candidate.finishReason == FinishReason.MAX_TOKENS
-                ? 'maxTokens'
-                : candidate.finishReason == FinishReason.STOP
-                    ? 'stop'
-                    : 'unknown',
-            usage: {
-                iterations,
-                prompt: totalPromptTokens,
-                output: totalOutputTokens,
-                total: totalPromptTokens + totalOutputTokens
+    }
+    async *_callFunctionsStream(options, itemsPromise) {
+        const generationStream = this.generateStream({
+            model: options.model,
+            generationOptions: {
+                temperature: 0.5,
+                ...options
+            },
+            systemInstruction: options.systemInstruction,
+            functions: options.functions,
+            functionCallingMode: 'force',
+            contents: options.contents
+        });
+        const items = [];
+        for await (const generation of generationStream) {
+            items.push(generation);
+            for (const call of generation.functionCalls) {
+                const fn = assertDefinedPass(options.functions[call.name], 'Function in response not declared.');
+                const parametersSchema = await resolveValueOrAsyncProvider(fn.parameters);
+                const parameters = parametersSchema.parse(call.parameters);
+                const handlerResult = isSchemaFunctionDeclarationWithHandler(fn) ? await fn.handler(parameters) : undefined;
+                yield { functionName: call.name, parameters: parameters, handlerResult: handlerResult };
             }
-        };
+        }
+        itemsPromise.resolve(items);
     }
     convertContents(contents) {
         return toArray(contents).map((content) => this.convertContent(content));
@@ -306,3 +360,26 @@ AiService = __decorate([
     Singleton()
 ], AiService);
 export { AiService };
+export function mergeGenerationStreamItems(items) {
+    const parts = items.flatMap((item) => item.content.parts);
+    let text;
+    let functionCallParts;
+    return {
+        content: { role: 'model', parts },
+        get text() {
+            if (isUndefined(text)) {
+                const textParts = parts.filter((part) => hasOwnProperty(part, 'text')).map((part) => part.text);
+                text = (textParts.length > 0) ? textParts.join('') : null;
+            }
+            return text;
+        },
+        get functionCalls() {
+            if (isUndefined(functionCallParts)) {
+                functionCallParts = parts.filter((part) => hasOwnProperty(part, 'functionCall')).map((part) => part.functionCall);
+            }
+            return functionCallParts;
+        },
+        finishReason: items.at(-1).finishReason,
+        usage: items.at(-1).usage
+    };
+}

package/enumeration/enumeration.d.ts

@@ -1,8 +1,5 @@
-import type { Tagged } from 'type-fest';
 import type { EnumerationObject } from '../types.js';
 export type EnumType<T extends EnumerationObject> = T[keyof T];
-export declare function defineEnum<const Name extends string, const T extends EnumerationObject>(name: Name, enumObject: T): {
-    [P in keyof T]: Tagged<T[P], Name>;
-};
+export declare function defineEnum<const T extends EnumerationObject>(name: string, enumObject: T): T;
 export declare function tryGetEnumName(enumeration: EnumerationObject): string | undefined;
 export declare function getEnumName(enumeration: EnumerationObject): string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.92.29",
+  "version": "0.92.31",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -163,9 +163,9 @@
     "minio": "^8.0",
     "mjml": "^4.15",
     "mongodb": "^6.12",
-    "nodemailer": "^6.9",
+    "nodemailer": "^6.10",
     "pg": "8.13",
-    "playwright": "^1.49",
+    "playwright": "^1.50",
     "preact": "^10.25",
     "preact-render-to-string": "^6.5",
     "undici": "^7.3",

package/types.d.ts

@@ -49,7 +49,7 @@ export type EnumerationArray = readonly [string | number, ...(string | number)[]
 export type EnumerationObject<V extends string | number = string | number> = Record<string, V>;
 export type EnumerationKey<T extends EnumerationObject = EnumerationObject> = Extract<keyof T, string>;
 export type EnumerationMap<T extends EnumerationObject = EnumerationObject> = SimplifyObject<{
-    [P in EnumerationKey<T>]: (T[P] extends number ? (`${T[P]}` extends `${infer U extends number}` ? U : never) : `${T[P]}`) | T[P];
+    [P in EnumerationKey<T>]: (T[P] extends number ? (`${T[P]}` extends `${infer U extends number}` ? U : never) : T[P]) | T[P];
 }>;
 export type EnumerationValue<T extends Enumeration = Enumeration> = T extends EnumerationObject ? SimplifyDeep<EnumerationMap<T>[keyof EnumerationMap<T>]> : T extends EnumerationArray ? T[number] : never;
 export type EnumerationEntry<T extends EnumerationObject = EnumerationObject> = {