@illuma-ai/agents 1.1.21 → 1.1.23

package/src/llm/google/utils/tools.js

@@ -1,111 +0,0 @@
-import { FunctionCallingMode, } from '@google/generative-ai';
-import { isLangChainTool } from '@langchain/core/utils/function_calling';
-import { isOpenAITool, } from '@langchain/core/language_models/base';
-import { convertToGenerativeAITools } from './common';
-import { removeAdditionalProperties } from './zod_to_genai_parameters';
-export function convertToolsToGenAI(tools, extra) {
-    // Extract function declaration processing to a separate function
-    const genAITools = processTools(tools);
-    // Simplify tool config creation
-    const toolConfig = createToolConfig(genAITools, extra);
-    return { tools: genAITools, toolConfig };
-}
-function processTools(tools) {
-    let functionDeclarationTools = [];
-    const genAITools = [];
-    tools.forEach((tool) => {
-        if (isLangChainTool(tool)) {
-            const [convertedTool] = convertToGenerativeAITools([
-                tool,
-            ]);
-            if (convertedTool.functionDeclarations) {
-                functionDeclarationTools.push(...convertedTool.functionDeclarations);
-            }
-        }
-        else if (isOpenAITool(tool)) {
-            const { functionDeclarations } = convertOpenAIToolToGenAI(tool);
-            if (functionDeclarations) {
-                functionDeclarationTools.push(...functionDeclarations);
-            }
-            else {
-                throw new Error('Failed to convert OpenAI structured tool to GenerativeAI tool');
-            }
-        }
-        else {
-            genAITools.push(tool);
-        }
-    });
-    const genAIFunctionDeclaration = genAITools.find((t) => 'functionDeclarations' in t);
-    if (genAIFunctionDeclaration) {
-        return genAITools.map((tool) => {
-            if (functionDeclarationTools.length > 0 &&
-                'functionDeclarations' in tool) {
-                const newTool = {
-                    functionDeclarations: [
-                        ...(tool.functionDeclarations || []),
-                        ...functionDeclarationTools,
-                    ],
-                };
-                // Clear the functionDeclarationTools array so it is not passed again
-                functionDeclarationTools = [];
-                return newTool;
-            }
-            return tool;
-        });
-    }
-    return [
-        ...genAITools,
-        ...(functionDeclarationTools.length > 0
-            ? [
-                {
-                    functionDeclarations: functionDeclarationTools,
-                },
-            ]
-            : []),
-    ];
-}
-function convertOpenAIToolToGenAI(tool) {
-    return {
-        functionDeclarations: [
-            {
-                name: tool.function.name,
-                description: tool.function.description,
-                parameters: removeAdditionalProperties(tool.function.parameters),
-            },
-        ],
-    };
-}
-function createToolConfig(genAITools, extra) {
-    if (!genAITools.length || !extra)
-        return undefined;
-    const { toolChoice, allowedFunctionNames } = extra;
-    const modeMap = {
-        any: FunctionCallingMode.ANY,
-        auto: FunctionCallingMode.AUTO,
-        none: FunctionCallingMode.NONE,
-    };
-    if (toolChoice != null &&
-        ['any', 'auto', 'none'].includes(toolChoice)) {
-        return {
-            functionCallingConfig: {
-                mode: modeMap[toolChoice] ?? 'MODE_UNSPECIFIED',
-                allowedFunctionNames,
-            },
-        };
-    }
-    if (typeof toolChoice === 'string' || allowedFunctionNames) {
-        return {
-            functionCallingConfig: {
-                mode: FunctionCallingMode.ANY,
-                allowedFunctionNames: [
-                    ...(allowedFunctionNames ?? []),
-                    ...(toolChoice != null && typeof toolChoice === 'string'
-                        ? [toolChoice]
-                        : []),
-                ],
-            },
-        };
-    }
-    return undefined;
-}
-//# sourceMappingURL=tools.js.map

package/src/llm/google/utils/zod_to_genai_parameters.js

@@ -1,47 +0,0 @@
-import { isInteropZodSchema, } from '@langchain/core/utils/types';
-import { toJsonSchema, } from '@langchain/core/utils/json_schema';
-export function removeAdditionalProperties(
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-obj) {
-    if (typeof obj === 'object' && obj !== null) {
-        const newObj = { ...obj };
-        if ('additionalProperties' in newObj) {
-            delete newObj.additionalProperties;
-        }
-        if ('$schema' in newObj) {
-            delete newObj.$schema;
-        }
-        if ('strict' in newObj) {
-            delete newObj.strict;
-        }
-        for (const key in newObj) {
-            if (key in newObj) {
-                if (Array.isArray(newObj[key])) {
-                    newObj[key] = newObj[key].map(removeAdditionalProperties);
-                }
-                else if (typeof newObj[key] === 'object' && newObj[key] !== null) {
-                    newObj[key] = removeAdditionalProperties(newObj[key]);
-                }
-            }
-        }
-        return newObj;
-    }
-    return obj;
-}
-export function schemaToGenerativeAIParameters(schema) {
-    // GenerativeAI doesn't accept either the $schema or additionalProperties
-    // attributes, so we need to explicitly remove them.
-    const jsonSchema = removeAdditionalProperties(isInteropZodSchema(schema) ? toJsonSchema(schema) : schema);
-    const { $schema: _s, ...rest } = jsonSchema;
-    return rest;
-}
-export function jsonSchemaToGeminiParameters(
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-schema) {
-    // Gemini doesn't accept either the $schema or additionalProperties
-    // attributes, so we need to explicitly remove them.
-    const jsonSchema = removeAdditionalProperties(schema);
-    const { $schema: _s, ...rest } = jsonSchema;
-    return rest;
-}
-//# sourceMappingURL=zod_to_genai_parameters.js.map