genaicode 1.0.0 → 2.1.0

package/package.json

@@ -1,133 +1,76 @@
 {
   "name": "genaicode",
-  "version": "1.0.0",
+  "version": "2.1.0",
+  "description": "A small, provider-neutral TypeScript toolkit for calling LLMs from backend code.",
   "author": "Grzegorz Tańczyk",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/gtanczyk/genaicode.git"
   },
   "keywords": [
-    "generate",
-    "code",
+    "llm",
     "ai",
-    "vite-plugin"
+    "openai",
+    "backend",
+    "prompt",
+    "toolkit"
   ],
   "type": "module",
-  "bin": "./bin/genaicode.cjs",
+  "bin": {
+    "genaicode": "./dist/cli.js"
+  },
   "engines": {
-    "node": ">=18"
+    "node": ">=20"
   },
   "license": "Apache-2.0",
+  "sideEffects": false,
   "files": [
-    "bin",
     "dist",
-    "media",
+    "docs",
+    "CHANGELOG.md",
     "README.md",
     "LICENSE"
   ],
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "default": "./dist/index.js"
-    },
-    "./vite-plugin": {
-      "types": "./dist/vite-genaicode/vite-genaicode-plugin.d.ts",
-      "default": "./dist/vite-genaicode/vite-genaicode-plugin.js"
-    },
-    "./vite-context": {
-      "types": "./dist/vite-genaicode/vite-genaicode-context.d.ts",
-      "default": "./dist/vite-genaicode/vite-genaicode-context.js"
+      "import": "./dist/index.js"
     },
-    "./*": "./dist/*"
+    "./providers": {
+      "types": "./dist/providers.d.ts",
+      "import": "./dist/providers.js"
+    }
   },
   "scripts": {
-    "cli": "node ./bin/genaicode.cjs",
-    "interactive-cli": "node ./bin/genaicode.cjs --interactive",
-    "ui": "node ./bin/genaicode.cjs --ui",
-    "lint": "eslint . --ext js,ts,tsx --report-unused-disable-directives --max-warnings 0",
-    "test:watch": "vitest  --config vitest.unit.config.ts",
+    "clean": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\"",
+    "build": "npm run clean && tsc -p tsconfig.build.json",
+    "lint": "eslint . --ext js,ts --report-unused-disable-directives --max-warnings 0",
     "test": "vitest --config vitest.unit.config.ts --run",
-    "test:ci": "vitest run --config vitest.unit.config.ts --reporter=json",
-    "test:e2e": "vitest --config vitest.e2e.config.ts",
-    "test:eval": "vitest --config vitest.eval.config.ts",
-    "coverage": "vitest run --coverage",
-    "prepare": "husky install || true",
+    "test:e2e": "vitest --config vitest.e2e.config.ts --run",
+    "test:watch": "vitest --config vitest.unit.config.ts",
     "type-check": "tsc --noEmit",
-    "build": "tsc -p tsconfig.build.json && npm run build-frontend",
-    "build-frontend": "vite build src/main/ui/frontend",
-    "prepublishOnly": "npm run build"
+    "check": "npm run type-check && npm run lint && npm test && npm run build",
+    "prepublishOnly": "npm run check"
+  },
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.74.0",
+    "@google/genai": "^1.30.0",
+    "openai": "^5.16.0"
   },
   "devDependencies": {
-    "@inquirer/type": "^1.5.5",
-    "@types/cors": "^2.8.13",
-    "@types/dockerode": "^3.3.42",
-    "@types/express": "^4.17.21",
-    "@types/helmet": "^4.0.0",
-    "@types/mock-fs": "^4.13.4",
-    "@types/multer": "^1.4.12",
-    "@types/react": "^18.3.5",
-    "@types/react-dom": "^18.3.0",
-    "@types/tar-stream": "^3.1.4",
-    "@types/xml2js": "^0.4.14",
+    "@types/node": "^20.0.0",
     "@typescript-eslint/eslint-plugin": "^7.17.0",
-    "@uiw/react-json-view": "^2.0.0-alpha.30",
-    "@vitejs/plugin-react": "^4.3.4",
-    "@vitest/coverage-v8": "^3.0.7",
-    "@vitest/ui": "^3.0.7",
+    "@typescript-eslint/parser": "^7.17.0",
     "eslint": "^8.54.0",
     "eslint-config-prettier": "^9.0.0",
-    "eslint-plugin-import": "^2.29.0",
     "husky": "^9.1.1",
     "lint-staged": "^15.2.7",
-    "madge": "^8.0.0",
-    "mock-fs": "^5.5.0",
     "prettier": "^3.1.0",
-    "puppeteer": "^22.15.0",
-    "react": "^18.3.1",
-    "react-dom": "^18.3.1",
-    "react-markdown": "^10.1.0",
-    "remark-gfm": "^4.0.1",
-    "styled-components": "^6.1.13",
-    "ts-node": "^10.9.2",
     "typescript": "^5.0.0",
     "vite": "^6.4.1",
-    "vite-plugin-checker": "^0.8.0",
     "vitest": "^3.0.7"
   },
-  "dependencies": {
-    "@anthropic-ai/sdk": "^0.74.0",
-    "@fontsource/press-start-2p": "^5.1.0",
-    "@google-cloud/aiplatform": "^3.34.0",
-    "@google/genai": "^1.30.0",
-    "@imgly/background-removal-node": "^1.4.5",
-    "@inquirer/prompts": "^7.8.4",
-    "@types/diff": "^5.2.1",
-    "@types/mime-types": "^2.1.4",
-    "@types/node": "^18.0.0",
-    "@types/styled-components": "^5.1.34",
-    "axios": "^1.13.5",
-    "c12": "^3.3.3",
-    "cors": "^2.8.5",
-    "diff": "^5.2.2",
-    "dockerode": "^4.0.7",
-    "express": "^4.22.1",
-    "find-cache-dir": "^5.0.0",
-    "glob-regex": "^0.3.2",
-    "helmet": "^7.1.0",
-    "image-size": "^1.2.1",
-    "inquirer-file-selector": "^0.4.0",
-    "jsonschema": "^1.4.1",
-    "mime-types": "^2.1.35",
-    "multer": "^2.1.1",
-    "openai": "^5.16.0",
-    "please-upgrade-node": "^3.2.0",
-    "sharp": "^0.33.4",
-    "simple-git": "^3.32.3",
-    "tar-stream": "^3.1.7",
-    "xml2js": "^0.6.2",
-    "zod": "^3.25.0"
-  },
   "lint-staged": {
-    "*.{js,ts,css,md}": "prettier --write"
+    "*.{js,ts,md}": "prettier --write"
   }
 }

package/bin/genaicode-dev.js

@@ -1,12 +0,0 @@
-import url from 'node:url';
-import { register } from 'node:module';
-import path from 'path';
-
-const __filename = url.fileURLToPath(import.meta.url);
-register('ts-node/esm', url.pathToFileURL(__filename));
-
-const project = path.resolve('./tsconfig.json');
-(await import('ts-node')).register({ project });
-
-const codegen = await import('../src/main/codegen.ts');
-await codegen.runCodegen(true);

package/bin/genaicode.cjs

@@ -1,23 +0,0 @@
-#!/usr/bin/env node
-
-/* eslint-disable @typescript-eslint/no-var-requires */
-const pleaseUpgradeNode = require('please-upgrade-node');
-
-const pkg = require('../package.json');
-pleaseUpgradeNode(pkg);
-
-const devMode = require('fs').existsSync(`${__dirname}/../src`);
-const forceDist = process.argv.indexOf('--force-dist') >= 0;
-
-if (devMode && !forceDist) {
-  pleaseUpgradeNode({
-    name: 'genaicode-dev.js',
-    engines: {
-      node: '>=20',
-    },
-  });
-
-  import('./genaicode-dev.js').catch((e) => console.error(e));
-} else {
-  import('../dist/main/codegen.js').then(({ runCodegen }) => runCodegen());
-}

package/dist/ai-service/ai-studio.d.ts

@@ -1,6 +0,0 @@
-import { GenerateContentFunction, GenerateContentResult, PromptItem, GenerateContentArgs } from './common-types.js';
-/**
- * This function generates content using the Google AI Studio models with the new interface.
- */
-export declare const generateContent: GenerateContentFunction;
-export declare function internalGoogleGenerateContent(serviceType: 'ai-studio' | 'vertex-ai', prompt: PromptItem[], config: GenerateContentArgs[1], options?: GenerateContentArgs[2]): Promise<GenerateContentResult>;

package/dist/ai-service/ai-studio.js

@@ -1,460 +0,0 @@
-import { FunctionCallingConfigMode, GoogleGenAI, HarmBlockThreshold, HarmCategory, } from '@google/genai';
-import axios from 'axios';
-import assert from 'node:assert';
-import mime from 'mime-types';
-import { optimizeFunctionDefs, printTokenUsageAndCost } from './common.js';
-import { ModelType, } from './common-types.js';
-import { abortController } from '../main/common/abort-controller.js';
-import { unescapeFunctionCall } from './unescape-function-call.js';
-import { enableVertexUnescape } from '../cli/cli-params.js';
-import { getServiceConfig, getModelSettings } from './service-configurations.js';
-/**
- * This function generates content using the Google AI Studio models with the new interface.
- */
-export const generateContent = async function generateContent(...args) {
-    const [prompt, config, options = {}] = args;
-    return internalGoogleGenerateContent('ai-studio', prompt, config, options);
-};
-export async function internalGoogleGenerateContent(serviceType, prompt, config, options = {}) {
-    const modelType = config.modelType ?? ModelType.DEFAULT;
-    const temperature = config.temperature ?? 0.7;
-    const functionDefs = optimizeFunctionDefs(prompt, config.functionDefs, config.requiredFunctionName ?? undefined);
-    const requiredFunctionName = config.requiredFunctionName ?? null;
-    const expectedResponseType = config.expectedResponseType ?? {
-        text: false,
-        functionCall: true,
-        media: false,
-    };
-    const messages = prompt
-        .filter((item) => item.type === 'user' || item.type === 'assistant')
-        .map((item) => {
-        if (item.type === 'user') {
-            const content = {
-                role: 'user',
-                parts: [
-                    ...(item.functionResponses ?? []).map((response) => ({
-                        functionResponse: {
-                            name: response.name,
-                            response: { name: response.name, content: response.content },
-                        },
-                    })),
-                    ...(item.images ?? []).map((image) => image.uri
-                        ? {
-                            fileData: {
-                                fileUri: image.uri,
-                                mimeType: image.mediaType,
-                            },
-                        }
-                        : {
-                            inlineData: {
-                                mimeType: image.mediaType,
-                                data: image.base64url,
-                            },
-                        }),
-                    ...(item.text ? [{ text: item.text }] : []),
-                    // Add file references for code execution if provided in config and this is the last user message
-                    ...(config.fileIds && config.fileIds.length > 0 && item === prompt[prompt.length - 1]
-                        ? config.fileIds.map((fileId) => {
-                            // Find metadata if available to get mimeType
-                            const fileMeta = config.uploadedFiles?.find((f) => f.fileId === fileId);
-                            // Gemini uses fileUri for uploaded files via File API
-                            // fileId here is expected to be the full resource name (files/xxxx) or uri
-                            return {
-                                fileData: {
-                                    fileUri: fileId.startsWith('files/')
-                                        ? `https://generativelanguage.googleapis.com/v1beta/${fileId}`
-                                        : fileId,
-                                    mimeType: fileMeta
-                                        ? mime.lookup(fileMeta.filename) || 'application/octet-stream'
-                                        : 'application/octet-stream',
-                                },
-                            };
-                        })
-                        : []),
-                ],
-            };
-            return content;
-        }
-        else {
-            assert(item.type === 'assistant');
-            const content = {
-                role: 'model',
-                parts: [
-                    ...(item.text ? [{ text: item.text }] : []),
-                    ...(item.images ?? []).map((image) => image.uri
-                        ? {
-                            fileData: {
-                                mimeType: image.mediaType,
-                                fileUri: image.uri,
-                            },
-                        }
-                        : {
-                            inlineData: {
-                                mimeType: image.mediaType,
-                                data: image.base64url,
-                            },
-                        }),
-                    ...(item.functionCalls ?? []).map((call) => ({
-                        functionCall: {
-                            name: call.name,
-                            args: call.args ?? {},
-                        },
-                        // https://docs.cloud.google.com/vertex-ai/generative-ai/docs/thought-signatures
-                        thoughtSignature: 'skip_thought_signature_validator',
-                    })),
-                    ...(item.executableCode
-                        ? [
-                            {
-                                executableCode: {
-                                    language: item.executableCode.language,
-                                    code: item.executableCode.code,
-                                },
-                            },
-                        ]
-                        : []),
-                    ...(item.codeExecutionResult
-                        ? [
-                            {
-                                codeExecutionResult: {
-                                    outcome: item.codeExecutionResult.outcome,
-                                    output: item.codeExecutionResult.output,
-                                },
-                            },
-                        ]
-                        : []),
-                ],
-            };
-            return content;
-        }
-    });
-    const req = {
-        contents: messages,
-        model: '',
-        config: {},
-    };
-    if (functionDefs.length > 0) {
-        req.config.tools = [
-            {
-                functionDeclarations: JSON.parse(JSON.stringify(functionDefs)),
-            },
-        ];
-    }
-    if (expectedResponseType.functionCall !== false) {
-        req.config.toolConfig = {
-            functionCallingConfig: {
-                mode: FunctionCallingConfigMode.ANY,
-                ...(requiredFunctionName ? { allowedFunctionNames: [requiredFunctionName] } : {}),
-            },
-        };
-    }
-    else if (expectedResponseType.functionCall === false) {
-        req.config.toolConfig = {
-            functionCallingConfig: {
-                mode: FunctionCallingConfigMode.NONE,
-                allowedFunctionNames: [],
-            },
-        };
-    }
-    if (expectedResponseType.webSearch) {
-        req.config.tools = [
-            {
-                googleSearch: {},
-            },
-        ];
-        delete req.config.toolConfig;
-    }
-    if (expectedResponseType.codeExecution) {
-        req.config.tools = [
-            ...(req.config.tools ?? []),
-            {
-                codeExecution: {},
-            },
-        ];
-        // Code execution usually works best without forced function calling mode restrictions,
-        // or at least it needs to be allowed.
-        // If functionCall is false, we already set mode to NONE, which might block code execution tool use?
-        // Actually, codeExecution is a tool. If mode is NONE, tools are disabled.
-        // So if codeExecution is requested, we should probably ensure tool use is allowed.
-        if (expectedResponseType.functionCall === false) {
-            // If the user explicitly disabled function calls but enabled code execution,
-            // we should probably allow tools but maybe restrict to code execution?
-            // For now, let's assume if codeExecution is true, we don't force NONE.
-            // But the logic above sets NONE if functionCall is false.
-            // Let's override it if codeExecution is true.
-            if (req.config.toolConfig?.functionCallingConfig?.mode === FunctionCallingConfigMode.NONE) {
-                delete req.config.toolConfig;
-            }
-        }
-    }
-    const result = await internalGoogleModelsCall(serviceType, modelType, temperature, prompt.find((item) => item.type === 'systemPrompt')?.systemPrompt, options.geminiBlockNone, req);
-    // Print token usage
-    const usageMetadata = result.usageMetadata;
-    const usage = {
-        inputTokens: usageMetadata.promptTokenCount,
-        outputTokens: usageMetadata.candidatesTokenCount,
-        totalTokens: usageMetadata.totalTokenCount,
-        thinkingTokens: usageMetadata.thoughtsTokenCount,
-        cacheReadTokens: usageMetadata.cachedContentTokenCount,
-    };
-    printTokenUsageAndCost({
-        aiService: serviceType,
-        usage,
-        inputCostPerToken: 0.000125 / 1000,
-        outputCostPerToken: 0.000375 / 1000,
-        modelType,
-    });
-    if (result.promptFeedback) {
-        console.log('Prompt feedback:');
-        console.log(JSON.stringify(result.promptFeedback, null, 2));
-    }
-    if (!result.candidates?.length) {
-        console.log('Response:', result);
-        throw new Error('No candidates found');
-    }
-    const functionCalls = result.candidates
-        .map((candidate) => candidate.content?.parts?.map((part) => part.functionCall))
-        .flat()
-        .filter((functionCall) => !!functionCall)
-        .map((call) => ({
-        name: call.name,
-        args: call.args,
-    }))
-        .map(!enableVertexUnescape ? (call) => call : unescapeFunctionCall);
-    // Prepare the result parts array
-    const resultParts = [];
-    // Add function calls to result parts if they exist
-    if (functionCalls.length > 0) {
-        functionCalls.forEach((call) => {
-            resultParts.push({
-                type: 'functionCall',
-                functionCall: call,
-            });
-        });
-    }
-    // Handle text response if no function calls were returned
-    if (functionCalls.length === 0 && expectedResponseType.text !== true && expectedResponseType.functionCall === true) {
-        const textResponse = result.candidates
-            .map((candidate) => candidate.content?.parts?.map((part) => part.text))
-            .flat()
-            .filter((text) => !!text)[0] ??
-            result.candidates.map((candidate) => candidate.finishReason === 'MALFORMED_FUNCTION_CALL' ? candidate.finishMessage : '')[0];
-        if (textResponse) {
-            resultParts.push({
-                type: 'text',
-                text: textResponse,
-            });
-            // Try to recover function call from text if required function name is provided
-            const functionDef = functionDefs.find((def) => def.name === requiredFunctionName);
-            if (functionDef) {
-                try {
-                    const recoveredCall = await recoverFunctionCall(serviceType, textResponse, [], functionDef);
-                    if (recoveredCall) {
-                        console.log('Recovered function call.');
-                        // The recovered call will be added to the functionCalls array by the recoverFunctionCall function
-                        // We need to add it to resultParts as well
-                        resultParts.push({
-                            type: 'functionCall',
-                            functionCall: {
-                                name: functionDef.name,
-                                args: recoveredCall,
-                            },
-                        });
-                    }
-                }
-                catch (error) {
-                    console.log('Failed to recover function call:', error);
-                }
-            }
-        }
-    }
-    if (expectedResponseType.text) {
-        for (const candidate of result.candidates) {
-            for (const part of candidate.content?.parts ?? []) {
-                if (part.text && !part.thought) {
-                    resultParts.push({
-                        type: 'text',
-                        text: part.text,
-                    });
-                }
-            }
-        }
-    }
-    if (expectedResponseType.webSearch) {
-        for (const candidate of result.candidates) {
-            const urls = {};
-            for (const chunk of candidate.groundingMetadata?.groundingChunks ?? []) {
-                if (chunk.web?.uri) {
-                    let url = chunk.web?.uri;
-                    try {
-                        const res = await axios.get(url);
-                        if (res.request.res.responseUrl) {
-                            url = res.request.res.responseUrl;
-                        }
-                        else if (res.status !== 200) {
-                            continue;
-                        }
-                    }
-                    catch (e) {
-                        if (axios.isAxiosError(e) && e.response?.request.res.responseUrl) {
-                            url = e.response.request.res.responseUrl;
-                        }
-                        else {
-                            continue;
-                        }
-                    }
-                    urls[url] = true;
-                }
-            }
-            const text = candidate.content?.parts
-                ?.filter((part) => part.text && !part.thought)
-                .map((part) => part.text)
-                .join('');
-            if (text) {
-                resultParts.push({
-                    type: 'webSearch',
-                    text: text,
-                    urls: Object.keys(urls),
-                });
-            }
-        }
-    }
-    // Handle code execution parts
-    for (const candidate of result.candidates) {
-        for (const part of candidate.content?.parts ?? []) {
-            if (part.executableCode) {
-                resultParts.push({
-                    type: 'executableCode',
-                    code: part.executableCode.code,
-                    language: part.executableCode.language,
-                });
-            }
-            if (part.codeExecutionResult) {
-                resultParts.push({
-                    type: 'codeExecutionResult',
-                    outcome: part.codeExecutionResult.outcome,
-                    output: part.codeExecutionResult.output,
-                    // Note: Gemini API currently returns inline images or files as separate parts or within the output text/artifacts.
-                    // If the API evolves to return structured output files in codeExecutionResult, we should map them here.
-                    // For now, inline images might appear as separate parts with mimeType image/*.
-                });
-            }
-        }
-    }
-    return resultParts;
-}
-function internalGoogleModelsCall(serviceType, modelType, temperature, systemPrompt, geminiBlockNone, { contents, config }) {
-    const serviceConfig = getServiceConfig(serviceType);
-    assert(serviceType === 'vertex-ai' ? serviceConfig.googleCloudProjectId : serviceConfig.apiKey, serviceType === 'vertex-ai'
-        ? 'Google Cloud Project ID not configured.'
-        : 'API key not configured, use API_KEY environment variable');
-    const genAI = serviceType === 'vertex-ai'
-        ? new GoogleGenAI({
-            vertexai: true,
-            project: serviceConfig.googleCloudProjectId,
-            location: serviceConfig.googleCloudRegion ?? 'global',
-        })
-        : new GoogleGenAI({ apiKey: serviceConfig.apiKey });
-    // Determine the model name based on model type
-    const model = (() => {
-        switch (modelType) {
-            case ModelType.CHEAP:
-                return serviceConfig.modelOverrides?.cheap ?? 'gemini-2.5-flash';
-            case ModelType.LITE:
-                return serviceConfig.modelOverrides?.lite ?? 'gemini-2.5-flash-lite';
-            default:
-                return serviceConfig.modelOverrides?.default ?? 'gemini-2.5-pro';
-        }
-    })();
-    console.log(`Using ${serviceType === 'vertex-ai' ? 'Vertex AI' : 'AI Studio'} model: ${model}`);
-    // Get model-specific settings
-    const { systemInstruction: modelSystemInstruction, outputTokenLimit, thinkingEnabled, thinkingBudget, } = getModelSettings(serviceType, model);
-    // Combine base system prompt with model-specific instructions if available
-    let effectiveSystemPrompt = systemPrompt || '';
-    if (modelSystemInstruction?.length) {
-        effectiveSystemPrompt += `\n${modelSystemInstruction.join('\n')}`;
-    }
-    const effectiveConfig = Object.assign({
-        maxOutputTokens: outputTokenLimit,
-        temperature,
-        topP: 0.95,
-    }, config);
-    if (typeof thinkingEnabled === 'boolean') {
-        effectiveConfig.thinkingConfig = {
-            thinkingBudget: thinkingEnabled ? -1 : 0,
-        };
-        if (thinkingBudget) {
-            effectiveConfig.thinkingConfig.thinkingBudget = thinkingBudget;
-        }
-    }
-    return genAI.models.generateContent({
-        model,
-        config: {
-            abortSignal: abortController?.signal,
-            safetySettings: [
-                {
-                    category: HarmCategory.HARM_CATEGORY_HATE_SPEECH,
-                    threshold: geminiBlockNone ? HarmBlockThreshold.BLOCK_NONE : HarmBlockThreshold.BLOCK_ONLY_HIGH,
-                },
-                {
-                    category: HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT,
-                    threshold: geminiBlockNone ? HarmBlockThreshold.BLOCK_NONE : HarmBlockThreshold.BLOCK_ONLY_HIGH,
-                },
-                {
-                    category: HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT,
-                    threshold: geminiBlockNone ? HarmBlockThreshold.BLOCK_NONE : HarmBlockThreshold.BLOCK_ONLY_HIGH,
-                },
-                {
-                    category: HarmCategory.HARM_CATEGORY_HARASSMENT,
-                    threshold: geminiBlockNone ? HarmBlockThreshold.BLOCK_NONE : HarmBlockThreshold.BLOCK_ONLY_HIGH,
-                },
-            ],
-            ...effectiveConfig,
-            ...(effectiveSystemPrompt
-                ? {
-                    systemInstruction: {
-                        role: 'system',
-                        parts: [
-                            {
-                                text: effectiveSystemPrompt,
-                            },
-                        ],
-                    },
-                }
-                : {}),
-        },
-        contents,
-    });
-}
-async function recoverFunctionCall(serviceType, textResponse, functionCalls, functionDef) {
-    console.log('Recovering function call');
-    const schema = functionDef.parameters;
-    const result = await internalGoogleModelsCall(serviceType, ModelType.DEFAULT, // Always use default model for recovery attempts
-    0.2, 'Your role is read the text below and if possible, return it in the desired format.', undefined, {
-        contents: [
-            {
-                role: 'user',
-                parts: [
-                    {
-                        text: textResponse,
-                    },
-                ],
-            },
-        ],
-        config: {
-            responseMimeType: 'application/json',
-            responseSchema: schema,
-        },
-    });
-    try {
-        const parsed = JSON.parse(result.text);
-        const functionCall = enableVertexUnescape
-            ? unescapeFunctionCall({ name: functionDef.name, args: parsed })
-            : { name: functionDef.name, args: parsed };
-        functionCalls.push(functionCall);
-        return parsed;
-    }
-    catch {
-        return false;
-    }
-}
-//# sourceMappingURL=ai-studio.js.map