@tstdl/base 0.92.19 → 0.92.21

package/ai/ai.service.d.ts

@@ -33,6 +33,7 @@ export declare class AiService implements Resolvable<AiServiceArgument> {
     createSession(): AiSession;
     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>>>;
     getClassifyConents(parts: OneOrMany<ContentPart>): Content[];
     extractData<T>(parts: OneOrMany<ContentPart>, schema: SchemaTestable<T>, options?: GenerationOptions & Pick<GenerationRequest, 'model'>): Promise<SpecializedGenerationResult<T>>;

package/ai/ai.service.js

@@ -11,8 +11,11 @@ import { inject, injectArgument } from '../injector/inject.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 { resolveValueOrAsyncProvider } from '../utils/value-or-provider.js';
 import { AiFileService } from './ai-file.service.js';
 import { AiSession } from './ai-session.js';
 import { isSchemaFunctionDeclarationWithHandler } from './types.js';
@@ -40,6 +43,9 @@ let AiService = class AiService {
     async processFiles(fileInputs) {
         return this.#fileService.processFiles(fileInputs);
     }
+    getFileById(id) {
+        return { file: id };
+    }
     async classify(parts, types, options) {
         const generationSchema = object({
             types: nullable(array(object({
@@ -155,7 +161,8 @@ Always output the content and tags in ${options?.targetLanguage ?? 'the same lan
         const result = [];
         for (const call of generation.functionCalls) {
             const fn = assertDefinedPass(options.functions[call.name], 'Function in response not declared.');
-            const parameters = fn.parameters.parse(call.parameters);
+            const parametersSchema = await resolveValueOrAsyncProvider(fn.parameters);
+            const parameters = parametersSchema.parse(call.parameters);
             const handlerResult = isSchemaFunctionDeclarationWithHandler(fn) ? await fn.handler(parameters) : undefined;
             result.push({ functionName: call.name, parameters: parameters, handlerResult: handlerResult });
         }
@@ -165,7 +172,7 @@ Always output the content and tags in ${options?.targetLanguage ?? 'the same lan
         };
     }
     async generate(request) {
-        const googleFunctionDeclarations = isDefined(request.functions) ? this.convertFunctions(request.functions) : undefined;
+        const googleFunctionDeclarations = isDefined(request.functions) ? await this.convertFunctions(request.functions) : undefined;
         const generationConfig = {
             maxOutputTokens: request.generationOptions?.maxOutputTokens,
             temperature: request.generationOptions?.temperature,
@@ -253,12 +260,16 @@ Always output the content and tags in ${options?.targetLanguage ?? 'the same lan
             })
         };
     }
-    convertFunctions(functions) {
-        return objectEntries(functions).map(([name, declaration]) => ({
-            name,
-            description: declaration.description,
-            parameters: convertToOpenApiSchema(declaration.parameters)
-        }));
+    async convertFunctions(functions) {
+        const mapped = mapAsync(objectEntries(functions), async ([name, declaration]) => {
+            const parametersSchema = await resolveValueOrAsyncProvider(declaration.parameters);
+            return {
+                name,
+                description: declaration.description,
+                parameters: convertToOpenApiSchema(parametersSchema)
+            };
+        });
+        return toArrayAsync(mapped);
     }
     convertGoogleContent(content) {
         return {

package/ai/functions.d.ts

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

package/ai/functions.js

@@ -2,14 +2,6 @@ import { convertToOpenApiSchema } from '../schema/converters/openapi-converter.j
 import { FunctionSchema, getObjectSchema, object } from '../schema/index.js';
 import { fromEntries, objectEntries } from '../utils/object/object.js';
 import { isNotNull, isNull, isString } from '../utils/type-guards.js';
-export function convertFunctionDeclarations(declarations) {
-    return objectEntries(declarations)
-        .map(([name, declaration]) => ({
-        name,
-        description: declaration.description,
-        parameters: convertToOpenApiSchema(declaration.parameters)
-    }));
-}
 export function getFunctionDeclarations(type) {
     const objectSchema = getObjectSchema(type);
     return objectEntries(objectSchema.properties)

package/ai/types.d.ts

@@ -1,6 +1,7 @@
 import type { LiteralUnion } from 'type-fest';
 import type { ObjectSchema, SchemaOutput, SchemaTestable } from '../schema/index.js';
 import type { Record, UndefinableJsonObject } from '../types.js';
+import type { ResolvedValueOrProvider, ValueOrAsyncProvider } from '../utils/value-or-provider.js';
 export type FileInput = {
     path: string;
     mimeType: string;
@@ -8,7 +9,7 @@ export type FileInput = {
 export type SchemaFunctionDeclarations = Record<string, SchemaFunctionDeclaration<any>>;
 export type SchemaFunctionDeclarationWithoutHandler<T extends Record = Record> = {
     description: string;
-    parameters: ObjectSchema<T>;
+    parameters: ValueOrAsyncProvider<ObjectSchema<T>>;
 };
 export type SchemaFunctionDeclarationWithHandler<T extends Record = Record, R = unknown> = SchemaFunctionDeclarationWithoutHandler<T> & {
     handler: (parameters: T) => R | Promise<R>;
@@ -18,7 +19,7 @@ export type SchemaFunctionDeclarationHandlerResult<T extends SchemaFunctionDecla
 export type SchemaFunctionDeclarationsResult<T extends SchemaFunctionDeclarations = SchemaFunctionDeclarations> = {
     [P in keyof T]: {
         functionName: P;
-        parameters: SchemaOutput<T[P]['parameters']>;
+        parameters: SchemaOutput<ResolvedValueOrProvider<T[P]['parameters']>>;
         handlerResult: SchemaFunctionDeclarationHandlerResult<T[P]>;
     };
 }[keyof T];

package/http/client/http-client-response.d.ts

@@ -1,8 +1,6 @@
 import type { TypedOmit } from '../../types.js';
-import type { HttpBodySource } from '../http-body.js';
-import { HttpBody } from '../http-body.js';
-import type { HttpHeadersObject } from '../http-headers.js';
-import { HttpHeaders } from '../http-headers.js';
+import { HttpBody, type HttpBodySource } from '../http-body.js';
+import { HttpHeaders, type HttpHeadersObject } from '../http-headers.js';
 import type { HttpClientRequest, HttpClientRequestObject } from './http-client-request.js';
 export type HttpClientResponseObject = TypedOmit<HttpClientResponse, 'hasBody' | 'request' | 'headers' | 'close' | 'asObject'> & {
     request: HttpClientRequestObject;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.92.19",
+  "version": "0.92.21",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -121,7 +121,7 @@
     "luxon": "^3.5",
     "reflect-metadata": "^0.2",
     "rxjs": "^7.8",
-    "type-fest": "4.32"
+    "type-fest": "4.33"
   },
   "devDependencies": {
     "@mxssfd/typedoc-theme": "1.1",
@@ -134,7 +134,7 @@
     "@types/node": "22",
     "@types/nodemailer": "6.4",
     "@types/pg": "8.11",
-    "@typescript-eslint/eslint-plugin": "8.20",
+    "@typescript-eslint/eslint-plugin": "8.21",
     "concurrently": "9.1",
     "drizzle-kit": "0.30",
     "eslint": "8.57",
@@ -167,7 +167,7 @@
     "playwright": "^1.49",
     "preact": "^10.25",
     "preact-render-to-string": "^6.5",
-    "undici": "^7.2",
+    "undici": "^7.3",
     "urlpattern-polyfill": "^10.0"
   },
   "peerDependenciesMeta": {

package/types.d.ts

@@ -46,7 +46,7 @@ export type UndefinableJsonArray = UndefinableJsonInnerNode[] | readonly Undefin
 export type ArrayItem<T extends readonly any[]> = T extends readonly (infer U)[] ? U : never;
 export type Enumeration = EnumerationArray | EnumerationObject;
 export type EnumerationArray = readonly [string | number, ...(string | number)[]];
-export type EnumerationObject = Record<string, 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];

package/utils/enum.d.ts

@@ -1,6 +1,9 @@
 import type { EnumerationEntries, EnumerationKey, EnumerationObject, EnumerationValue } from '../types.js';
-export declare function enumValueName<T extends EnumerationObject>(enumeration: T, value: T[keyof T]): string;
+export declare function enumValueName<T extends EnumerationObject>(enumeration: T, value: T[keyof T]): EnumerationKey<T>;
 export declare function enumEntries<T extends EnumerationObject>(enumeration: T): EnumerationEntries<T>;
 export declare function enumKeys<T extends EnumerationObject>(enumeration: T): EnumerationKey<T>[];
 export declare function enumValues<T extends EnumerationObject>(enumeration: T): EnumerationValue<T>[];
 export declare function randomEnumValue<T extends EnumerationObject>(enumeration: T): EnumerationValue<T>;
+export declare function reversedEnum<T extends EnumerationObject>(enumeration: T): {
+    [P in keyof T as T[P]]: P;
+};

package/utils/enum.js

@@ -1,7 +1,6 @@
 import { randomItem } from './array/array.js';
 import { memoizeSingle } from './function/memoize.js';
-import { objectEntries } from './object/object.js';
-import { isNumber } from './type-guards.js';
+import { mapObject, objectEntries } from './object/object.js';
 const memoizedEnumEntries = memoizeSingle((enumeration) => objectEntries(enumeration).filter((entry) => Number.isNaN(Number(entry[0]))), { weak: true });
 const memoizedEnumKeys = memoizeSingle((enumeration) => {
     const entries = enumEntries(enumeration);
@@ -11,8 +10,9 @@ const memoizedEnumValues = memoizeSingle((enumeration) => {
     const entries = enumEntries(enumeration);
     return entries.map((entry) => entry[1]);
 }, { weak: true });
+const memoizedReversedEnum = memoizeSingle((enumeration) => mapObject(enumeration, (value, key) => [value, key]), { weak: true });
 export function enumValueName(enumeration, value) {
-    return isNumber(value) ? enumeration[value]?.toString() ?? value.toString() : value;
+    return reversedEnum(enumeration)[value];
 }
 export function enumEntries(enumeration) {
     return memoizedEnumEntries(enumeration);
@@ -26,3 +26,6 @@ export function enumValues(enumeration) {
 export function randomEnumValue(enumeration) {
     return randomItem(enumValues(enumeration));
 }
+export function reversedEnum(enumeration) {
+    return memoizedReversedEnum(enumeration);
+}