@tstdl/base 0.92.14 → 0.92.16

package/ai/ai-session.d.ts

@@ -1,18 +1,11 @@
-import type { SchemaTestable } from '../schema/index.js';
-import type { Enumeration, OneOrMany, TypedOmit } from '../types.js';
-import type { AiService, AnalyzeContentResult, ClassificationResult, SpecializedGenerationResult } from './ai.service.js';
-import type { Content, ContentPart, GenerationOptions, GenerationRequest, GenerationResult, SchemaFunctionDeclarations, SchemaFunctionDeclarationsResult } from './types.js';
+import type { OneOrMany } from '../types.js';
+import type { AiService, CallFunctionsOptions, SpecializedGenerationResult } from './ai.service.js';
+import type { Content, GenerationRequest, GenerationResult, SchemaFunctionDeclarations, SchemaFunctionDeclarationsResult } from './types.js';
 export declare class AiSession {
     #private;
     readonly contents: Content[];
     constructor(aiService: AiService);
     addContent(content: OneOrMany<Content>): void;
-    analyzeContent<T extends Enumeration>(parts: OneOrMany<ContentPart>, types: T, options?: GenerationOptions & {
-        targetLanguage?: string;
-        maximumNumberOfTags?: number;
-    }): Promise<SpecializedGenerationResult<AnalyzeContentResult<T>>>;
-    classify<T extends Enumeration>(parts: OneOrMany<ContentPart>, types: T, options?: GenerationOptions & Pick<GenerationRequest, 'model'>): Promise<SpecializedGenerationResult<ClassificationResult<T>>>;
-    extractData<T>(parts: OneOrMany<ContentPart>, schema: SchemaTestable<T>, options?: GenerationOptions & Pick<GenerationRequest, 'model'>): Promise<SpecializedGenerationResult<T>>;
-    callFunctions<const T extends SchemaFunctionDeclarations>(functions: T, content: Content | [Content, ...Content[]], options?: Pick<GenerationRequest, 'model' | 'systemInstruction'> & GenerationOptions): Promise<SpecializedGenerationResult<SchemaFunctionDeclarationsResult<T>[]>>;
-    generate(content: Content | [Content, ...Content[]], request?: TypedOmit<GenerationRequest, 'contents'>): Promise<GenerationResult>;
+    callFunctions<const T extends SchemaFunctionDeclarations>(options: CallFunctionsOptions<T>): Promise<SpecializedGenerationResult<SchemaFunctionDeclarationsResult<T>[]>>;
+    generate(request: GenerationRequest): Promise<GenerationResult>;
 }

package/ai/ai-session.js

@@ -8,35 +8,14 @@ export class AiSession {
     addContent(content) {
         this.contents.push(...toArray(content));
     }
-    async analyzeContent(parts, types, options) {
-        const newContents = this.#aiService.getAnalyzeContentConents(parts);
-        this.contents.push(...newContents);
-        const result = await this.#aiService.analyzeContent(parts, types, options);
+    async callFunctions(options) {
+        this.contents.push(...toArray(options.contents));
+        const result = await this.#aiService.callFunctions({ ...options, contents: this.contents });
         this.contents.push(result.raw.content);
         return result;
     }
-    async classify(parts, types, options) {
-        const newContents = this.#aiService.getExtractDataConents(parts);
-        this.contents.push(...newContents);
-        const result = await this.#aiService.classify(parts, types, options);
-        this.contents.push(result.raw.content);
-        return result;
-    }
-    async extractData(parts, schema, options) {
-        const newContents = this.#aiService.getExtractDataConents(parts);
-        this.contents.push(...newContents);
-        const result = await this.#aiService.extractData(parts, schema, options);
-        this.contents.push(result.raw.content);
-        return result;
-    }
-    async callFunctions(functions, content, options) {
-        this.contents.push(...toArray(content));
-        const result = await this.#aiService.callFunctions(functions, this.contents, options);
-        this.contents.push(result.raw.content);
-        return result;
-    }
-    async generate(content, request) {
-        this.contents.push(...toArray(content));
+    async generate(request) {
+        this.contents.push(...toArray(request.contents));
         const result = await this.#aiService.generate({ ...request, contents: this.contents });
         this.contents.push(result.content);
         return result;

package/ai/ai.service.d.ts

@@ -1,4 +1,3 @@
-import '../polyfills.js';
 import { Resolvable, type resolveArgumentType } from '../injector/interfaces.js';
 import { OneOrMany, SchemaTestable } from '../schema/index.js';
 import { Enumeration as EnumerationType, EnumerationValue } from '../types.js';
@@ -24,6 +23,9 @@ export type AnalyzeContentResult<T extends EnumerationType> = {
     documentTypes: ClassificationResult<T>[];
     tags: string[];
 };
+export type CallFunctionsOptions<T extends SchemaFunctionDeclarations> = Pick<GenerationRequest, 'contents' | 'model' | 'systemInstruction'> & GenerationOptions & {
+    functions: T;
+};
 export declare class AiService implements Resolvable<AiServiceArgument> {
     #private;
     readonly defaultModel: AiModel;
@@ -40,7 +42,7 @@ export declare class AiService implements Resolvable<AiServiceArgument> {
         maximumNumberOfTags?: number;
     }): Promise<SpecializedGenerationResult<AnalyzeContentResult<T>>>;
     getAnalyzeContentConents(parts: OneOrMany<ContentPart>): Content[];
-    callFunctions<const T extends SchemaFunctionDeclarations>(functions: T, contents: Content[], options?: Pick<GenerationRequest, 'model' | 'systemInstruction'> & GenerationOptions): Promise<SpecializedGenerationResult<SchemaFunctionDeclarationsResult<T>[]>>;
+    callFunctions<const T extends SchemaFunctionDeclarations>(options: CallFunctionsOptions<T>): Promise<SpecializedGenerationResult<SchemaFunctionDeclarationsResult<T>[]>>;
     generate(request: GenerationRequest): Promise<GenerationResult>;
     private convertContents;
     private convertContent;

package/ai/ai.service.js

@@ -4,8 +4,7 @@ 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;
 };
-import '../polyfills.js';
-import { FunctionCallingMode as GoogleFunctionCallingMode, GoogleGenerativeAI } from '@google/generative-ai';
+import { FinishReason, FunctionCallingMode as GoogleFunctionCallingMode, GoogleGenerativeAI } from '@google/generative-ai';
 import { NotSupportedError } from '../errors/not-supported.error.js';
 import { Singleton } from '../injector/decorators.js';
 import { inject, injectArgument } from '../injector/inject.js';
@@ -47,7 +46,7 @@ let AiService = class AiService {
             model: options?.model,
             generationOptions: {
                 maxOutputTokens: 1048,
-                temperature: 0.5,
+                temperature: 0.25,
                 ...options
             },
             generationSchema,
@@ -72,7 +71,7 @@ let AiService = class AiService {
         const generation = await this.generate({
             model: options?.model,
             generationOptions: {
-                temperature: 0.5,
+                temperature: 0.25,
                 ...options
             },
             generationSchema: schema,
@@ -108,7 +107,7 @@ Carefully read and analyze the provided document. Identify relevant information
         const generation = await this.generate({
             generationOptions: {
                 maxOutputTokens: 2048,
-                temperature: 0.5,
+                temperature: 0.25,
                 ...options
             },
             generationSchema: schema,
@@ -136,22 +135,21 @@ Always output the content and tags in ${options?.targetLanguage ?? 'the same lan
                 ]
             }];
     }
-    async callFunctions(functions, contents, options) {
+    async callFunctions(options) {
         const generation = await this.generate({
-            model: options?.model,
+            model: options.model,
             generationOptions: {
-                maxOutputTokens: 4096,
-                temperature: 0.5,
+                temperature: 0.25,
                 ...options
             },
-            systemInstruction: options?.systemInstruction,
-            functions,
+            systemInstruction: options.systemInstruction,
+            functions: options.functions,
             functionCallingMode: 'force',
-            contents
+            contents: options.contents
         });
         const result = [];
         for (const call of generation.functionCalls) {
-            const fn = assertDefinedPass(functions[call.name], 'Function in response not declared.');
+            const fn = assertDefinedPass(options.functions[call.name], 'Function in response not declared.');
             const parameters = fn.parameters.parse(call.parameters);
             const handlerResult = isSchemaFunctionDeclarationWithHandler(fn) ? await fn.handler(parameters) : undefined;
             result.push({ functionName: call.name, parameters: parameters, handlerResult: handlerResult });
@@ -162,36 +160,72 @@ Always output the content and tags in ${options?.targetLanguage ?? 'the same lan
         };
     }
     async generate(request) {
-        const googleContent = this.convertContents(request.contents);
         const googleFunctionDeclarations = isDefined(request.functions) ? this.convertFunctions(request.functions) : undefined;
-        const generationConfig = isDefined(request.generationSchema)
-            ? { ...request.generationOptions, responseMimeType: 'application/json', responseSchema: convertToOpenApiSchema(request.generationSchema) }
-            : request.generationOptions;
-        const generation = await this.getModel(request.model ?? this.defaultModel).generateContent({
-            generationConfig,
-            systemInstruction: request.systemInstruction,
-            tools: isDefined(googleFunctionDeclarations) ? [{ functionDeclarations: googleFunctionDeclarations }] : undefined,
-            toolConfig: isDefined(request.functionCallingMode)
-                ? { functionCallingConfig: { mode: functionCallingModeMap[request.functionCallingMode] } }
-                : undefined,
-            contents: googleContent
-        });
-        const content = this.convertGoogleContent(generation.response.candidates.at(0).content);
+        const generationConfig = {
+            maxOutputTokens: request.generationOptions?.maxOutputTokens,
+            temperature: request.generationOptions?.temperature,
+            topP: request.generationOptions?.topP,
+            topK: request.generationOptions?.topK,
+            responseMimeType: isDefined(request.generationSchema) ? 'application/json' : undefined,
+            responseSchema: isDefined(request.generationSchema) ? convertToOpenApiSchema(request.generationSchema) : undefined,
+            presencePenalty: request.generationOptions?.presencePenalty,
+            frequencyPenalty: request.generationOptions?.frequencyPenalty
+        };
+        const googleContent = this.convertContents(request.contents);
+        const generationContent = { role: 'model', parts: [] };
+        const maxTotalOutputTokens = request.generationOptions?.maxOutputTokens ?? 8192;
+        let iterations = 0;
+        let totalPromptTokens = 0;
+        let totalOutputTokens = 0;
+        let candidate;
+        while (totalOutputTokens < maxTotalOutputTokens) {
+            const generation = await this.getModel(request.model ?? this.defaultModel).generateContent({
+                generationConfig: {
+                    ...generationConfig,
+                    maxOutputTokens: Math.min(8192, maxTotalOutputTokens - totalOutputTokens)
+                },
+                systemInstruction: request.systemInstruction,
+                tools: isDefined(googleFunctionDeclarations) ? [{ functionDeclarations: googleFunctionDeclarations }] : undefined,
+                toolConfig: isDefined(request.functionCallingMode)
+                    ? { functionCallingConfig: { mode: functionCallingModeMap[request.functionCallingMode] } }
+                    : undefined,
+                contents: googleContent
+            });
+            iterations++;
+            candidate = generation.response.candidates.at(0);
+            // On first generation only
+            if (generationContent.parts.length == 0) {
+                googleContent.push(generationContent);
+            }
+            generationContent.parts.push(...candidate.content.parts);
+            totalPromptTokens += generation.response.usageMetadata.promptTokenCount;
+            totalOutputTokens += generation.response.usageMetadata.candidatesTokenCount;
+            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: {
-                prompt: generation.response.usageMetadata.promptTokenCount,
-                output: generation.response.usageMetadata.candidatesTokenCount,
-                total: generation.response.usageMetadata.totalTokenCount
+                iterations,
+                prompt: totalPromptTokens,
+                output: totalOutputTokens,
+                total: totalPromptTokens + totalOutputTokens
             }
         };
     }
     convertContents(contents) {
-        return contents.map((content) => this.convertContent(content));
+        return toArray(contents).map((content) => this.convertContent(content));
     }
     convertContent(content) {
         return {

package/ai/types.d.ts

@@ -49,6 +49,7 @@ export type Content = {
     parts: readonly ContentPart[];
 };
 export type FunctionCallingMode = 'auto' | 'force' | 'none';
+export type FinishReason = 'stop' | 'maxTokens' | 'unknown';
 export type AiModel = LiteralUnion<'gemini-2.0-flash-exp' | 'gemini-exp-1206' | 'gemini-2.0-flash-thinking-exp-1219', string>;
 export type GenerationOptions = {
     maxOutputTokens?: number;
@@ -61,13 +62,14 @@ export type GenerationOptions = {
 export type GenerationRequest = {
     model?: AiModel;
     systemInstruction?: string;
-    contents: readonly Content[];
+    contents: Content | readonly Content[];
     functions?: SchemaFunctionDeclarations;
     functionCallingMode?: FunctionCallingMode;
     generationSchema?: SchemaTestable;
     generationOptions?: GenerationOptions;
 };
 export type GenerationUsage = {
+    iterations: number;
     prompt: number;
     output: number;
     total: number;
@@ -76,6 +78,7 @@ export type GenerationResult = {
     content: Content;
     text: string | null;
     functionCalls: FunctionCall[];
+    finishReason: FinishReason;
     usage: GenerationUsage;
 };
 export declare function declareFunctions<T extends SchemaFunctionDeclarations>(declarations: T): T;

package/authentication/server/authentication.service.d.ts

@@ -1,8 +1,7 @@
-import type { AfterResolve } from '../../injector/index.js';
-import { afterResolve } from '../../injector/index.js';
-import type { Record } from '../../types.js';
+import { AfterResolve, afterResolve } from '../../injector/index.js';
+import type { BinaryData, Record } from '../../types.js';
 import type { RefreshToken, SecretCheckResult, SecretResetToken, Token } from '../models/index.js';
-import type { SecretTestResult } from './authentication-secret-requirements.validator.js';
+import { SecretTestResult } from './authentication-secret-requirements.validator.js';
 export type CreateTokenData<AdditionalTokenPayload extends Record> = {
     tokenVersion?: number;
     jwtId?: string;

package/authentication/server/helper.d.ts

@@ -1,5 +1,5 @@
 import type { HttpServerRequest } from '../../http/server/index.js';
-import type { Record } from '../../types.js';
+import type { BinaryData, Record } from '../../types.js';
 import type { RefreshToken, SecretResetToken, Token } from '../models/index.js';
 /**
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.92.14",
+  "version": "0.92.16",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -144,7 +144,7 @@
     "tsx": "^4.19.2",
     "typedoc": "0.27",
     "typedoc-plugin-missing-exports": "3.1",
-    "typescript": "5.6"
+    "typescript": "5.7"
   },
   "peerDependencies": {
     "@elastic/elasticsearch": "^8.17",

package/rpc/rpc.js

@@ -137,7 +137,8 @@ function createProxy(channel, path = []) {
             handlers[method] = deferThrow(() => new NotSupportedError(`${method} not supported on rpc proxies.`));
         }
     }
-    return new Proxy(RpcProxy, handlers);
+    proxy = new Proxy(RpcProxy, handlers);
+    return proxy;
 }
 function exposeObject(object, channel) {
     const { endpoint } = channel;

package/serializer/handlers/binary.d.ts

@@ -4,7 +4,7 @@ interface TypedArrayConstructor {
     new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): TypedArray;
 }
 export declare function serializeArrayBuffer(buffer: ArrayBuffer): string;
-export declare function deserializeArrayBuffer(data: string): ArrayBuffer;
+export declare function deserializeArrayBuffer(data: string): ArrayBufferLike;
 export declare function serializeTypedArray(array: TypedArray): string;
 export declare function getTypedArrayDeserializer(constructor: TypedArrayConstructor): (data: string) => TypedArray;
 export declare function serializeBuffer(buffer: Buffer): string;

package/utils/binary.d.ts

@@ -4,14 +4,13 @@ import type { BinaryData, Type } from '../types.js';
  * @param data data to get ArrayBuffer from
  * @param clone force cloning (might still clone if datas underlying buffer is larger than its view)
  */
-export declare function toArrayBuffer(data: BinaryData, clone?: boolean): ArrayBuffer;
+export declare function toArrayBuffer(data: BinaryData, clone?: boolean): ArrayBufferLike;
 /**
- * eslint-disable-next-line @typescript-eslint/no-shadow
- * convert to Uint8Array
+ * Convert to Uint8Array
  * @param data binary data
  * @param clone whether to clone buffer or not
  */
 export declare function toUint8Array(data: BinaryData, clone?: boolean): Uint8Array;
-export declare function concatArrayBuffers(buffers: ArrayBufferLike[]): ArrayBuffer;
+export declare function concatArrayBuffers(buffers: ArrayBufferLike[]): ArrayBufferLike;
 export declare function concatArrayBufferViews<T extends ArrayBufferView>(arrays: T[], totalLength?: number): T;
 export declare function concatArrayBufferViews<T extends ArrayBufferView>(arrays: ArrayBufferView[], targetType: Type<T, [ArrayBufferLike, number, number]>, totalLength?: number): T;

package/utils/binary.js

@@ -16,8 +16,7 @@ export function toArrayBuffer(data, clone = false) {
     return data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
 }
 /**
- * eslint-disable-next-line @typescript-eslint/no-shadow
- * convert to Uint8Array
+ * Convert to Uint8Array
  * @param data binary data
  * @param clone whether to clone buffer or not
  */

package/utils/type-guards.d.ts

@@ -1,4 +1,4 @@
-import type { AbstractConstructor, JsonPrimitive, PascalCase, Primitive, TypedArray } from '../types.js';
+import type { AbstractConstructor, BinaryData, JsonPrimitive, PascalCase, Primitive, TypedArray } from '../types.js';
 export type AssertionMessage = string | (() => string);
 export type IsFunction<T> = <U extends T = T>(value: any) => value is U;
 export type IsNotFunction<T> = <V>(value: V) => value is Exclude<V, T>;