utilitas 1998.2.36 → 1998.2.37

package/lib/alan.mjs

@@ -751,8 +751,7 @@ const streamResp = async (resp, options) => {
 
 const packGptResp = async (resp, options) => {
     // simple mode is not recommended for streaming responses
-    let text = resp.text                                                        // ChatGPT / Claude
-        || (Function.isFunction(resp?.text) ? resp.text() : resp?.text)         // Gemini
+    let text = resp.text                                                        // ChatGPT / Claude / Gemini
         || resp?.message?.content || '';                                        // Ollama
     const audio = resp?.message?.audio?.data;                                   // ChatGPT audio mode
     if (options?.raw) { return resp; }
@@ -783,11 +782,11 @@ const handleToolsCall = async (msg, options) => {
         toolsResponse = (toolsResponse + m).trim();
         await streamResp({ text: options?.delta ? m : toolsResponse }, options);
     };
-    const calls = msg.tool_calls || msg.content || [];
+    const calls = msg.tool_calls || msg.content || msg.parts || [];
     if (calls.length) {
         switch (options?.flavor) {
             case CLAUDE: preRes.push(msg); break;
-            case GEMINI: preRes.push({ role: MODEL, parts: msg?.tool_calls.map(x => ({ functionCall: x })) }); break;
+            case GEMINI: preRes.push(msg); break;
             case CHATGPT: default: preRes.push(msg); break;
         }
         for (const fn of calls) {
@@ -799,11 +798,11 @@ const handleToolsCall = async (msg, options) => {
                     });
                     break;
                 case GEMINI:
-                    input = fn.args;
+                    input = fn?.functionCall?.args;
                     packMsg = (t, e) => ({
                         functionResponse: {
-                            name: fn.name, response: {
-                                name: fn.name, content: e ? `[Error] ${t}` : t,
+                            name: fn?.functionCall?.name, response: {
+                                name: fn?.functionCall?.name, content: e ? `[Error] ${t}` : t,
                             }
                         }
                     });
@@ -816,7 +815,7 @@ const handleToolsCall = async (msg, options) => {
                     });
                     break;
             }
-            const name = fn?.function?.name || fn?.name;
+            const name = (fn?.function || fn?.functionCall || fn)?.name;
             if (!name) { continue; }
             await resp(`\nName: ${name}`);
             const f = tools.find(x => insensitiveCompare(
@@ -1012,7 +1011,8 @@ const promptClaude = async (content, options = {}) => {
     );
     if (tool_use.length && countToolCalls(toolsResponse) < MAX_TOOL_RECURSION) {
         return await promptClaude(content, {
-            ...options, toolsResult: [...options?.toolsResult || [], ...toolsResult], result: toolsResponse,
+            ...options, toolsResult: [...options?.toolsResult || [],
+            ...toolsResult], result: toolsResponse,
         });
     }
     return packGptResp({ text: mergeMsgs(toolsResponse, tool_use) }, options);
@@ -1078,54 +1078,46 @@ const promptGemini = async (content, options = {}) => {
     options.model = genModel;
     const chat = generative.startChat({
         history: [
-            ...options?.messages && !options?.attachments?.length
-                ? options.messages : [],
-            ...options?.toolsResult ? [{
-                role: user, parts: buildGeminiMessage(content, options)
-            }, options?.toolsResult[0]] : [],
+            ...options?.messages && !options?.attachments?.length ? options.messages : [],
+            ...options?.toolsResult ? [
+                buildGeminiMessage(content, { ...options, history: true }),
+                ...options.toolsResult.slice(0, options.toolsResult.length - 1)
+            ] : []
         ], ...generationConfig(options),
     });
-    const resp = await chat[
-        options?.stream ? 'sendMessageStream' : 'sendMessage'
-    ](options?.toolsResult ?
-        options?.toolsResult[1].parts : buildGeminiMessage(content, options));
-    let [result, references, functionCalls] = [
-        options?.toolsResponse ? `${options?.toolsResponse}\n\n` : '', 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,
-                chunk.candidates[0]?.groundingMetadata?.groundingSupports
-            );
-            if (delta === '' && !rfc) { continue; }
-            result += delta;
-            references = rfc;
-            await ignoreErrFunc(async () => await options.stream(
-                await packGptResp({
-                    text: () => options?.delta ? delta : result, references,
-                }, { ...options, processing: true })
-            ), LOG);
-        }
+    const resp = await chat.sendMessageStream(
+        options?.toolsResult?.[options?.toolsResult?.length]?.parts
+        || buildGeminiMessage(content, options)
+    );
+    let [result, references, functionCalls]
+        = [options?.result ?? '', null, null];
+    for await (const chunk of resp.stream) {
+        functionCalls || (functionCalls = chunk.functionCalls);
+        const delta = chunk?.text?.() || '';
+        const rfc = packGeminiReferences(
+            chunk.candidates[0]?.groundingMetadata?.groundingChunks,
+            chunk.candidates[0]?.groundingMetadata?.groundingSupports
+        );
+        if (delta === '' && !rfc) { continue; }
+        result += delta;
+        references = rfc;
+        await streamResp({ text: options?.delta ? delta : result }, options);
     }
     const _resp = await resp.response;
-    const { toolsResult, toolsResponse } = await handleToolsCall({
-        tool_calls: (functionCalls || _resp.functionCalls)()
-    }, { ...options, flavor: GEMINI });
-    options?.toolsResponse && !options?.stream
-        && (_resp.text = [options?.toolsResponse, _resp.text()].join('\n\n'));
-    return await (toolsResult.length && !options?.toolsResult ? promptGemini(
-        content, { ...options || {}, toolsResult, toolsResponse }
-    ) : packGptResp(options?.stream ? {
-        _resp, text: () => result, references
-    } : {
-        ..._resp, references: packGeminiReferences(
-            _resp.candidates[0]?.groundingMetadata?.groundingChunks,
-            _resp.candidates[0]?.groundingMetadata?.groundingSupports
-        )
-    }, options));
+    functionCalls = (functionCalls() || _resp.functionCalls() || []).map(x => ({ functionCall: x }));
+    const { toolsResult, toolsResponse } = await handleToolsCall(
+        { role: MODEL, parts: functionCalls },
+        { ...options, result, flavor: GEMINI }
+    );
+    if (functionCalls.length && countToolCalls(toolsResponse) < MAX_TOOL_RECURSION) {
+        return promptGemini(content, {
+            ...options || {}, toolsResult: [...options?.toolsResult || [],
+            ...toolsResult], result: toolsResponse,
+        });
+    }
+    return await packGptResp({
+        text: mergeMsgs(toolsResponse, functionCalls), references,
+    }, options);
 };
 
 const checkEmbeddingInput = async (input, model) => {

package/lib/manifest.mjs

@@ -1,7 +1,7 @@
 const manifest = {
     "name": "utilitas",
     "description": "Just another common utility for JavaScript.",
-    "version": "1998.2.36",
+    "version": "1998.2.37",
     "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.36",
+    "version": "1998.2.37",
     "private": false,
     "homepage": "https://github.com/Leask/utilitas",
     "main": "index.mjs",