@tstdl/base 0.93.35 → 0.93.37

package/ai/ai.service.js

@@ -209,8 +209,10 @@ let AiService = AiService_1 = class AiService {
         const inputContent = this.convertContents(request.contents);
         let iterations = 0;
         let totalPromptTokens = 0;
+        let totalCachedTokens = 0;
+        let totalThoughtsTokens = 0;
         let totalOutputTokens = 0;
-        let totalTokens = 0;
+        let totalToolsTokens = 0;
         while (totalOutputTokens < maxTotalOutputTokens) {
             let generation;
             let triesLeft = 10;
@@ -250,7 +252,7 @@ let AiService = AiService_1 = class AiService {
                     throw new Error('No content returned.');
                 }
                 inputContent.push(rawContent);
-                const { promptTokenCount = 0, candidatesTokenCount = 0 } = generationResponse.usageMetadata ?? {};
+                const { cachedContentTokenCount = 0, candidatesTokenCount = 0, promptTokenCount = 0, thoughtsTokenCount = 0, toolUsePromptTokenCount = 0, totalTokenCount = 0, } = generationResponse.usageMetadata ?? {};
                 lastUsageMetadata = generationResponse.usageMetadata;
                 const content = this.convertGoogleContent(rawContent);
                 let text;
@@ -280,16 +282,21 @@ let AiService = AiService_1 = class AiService {
                             : 'unknown',
                     usage: {
                         iterations,
+                        cached: totalCachedTokens + cachedContentTokenCount,
                         prompt: totalPromptTokens + promptTokenCount,
+                        thoughts: totalThoughtsTokens + thoughtsTokenCount,
                         output: totalOutputTokens + candidatesTokenCount,
-                        total: totalTokens + promptTokenCount + candidatesTokenCount,
+                        tools: totalToolsTokens + toolUsePromptTokenCount,
+                        total: totalTokenCount,
                     },
                 };
                 yield result;
             }
+            totalCachedTokens += lastUsageMetadata?.cachedContentTokenCount ?? 0;
             totalPromptTokens += lastUsageMetadata?.promptTokenCount ?? 0;
+            totalThoughtsTokens += lastUsageMetadata?.thoughtsTokenCount ?? 0;
             totalOutputTokens += lastUsageMetadata?.responseTokenCount ?? 0;
-            totalTokens += lastUsageMetadata?.totalTokenCount ?? 0;
+            totalToolsTokens += lastUsageMetadata?.toolUsePromptTokenCount ?? 0;
             if (candidate?.finishReason != FinishReason.MAX_TOKENS) {
                 break;
             }
@@ -455,7 +462,7 @@ export function mergeGenerationStreamItems(items, schema) {
             json: undefined,
             functionCalls: [],
             finishReason: 'unknown',
-            usage: { iterations: 0, prompt: 0, output: 0, total: 0 },
+            usage: { iterations: 0, cached: 0, prompt: 0, thoughts: 0, output: 0, tools: 0, total: 0 },
         };
     }
     const parts = items.flatMap((item) => item.content.parts);

package/ai/types.d.ts

@@ -168,11 +168,17 @@ export type GenerationRequest<S = unknown> = {
 export type GenerationUsage = {
     /** The number of generation iterations (usually 1, more if `maxOutputTokens` is hit and generation continues). */
     iterations: number;
-    /** The number of tokens in the prompt. */
+    /** Tokens cached.  */
+    cached: number;
+    /** Tokens used in the prompt. */
     prompt: number;
-    /** The number of tokens in the generated output. */
+    /** Tokens used for internal thoughts. */
+    thoughts: number;
+    /** Tokens in the generated output. */
     output: number;
-    /** The total number of tokens used. */
+    /** Tokens used for tools. */
+    tools: number;
+    /** Total tokens used. */
     total: number;
 };
 /**

package/package.json

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

package/schema/converters/openapi-converter.js

@@ -1,5 +1,5 @@
 import { NotSupportedError } from '../../errors/not-supported.error.js';
-import { fromEntries, hasOwnProperty, objectEntries } from '../../utils/object/object.js';
+import { filterUndefinedObjectProperties, fromEntries, hasOwnProperty, objectEntries } from '../../utils/object/object.js';
 import { isDefined, isNotNull, isNumber, isString } from '../../utils/type-guards.js';
 import { ArraySchema } from '../schemas/array.js';
 import { BooleanSchema } from '../schemas/boolean.js';
@@ -16,29 +16,36 @@ import { schemaTestableToSchema } from '../testable.js';
 export function convertToOpenApiSchema(testable) {
     const schema = schemaTestableToSchema(testable);
     const openApiSchema = convertToOpenApiSchemaBase(schema);
-    return {
+    return filterUndefinedObjectProperties({
         ...openApiSchema,
-        ...(hasOwnProperty(openApiSchema, 'nullable') ? undefined : { nullable: false }),
-        ...(isNotNull(schema.description) ? { description: schema.description } : undefined),
-        ...(isDefined(schema.example) ? { example: schema.example } : undefined),
-    };
+        nullable: hasOwnProperty(openApiSchema, 'nullable') ? undefined : false,
+        title: ((schema instanceof ObjectSchema) && (schema.name != 'Object')) ? schema.name : undefined,
+        description: isNotNull(schema.description) ? schema.description : undefined,
+        example: isDefined(schema.example) ? schema.example : undefined,
+    });
 }
 function convertToOpenApiSchemaBase(schema) {
     if (schema instanceof ObjectSchema) {
         const entries = objectEntries(schema.properties);
         const convertedEntries = entries.map(([property, propertySchema]) => [property, convertToOpenApiSchema(stripOptional(propertySchema))]);
-        return {
+        const required = entries
+            .filter(([, propertySchema]) => !(propertySchema instanceof OptionalSchema) && !((propertySchema instanceof NullableSchema) && (propertySchema.schema instanceof OptionalSchema)))
+            .map(([property]) => property);
+        return filterUndefinedObjectProperties({
             type: 'object',
             properties: fromEntries(convertedEntries),
-            required: entries
-                .filter(([, propertySchema]) => !(propertySchema instanceof OptionalSchema) && !((propertySchema instanceof NullableSchema) && (propertySchema.schema instanceof OptionalSchema)))
-                .map(([property]) => property),
-        };
+            required: (required.length > 0) ? required : undefined,
+            minProperties: isNumber(schema.minimumPropertiesCount) ? schema.minimumPropertiesCount : undefined,
+            maxProperties: isNumber(schema.maximumPropertiesCount) ? schema.maximumPropertiesCount : undefined,
+        });
     }
     if (schema instanceof StringSchema) {
-        return {
+        return filterUndefinedObjectProperties({
             type: 'string',
-        };
+            minLength: isNumber(schema.minimumLength) ? schema.minimumLength : undefined,
+            maxLength: isNumber(schema.maximumLength) ? schema.maximumLength : undefined,
+            pattern: isString(schema.pattern) ? schema.pattern : undefined,
+        });
     }
     if (schema instanceof DateSchema) {
         return {
@@ -47,11 +54,11 @@ function convertToOpenApiSchemaBase(schema) {
         };
     }
     if (schema instanceof NumberSchema) {
-        return {
+        return filterUndefinedObjectProperties({
             type: schema.integer ? 'integer' : 'number',
-            ...(isNumber(schema.minimum) ? { minimum: schema.minimum } : undefined),
-            ...(isNumber(schema.maximum) ? { maximum: schema.maximum } : undefined),
-        };
+            minimum: isNumber(schema.minimum) ? schema.minimum : undefined,
+            maximum: isNumber(schema.maximum) ? schema.maximum : undefined,
+        });
     }
     if (schema instanceof BooleanSchema) {
         return {
@@ -65,20 +72,20 @@ function convertToOpenApiSchemaBase(schema) {
         };
     }
     if (schema instanceof ArraySchema) {
-        return {
+        return filterUndefinedObjectProperties({
             type: 'array',
             items: convertToOpenApiSchema(schema.itemSchema),
-            ...(isNumber(schema.minimum) ? { minItems: schema.minimum } : undefined),
-            ...(isNumber(schema.maximum) ? { maxItems: schema.maximum } : undefined),
-        };
+            minItems: isNumber(schema.minimum) ? schema.minimum : undefined,
+            maxItems: isNumber(schema.maximum) ? schema.maximum : undefined,
+        });
     }
     if (schema instanceof EnumerationSchema) {
         const hasString = schema.allowedValues.some(isString);
         const hasNumber = schema.allowedValues.some(isNumber);
-        if (schema.allowedValues.length === 0) {
+        if (schema.allowedValues.length == 0) {
             throw new NotSupportedError('Enum must have at least one value.');
         }
-        if (!hasString && !hasNumber) {
+        if (hasString && hasNumber) {
             throw new NotSupportedError('Enum must be either string or number but not both.');
         }
         return {
@@ -102,7 +109,7 @@ function convertToOpenApiSchemaBase(schema) {
     }
     if (schema instanceof UnionSchema) {
         return {
-            oneOf: schema.schemas.map((innerSchema) => convertToOpenApiSchema(innerSchema)),
+            anyOf: schema.schemas.map((innerSchema) => convertToOpenApiSchema(innerSchema)),
         };
     }
     throw new NotSupportedError(`Schema "${schema.name}" not supported.`);

package/schema/schemas/object.d.ts

@@ -20,6 +20,8 @@ export type ObjectSchemaOptions<T extends Record = Record, K extends PropertyKey
     mask?: boolean | null;
     unknownPropertiesKey?: SchemaTestable<K> | null;
     unknownProperties?: SchemaTestable<V> | null;
+    minimumPropertiesCount?: number | null;
+    maximumPropertiesCount?: number | null;
     factory?: ObjectSchemaFactory<T> | null;
 };
 export type ObjectSchemaOrType<T extends Record = any> = ObjectSchema<T> | AbstractConstructor<T>;
@@ -40,6 +42,8 @@ export declare class ObjectSchema<T extends Record = Record> extends Schema<T> {
     readonly mask: boolean | null;
     readonly unknownProperties: Schema | null;
     readonly unknownPropertiesKey: Schema<PropertyKey> | null;
+    readonly minimumPropertiesCount: number | null;
+    readonly maximumPropertiesCount: number | null;
     readonly factory: ObjectSchemaFactory<T> | null;
     constructor(properties: ObjectSchemaProperties<T>, options?: ObjectSchemaOptions<T>);
     _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<T>;

package/schema/schemas/object.js

@@ -20,6 +20,8 @@ export class ObjectSchema extends Schema {
     mask;
     unknownProperties;
     unknownPropertiesKey;
+    minimumPropertiesCount;
+    maximumPropertiesCount;
     factory;
     constructor(properties, options = {}) {
         super(options);
@@ -27,6 +29,8 @@ export class ObjectSchema extends Schema {
         this.mask = options.mask ?? null;
         this.unknownProperties = isNotNullOrUndefined(options.unknownProperties) ? schemaTestableToSchema(options.unknownProperties) : null;
         this.unknownPropertiesKey = isNotNullOrUndefined(options.unknownPropertiesKey) ? schemaTestableToSchema(options.unknownPropertiesKey) : null;
+        this.minimumPropertiesCount = options.minimumPropertiesCount ?? null;
+        this.maximumPropertiesCount = options.maximumPropertiesCount ?? null;
         this.factory = options.factory ?? null;
         this.allowUnknownProperties = isNotNull(this.unknownProperties) || isNotNull(this.unknownPropertiesKey);
         this.propertyKeys = new Set(objectKeys(properties));
@@ -38,7 +42,14 @@ export class ObjectSchema extends Schema {
         }
         const mask = this.mask ?? options.mask ?? false;
         const resultValue = isLiteralObject(this.factory) ? new this.factory.type() : {};
-        const valueKeys = new Set(objectKeys(value));
+        const keys = objectKeys(value);
+        if (isNotNull(this.minimumPropertiesCount) && (keys.length < this.minimumPropertiesCount)) {
+            return { valid: false, error: new SchemaError(`Object has too few properties (minimum ${this.minimumPropertiesCount}, got ${keys.length}).`, { path, fast: options.fastErrors }) };
+        }
+        if (isNotNull(this.maximumPropertiesCount) && (keys.length > this.maximumPropertiesCount)) {
+            return { valid: false, error: new SchemaError(`Object has too many properties (maximum ${this.maximumPropertiesCount}, got ${keys.length}).`, { path, fast: options.fastErrors }) };
+        }
+        const valueKeys = new Set(keys);
         const unknownValuePropertyKeys = valueKeys.difference(this.propertyKeys);
         if ((unknownValuePropertyKeys.size > 0) && !mask && !this.allowUnknownProperties) {
             return { valid: false, error: new SchemaError('Unexpected property', { path: path.add(unknownValuePropertyKeys.values().next().value), fast: options.fastErrors }) };

package/schema/schemas/string.d.ts

@@ -3,11 +3,15 @@ import { SimpleSchema, type SimpleSchemaOptions } from './simple.js';
 export type StringSchemaOptions = SimpleSchemaOptions<string> & {
     pattern?: RegExp | string;
     lowercase?: boolean;
+    minimumLength?: number;
+    maximumLength?: number;
 };
 export declare class StringSchema extends SimpleSchema<string> {
     readonly name: string;
     readonly pattern: RegExp | null;
     readonly lowercase: boolean;
+    readonly minimumLength: number | null;
+    readonly maximumLength: number | null;
     constructor(options?: StringSchemaOptions);
 }
 export declare function string(options?: StringSchemaOptions): StringSchema;

package/schema/schemas/string.js

@@ -5,6 +5,8 @@ export class StringSchema extends SimpleSchema {
     name = 'string';
     pattern;
     lowercase;
+    minimumLength;
+    maximumLength;
     constructor(options) {
         super('string', isString, options, {
             coercers: {
@@ -16,6 +18,12 @@ export class StringSchema extends SimpleSchema {
                 isDefined(options?.pattern)
                     ? (value) => this.pattern.test(value) ? ({ success: true }) : ({ success: false, error: 'Value did not match pattern.' })
                     : null,
+                isDefined(options?.minimumLength)
+                    ? (value) => (value.length >= this.minimumLength) ? ({ success: true }) : ({ success: false, error: `String length is less than minimum length of ${this.minimumLength}.` })
+                    : null,
+                isDefined(options?.maximumLength)
+                    ? (value) => (value.length <= this.maximumLength) ? ({ success: true }) : ({ success: false, error: `String length exceeds maximum length of ${this.maximumLength}.` })
+                    : null,
             ],
             transformers: (options?.lowercase ?? false) ? (value) => value.toLowerCase() : undefined,
         });
@@ -24,6 +32,9 @@ export class StringSchema extends SimpleSchema {
             : isRegExp(options?.pattern)
                 ? options.pattern
                 : null;
+        this.lowercase = options?.lowercase ?? false;
+        this.minimumLength = options?.minimumLength ?? null;
+        this.maximumLength = options?.maximumLength ?? null;
     }
 }
 export function string(options) {

package/test1.js

@@ -14,6 +14,7 @@ import { migrateTestSchema } from './test/module.js';
 import { Test, testData } from './test/test.model.js';
 import { timedBenchmarkAsync } from './utils/benchmark.js';
 import * as configParser from './utils/config-parser.js';
+import { string } from './utils/config-parser.js';
 const config = {
     database: {
         host: configParser.string('DATABASE_HOST', '127.0.0.1'),
@@ -22,6 +23,14 @@ const config = {
         pass: configParser.string('DATABASE_PASS', 'wf7rq6glrk5jykne'),
         database: configParser.string('DATABASE_NAME', 'tstdl'),
     },
+    ai: {
+        apiKey: string('AI_API_KEY', undefined),
+        keyFile: string('AI_API_KEY_FILE', undefined),
+        vertex: {
+            project: string('AI_VERTEX_PROJECT', undefined),
+            location: string('AI_VERTEX_LOCATION', undefined),
+        },
+    },
 };
 async function bootstrap() {
     const injector = inject(Injector);
@@ -30,7 +39,7 @@ async function bootstrap() {
             project: '922353391551', // insolytics-application
             location: 'europe-west4', // netherlands
         },
-        keyFile: '/home/patrick/.secret-files/insolytics-application-service-key.json',
+        keyFile: '/home/patrick/.secret-files/insolytic-application-service-key.json',
     });
     /*
     configureOrm({
@@ -65,20 +74,22 @@ async function bootstrap() {
 }
 async function main(_cancellationSignal) {
     const aiService = inject(AiService);
-    const aiResult = await aiService.generate({
+    const aiStream = aiService.generateStream({
         generationOptions: {
             includeThoughts: true,
+            thinkingBudget: 1000,
         },
         model: 'gemini-2.5-flash-lite',
         contents: [{
                 role: 'user',
                 parts: [
-                    { text: 'asd' },
+                    { text: 'Count from 1 to 1000. List *every* number.' },
                 ],
             }],
     });
-    console.log('AI Result:', aiResult);
-    console.log(aiResult.content);
+    for await (const { text, usage } of aiStream) {
+        console.log({ text, usage });
+    }
     if (1 + 1 == 2)
         process.exit(0);
 }