@tstdl/base 0.92.22 → 0.92.24

package/ai/ai.service.js

@@ -262,6 +262,10 @@ Always output the content and tags in ${options?.targetLanguage ?? 'the same lan
     }
     async convertFunctions(functions) {
         const mapped = mapAsync(objectEntries(functions), async ([name, declaration]) => {
+            const enabled = await resolveValueOrAsyncProvider(declaration.enabled);
+            if (enabled == false) {
+                return undefined;
+            }
             const parametersSchema = await resolveValueOrAsyncProvider(declaration.parameters);
             return {
                 name,
@@ -269,7 +273,8 @@ Always output the content and tags in ${options?.targetLanguage ?? 'the same lan
                 parameters: convertToOpenApiSchema(parametersSchema)
             };
         });
-        return toArrayAsync(mapped);
+        const functionsArray = await toArrayAsync(mapped);
+        return functionsArray.filter(isDefined);
     }
     convertGoogleContent(content) {
         return {

package/ai/types.d.ts

@@ -1,5 +1,5 @@
 import type { LiteralUnion } from 'type-fest';
-import type { ObjectSchema, SchemaOutput, SchemaTestable } from '../schema/index.js';
+import { type ObjectSchema, type SchemaOutput, type 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 = {
@@ -10,6 +10,7 @@ export type SchemaFunctionDeclarations = Record<string, SchemaFunctionDeclaratio
 export type SchemaFunctionDeclarationWithoutHandler<T extends Record = Record> = {
     description: string;
     parameters: ValueOrAsyncProvider<ObjectSchema<T>>;
+    enabled?: ValueOrAsyncProvider<boolean>;
 };
 export type SchemaFunctionDeclarationWithHandler<T extends Record = Record, R = unknown> = SchemaFunctionDeclarationWithoutHandler<T> & {
     handler: (parameters: T) => R | Promise<R>;
@@ -83,6 +84,6 @@ export type GenerationResult = {
     usage: GenerationUsage;
 };
 export declare function defineFunctions<T extends SchemaFunctionDeclarations>(declarations: T): T;
-export declare function defineFunction<T extends Record = Record>(description: string, parameters: ValueOrAsyncProvider<ObjectSchema<T>>): SchemaFunctionDeclaration<T, never>;
-export declare function defineFunction<T extends Record = Record, R = never>(description: string, parameters: ValueOrAsyncProvider<ObjectSchema<T>>, handler: (parameters: T) => R | Promise<R>): SchemaFunctionDeclaration<T, R>;
+export declare function defineFunction<T extends SchemaFunctionDeclarationWithHandler>(declaration: T): T;
+export declare function defineFunction<T extends SchemaFunctionDeclarationWithoutHandler>(declaration: T): T;
 export declare function isSchemaFunctionDeclarationWithHandler(declaration: SchemaFunctionDeclaration): declaration is SchemaFunctionDeclarationWithHandler;

package/ai/types.js

@@ -1,13 +1,9 @@
 import { hasOwnProperty } from '../utils/object/object.js';
-import { isDefined } from '../utils/type-guards.js';
 export function defineFunctions(declarations) {
     return declarations;
 }
-export function defineFunction(description, parameters, handler) {
-    if (isDefined(handler)) {
-        return { description, parameters, handler };
-    }
-    return { description, parameters };
+export function defineFunction(declaration) {
+    return declaration;
 }
 export function isSchemaFunctionDeclarationWithHandler(declaration) {
     return hasOwnProperty(declaration, 'handler');

package/package.json

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

package/schema/converters/openapi-converter.js

@@ -75,7 +75,7 @@ function convertToOpenApiSchemaBase(schema) {
     if (schema instanceof EnumerationSchema) {
         const hasString = schema.allowedValues.some(isString);
         const hasNumber = schema.allowedValues.some(isNumber);
-        if (hasString && hasNumber) {
+        if (!hasString && !hasNumber) {
             throw new NotSupportedError('Enum must be either string or number but not both.');
         }
         return {