utilitas 1998.2.24 → 1998.2.26

package/lib/alan.mjs

@@ -219,6 +219,7 @@ const MODELS = {
         trainingData: 'August 2024',
         vision: true,
         json: true,
+        tools: true,
         supportedMimeTypes: [
             png, jpeg, mov, mpeg, mp4, mpg, avi, wmv, mpegps, flv, pdf, aac,
             flac, mp3, m4a, mpga, opus, pcm, wav, webm, tgpp,
@@ -237,7 +238,6 @@ const MODELS = {
         requestLimitsRPD: 1500,
         tokenLimitsTPM: 4 * 1000000,
         trainingData: 'August 2024',
-        json: false,
         vision: true,
         reasoning: true,
         supportedMimeTypes: [
@@ -268,8 +268,6 @@ const MODELS = {
         maxOutputTokens: 32768,
         requestLimitsRPM: Infinity,
         tokenLimitsTPM: Infinity,
-        json: false,
-        vision: false,
         reasoning: true,
     },
     [TEXT_EMBEDDING_3_SMALL]: {
@@ -390,19 +388,17 @@ const init = async (options) => {
                 const { GoogleGenerativeAI } = await need('@google/generative-ai');
                 const genAi = new GoogleGenerativeAI(options.apiKey);
                 const genModel = options?.model || DEFAULT_MODELS[GEMINI];
-                const tools = options?.tools || { google: true, code: false };
                 clients[provider] = {
                     generative: genAi.getGenerativeModel({
-                        model: genModel,
-                        tools: [
-                            // @todo: https://cloud.google.com/vertex-ai/generative-ai/docs/gemini-v2?hl=en#search-tool
-                            ...tools.code ? [{
-                                codeExecution: tools.code === true ? {} : tools.code
-                            }] : [],
-                            ...tools.google ? [{
-                                googleSearch: tools.google === true ? {} : tools.code,
-                            }] : [],
-                        ],
+                        model: genModel, ...MODELS[genModel]?.tools ? (options?.tools ?? {
+                            tools: [
+                                // @todo: Gemini will failed when using these tools together.
+                                // https://ai.google.dev/gemini-api/docs/function-calling
+                                // { codeExecution: {} },
+                                // { googleSearch: {} },
+                                { functionDeclarations: toolsGemini.map(x => x.def) },
+                            ],
+                        }) : {},
                     }),
                     embedding: genAi.getGenerativeModel({
                         model: DEFAULT_MODELS[GEMINI_EMEDDING],
@@ -468,15 +464,15 @@ const tools = [
                 parameters: {
                     type: 'object',
                     properties: {
-                        a: { type: 'string', description: 'Please create a random string' },
-                        b: { type: 'string', enum: ['A', 'B'], description: 'Enum parameter' }
+                        a: { type: 'string', description: 'AI created a random string, default "1"' },
+                        b: { type: 'string', enum: ['1', '2'], description: 'Enum parameter' }
                     },
-                    required: ['a'],
+                    required: ['a', 'b'],
                     additionalProperties: false
                 }
             }
         },
-        func: async args => 'OK',
+        func: async args => `OK: ${~~args.a + ~~args.b}`,
     },
 ];
 
@@ -488,6 +484,21 @@ const toolsClaude = tools.map(x => ({
     }
 }));
 
+const toolsGemini = tools.map(x => ({
+    ...x, def: {
+        name: x.def.function.name,
+        description: x.def.function.description,
+        parameters: {
+            type: 'object',
+            properties: x.def.function.parameters.properties,
+            required: x.def.function.parameters.required,
+        },
+        response: x.def.function?.response ?? {
+            type: 'string', description: 'It could be a string or JSON',
+        },
+    }
+}));
+
 const selectGptAudioModel = options => {
     assert(
         MODELS[options.model]?.audio,
@@ -686,21 +697,35 @@ const handleToolsCall = async (msg, options) => {
     let content = [], preRes = [], input, packMsg;
     if (msg?.tool_calls?.length) {
         switch (options?.flavor) {
-            case CLAUDE: preRes.push({ role: 'assistant', content: msg?.tool_calls }); break;
-            case CHATGPT: default: preRes.push({ role: 'assistant', ...msg });
+            case CLAUDE: preRes.push({ role: assistant, content: msg?.tool_calls }); break;
+            case GEMINI: preRes.push({ role: MODEL, parts: msg?.tool_calls.map(x => ({ functionCall: x })) }); break;
+            case CHATGPT: default: preRes.push({ role: assistant, ...msg }); break;
         }
         for (const fn of msg.tool_calls) {
-            input = parseJson(fn?.function?.arguments || fn?.input);
             switch (options?.flavor) {
                 case CLAUDE:
-                    fn.input = input;
+                    input = fn.input = parseJson(fn?.input);
                     packMsg = (content, is_error) => ({
                         type: 'tool_result', tool_use_id: fn.id, content, is_error,
-                    }); break;
+                    });
+                    break;
+                case GEMINI:
+                    input = fn.args;
+                    packMsg = (t, e) => ({
+                        functionResponse: {
+                            name: fn.name, response: {
+                                name: fn.name,
+                                content: e ? `[Error] ${t}` : JSON.stringify(t),
+                            }
+                        }
+                    });
+                    break;
                 case CHATGPT: default:
+                    input = parseJson(fn?.function?.arguments);
                     packMsg = (t, e) => ({
                         role: 'tool', tool_call_id: fn.id, [e ? 'error' : 'content']: t
                     });
+                    break;
             }
             const name = fn?.function?.name || fn?.name;
             const func = tools.find(x => insensitiveCompare(
@@ -711,13 +736,14 @@ const handleToolsCall = async (msg, options) => {
                 continue;
             }
             try {
-                content.push(packMsg(await func(...Object.values(input))));
+                content.push(packMsg(await func(input)));
             } catch (err) {
                 content.push(packMsg(`Function call failed: ${err.message}`, true));
             }
         }
         switch (options?.flavor) {
-            case CLAUDE: content = [{ role: 'user', content }];
+            case CLAUDE: content = [{ role: user, content }]; break;
+            case GEMINI: content = [{ role: user, parts: content }]; break;
         }
     }
     return [...preRes, ...content];
@@ -847,7 +873,8 @@ const promptClaude = async (content, options = {}) => {
     const resp = await client.messages.create({
         model: options.model, max_tokens: MODELS[options.model].maxOutputTokens,
         messages: [
-            ...options?.messages || [], buildClaudeMessage(content, options), ...options?.toolsResult || [],
+            ...options?.messages || [], buildClaudeMessage(content, options),
+            ...options?.toolsResult || [],
         ], stream: !!options?.stream, ...reasoning ? {
             thinking: options?.thinking || { type: 'enabled', budget_tokens: 1024 },
         } : {}, // https://docs.anthropic.com/en/docs/build-with-claude/extended-thinking
@@ -859,7 +886,6 @@ const promptClaude = async (content, options = {}) => {
         = [null, '', '', '', '', '', []];
     if (options?.stream) {
         for await (event of resp) {
-            print(event);
             let [thkDelta, txtDelta] = [
                 event?.content_block?.thinking || event?.delta?.thinking || '',
                 event?.content_block?.text || event?.delta?.text || '',
@@ -949,9 +975,10 @@ const packGeminiReferences = (chunks, supports) => {
 
 const handleGeminiResponse = async (resp, options) => {
     const _resp = await resp;
-    let [result, references] = ['', null];
+    let [result, references, functionCalls] = ['', null, null];
     if (options?.stream) {
         for await (const chunk of _resp.stream) {
+            functionCalls || (functionCalls = chunk.functionCalls);
             const delta = chunk?.text?.() || '';
             const rfc = packGeminiReferences(
                 chunk.candidates[0]?.groundingMetadata?.groundingChunks,
@@ -968,14 +995,19 @@ const handleGeminiResponse = async (resp, options) => {
         }
     }
     const __resp = await _resp.response;
-    return await packGptResp(options?.stream ? {
+    const toolsResult = await handleToolsCall({
+        tool_calls: (functionCalls || __resp.functionCalls)()
+    }, { flavor: GEMINI });
+    return await (toolsResult.length ? promptGemini(
+        options?.content, { ...options || {}, toolsResult }
+    ) : packGptResp(options?.stream ? {
         __resp, text: () => result, references
     } : {
         ...__resp, references: packGeminiReferences(
             __resp.candidates[0]?.groundingMetadata?.groundingChunks,
             __resp.candidates[0]?.groundingMetadata?.groundingSupports
         )
-    }, options);
+    }, options));
 };
 
 const promptGemini = async (content, options) => {
@@ -987,15 +1019,21 @@ const promptGemini = async (content, options) => {
         options?.jsonMode && MODELS[genModel]?.json == false
     ), `This model does not support JSON output: ${genModel} `);
     const chat = generative.startChat({
-        history: options?.messages && !options?.attachments?.length
-            ? options.messages : [],
+        history: [
+            ...options?.messages && !options?.attachments?.length ? options.messages : [],
+            ...options?.toolsResult ? [
+                { role: user, parts: buildGeminiMessage(content, options) },
+                options?.toolsResult[0]
+            ] : [],
+        ],
         ...generationConfig(options),
     });
     const resp = chat[options?.stream ? 'sendMessageStream' : 'sendMessage'](
-        buildGeminiMessage(content, options)
+        options?.toolsResult ?
+            options?.toolsResult[1].parts : buildGeminiMessage(content, options)
     );
     return await handleGeminiResponse(
-        resp, { ...options || {}, model: genModel }
+        resp, { ...options || {}, content, model: genModel }
     );
 };
 

package/lib/manifest.mjs

@@ -1,7 +1,7 @@
 const manifest = {
     "name": "utilitas",
     "description": "Just another common utility for JavaScript.",
-    "version": "1998.2.24",
+    "version": "1998.2.26",
     "private": false,
     "homepage": "https://github.com/Leask/utilitas",
     "main": "index.mjs",

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "utilitas",
     "description": "Just another common utility for JavaScript.",
-    "version": "1998.2.24",
+    "version": "1998.2.26",
     "private": false,
     "homepage": "https://github.com/Leask/utilitas",
     "main": "index.mjs",