utilitas 1998.2.35 → 1998.2.37

package/lib/alan.mjs

@@ -743,14 +743,17 @@ const packResp = async (resp, options) => {
     };
 };
 
+const streamResp = async (resp, options) => {
+    const msg = await packGptResp(resp, { ...options, processing: true });
+    return options?.stream && (msg?.text || msg?.audio?.length)
+        && await ignoreErrFunc(async () => await options.stream(msg), LOG);
+};
+
 const packGptResp = async (resp, options) => {
     // simple mode is not recommended for streaming responses
-    let text = resp?.choices?.[0]?.message?.content                             // ChatGPT
-        || resp?.choices?.[0]?.message?.audio?.transcript                       // ChatGPT audio mode
-        || (Function.isFunction(resp?.text) ? resp.text() : resp?.text)         // Gemini
-        || resp?.content?.find(x => x.type === TEXT)?.text                      // Claude
+    let text = resp.text                                                        // ChatGPT / Claude / Gemini
         || resp?.message?.content || '';                                        // Ollama
-    const audio = resp?.choices?.[0]?.message?.audio?.data;                     // ChatGPT audio mode
+    const audio = resp?.message?.audio?.data;                                   // ChatGPT audio mode
     if (options?.raw) { return resp; }
     else if (options?.simple && options?.jsonMode) { return parseJson(text); }
     else if (options?.simple && options?.audioMode) { return audio; }
@@ -769,24 +772,24 @@ const packGptResp = async (resp, options) => {
 };
 
 const handleToolsCall = async (msg, options) => {
-    let [content, preRes, input, packMsg, toolsResponse]
-        = [[], [], [], null, options?.result ? options?.result.trim() : ''];
-    const resp = async (msg) => {
-        msg = `\n${msg}`;
-        toolsResponse = (toolsResponse + msg).trim();
-        // @todo: handle more flavors by @LeaskH
-        await ignoreErrFunc(async () => await options?.stream?.(await packGptResp({
-            choices: [{ message: { content: options?.delta ? msg : toolsResponse } }]
-        }, { ...options || {}, processing: true })), LOG);
+    let [content, preRes, input, packMsg, toolsResponse, responded] = [
+        [], [], [], null, options?.result ? options?.result.trim() : '', false
+    ];
+    const resp = async m => {
+        m = `\n${m}`;
+        responded || (m = `\n\n${TOOLS_STR}${m}`);
+        responded = true;
+        toolsResponse = (toolsResponse + m).trim();
+        await streamResp({ text: options?.delta ? m : toolsResponse }, options);
     };
-    if (msg?.tool_calls?.length) {
-        await resp(`\n${TOOLS_STR}`);
+    const calls = msg.tool_calls || msg.content || msg.parts || [];
+    if (calls.length) {
         switch (options?.flavor) {
-            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;
+            case CLAUDE: preRes.push(msg); break;
+            case GEMINI: preRes.push(msg); break;
+            case CHATGPT: default: preRes.push(msg); break;
         }
-        for (const fn of msg.tool_calls) {
+        for (const fn of calls) {
             switch (options?.flavor) {
                 case CLAUDE:
                     input = fn.input = String.isString(fn?.input) ? parseJson(fn.input) : fn?.input;
@@ -795,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,
                             }
                         }
                     });
@@ -812,13 +815,16 @@ 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(
                 x.def?.function?.name || x?.def?.name, name
             ));
             if (!f?.func) {
-                content.push(packMsg(`Function call failed: invalid function name ${name}`, true));
+                const rt = `Failed: invalid function name \`${name}\``;
+                content.push(packMsg(rt, true));
+                await resp(rt);
                 continue;
             }
             const description = f.def?.function?.description || f.def?.description;
@@ -830,20 +836,25 @@ const handleToolsCall = async (msg, options) => {
                 content.push(packMsg(output));
                 await resp(f.showRes ? `Output: ${output}` : `Status: OK`);
             } catch (err) {
-                content.push(packMsg(`Function call failed: ${err.message}`, true));
-                await resp(`Failed: ${err.message}`);
-                log(`Function call failed: ${err.message}`);
+                const rt = `Failed: ${err.message}`;
+                content.push(packMsg(rt, true));
+                await resp(rt);
+                log(rt);
             }
         }
         switch (options?.flavor) {
-            case CLAUDE: content = [{ role: user, content }]; break;
+            case CLAUDE: content = content.length ? [{ role: user, content }] : []; break;
             case GEMINI: content = [{ role: user, parts: content }]; break;
         }
-        await resp(`\n${TOOLS_END}`);
+        responded && await resp(`\n${TOOLS_END}`);
     }
-    return { toolsResult: [...preRes, ...content], toolsResponse };
+    return { toolsResult: [...content.length ? preRes : [], ...content], toolsResponse };
 };
 
+const mergeMsgs = (resp, calls) => [resp, ...calls.length ? [
+    `⚠️ Tools recursion limit reached: ${MAX_TOOL_RECURSION}`
+] : []].map(x => x.trim()).join('\n\n');
+
 const promptChatGPT = async (content, options = {}) => {
     const { client } = await getOpenAIClient(options);
     // https://github.com/openai/openai-node?tab=readme-ov-file#streaming-responses
@@ -871,10 +882,8 @@ const promptChatGPT = async (content, options = {}) => {
         options?.reasoning && !MODELS[options.model]?.reasoning
     ), `This model does not support reasoning: ${options.model}`);
     [options.audioMimeType, options.suffix] = [pcm16, 'pcm.wav'];
-    let [result, resultAudio, chunk, resultTools] = [
-        options?.result ? `${options?.result}\n\n` : '',
-        Buffer.alloc(0), null, []
-    ];
+    let [result, resultAudio, event, resultTools, responded]
+        = [options?.result ?? '', Buffer.alloc(0), null, [], false];
     const resp = await client.chat.completions.create({
         modalities, audio: options?.audio || (
             modalities?.find?.(x => x === AUDIO)
@@ -888,53 +897,43 @@ const promptChatGPT = async (content, options = {}) => {
         } : {}, model: options.model, stream: true,
         store: true, tool_choice: 'auto',
     });
-    for await (chunk of resp) {
-        const deltaText = chunk.choices[0]?.delta?.content
-            || chunk.choices[0]?.delta?.audio?.transcript || '';
-        const deltaAudio = chunk.choices[0]?.delta?.audio?.data ? await convert(
-            chunk.choices[0].delta.audio.data, { input: BASE64, expected: BUFFER }
+    for await (event of resp) {
+        event = event?.choices?.[0] || {};
+        const delta = event.delta || {};
+        let deltaText = delta.content || delta.audio?.transcript || '';
+        const deltaAudio = delta.audio?.data ? await convert(
+            delta.audio.data, { input: BASE64, expected: BUFFER }
         ) : Buffer.alloc(0);
-        const deltaFunc = chunk.choices[0]?.delta?.tool_calls || [];
-        for (const x in deltaFunc) {
-            let curFunc = resultTools.find(z => z.index === deltaFunc[x].index);
+        for (const x of delta.tool_calls || []) {
+            let curFunc = resultTools.find(y => y.index === x.index);
             curFunc || (resultTools.push(curFunc = {}));
-            isSet(deltaFunc[x].index, true) && (curFunc.index = deltaFunc[x].index);
-            deltaFunc[x].id && (curFunc.id = deltaFunc[x].id);
-            deltaFunc[x].type && (curFunc.type = deltaFunc[x].type);
+            isSet(x.index, true) && (curFunc.index = x.index);
+            x.id && (curFunc.id = x.id);
+            x.type && (curFunc.type = x.type);
             curFunc.function || (curFunc.function = { name: '', arguments: '' });
-            if (deltaFunc[x].function) {
-                deltaFunc[x].function.name && (curFunc.function.name += deltaFunc[x].function.name);
-                deltaFunc[x].function.arguments && (curFunc.function.arguments += deltaFunc[x].function.arguments);
-            }
+            x?.function?.name && (curFunc.function.name += x.function.name);
+            x?.function?.arguments && (curFunc.function.arguments += x.function.arguments);
         }
-        if (deltaText === '' && !deltaAudio.length) { continue; }
+        deltaText && (responded = responded || (deltaText = `\n\n${deltaText}`));
         result += deltaText;
         resultAudio = Buffer.concat([resultAudio, deltaAudio]);
         const respAudio = options?.delta ? deltaAudio : resultAudio;
-        chunk.choices[0].message = {
-            content: options?.delta ? deltaText : result,
+        await streamResp({
+            text: options?.delta ? deltaText : result,
             ...respAudio.length ? { audio: { data: respAudio } } : {},
-        };
-        await ignoreErrFunc(async () => await options?.stream?.(
-            await packGptResp(chunk, { ...options, processing: true })
-        ), LOG);
+        }, options);
     }
-    chunk.choices?.[0] || (chunk.choices = [{}]); // handle empty choices for Azure APIs
-    chunk.choices[0].message = {
-        content: result, tool_calls: resultTools,
+    event = {
+        role: assistant, text: result, tool_calls: resultTools,
         ...resultAudio.length ? { audio: { data: resultAudio } } : {},
     };
-    const { toolsResult, toolsResponse } = await handleToolsCall(
-        chunk?.choices?.[0]?.message, { ...options, result }
-    );
-
+    const { toolsResult, toolsResponse }
+        = await handleToolsCall(event, { ...options, result });
     if (toolsResult.length && countToolCalls(toolsResponse) < MAX_TOOL_RECURSION) {
         return promptChatGPT(content, { ...options, toolsResult, result: toolsResponse });
     }
-    chunk.choices[0].message.content = [toolsResponse, ...toolsResult.length ? [
-        `⚠️ Tools recursion limit reached: ${MAX_TOOL_RECURSION}`
-    ] : []].map(x => x.trim()).join('\n\n');
-    return await packGptResp(chunk, options);
+    event.text = mergeMsgs(toolsResponse, toolsResult);
+    return await packGptResp(event, options);
 };
 
 const promptAzure = async (content, options = {}) =>
@@ -966,13 +965,13 @@ const promptOllama = async (content, options = {}) => {
 const promptClaude = async (content, options = {}) => {
     const { client } = await getClaudeClient(options);
     options.model = options?.model || DEFAULT_MODELS[CLAUDE];
-    const reasoning = options?.reasoning ?? MODELS[options.model]?.reasoning;
     const resp = await client.messages.create({
         model: options.model, max_tokens: MODELS[options.model].maxOutputTokens,
         messages: [
             ...options?.messages || [], buildClaudeMessage(content, options),
             ...options?.toolsResult || [],
-        ], stream: true, ...reasoning ? {
+        ], stream: true,
+        ...options?.reasoning ?? MODELS[options.model]?.reasoning ? {
             thinking: options?.thinking || { type: 'enabled', budget_tokens: 1024 },
         } : {}, // https://docs.anthropic.com/en/docs/build-with-claude/extended-thinking
         ...MODELS[options.model]?.tools ? {
@@ -980,57 +979,43 @@ const promptClaude = async (content, options = {}) => {
             tool_choice: { type: 'auto' },
         } : {},
     });
-    let [event, text, thinking, signature, result, thinkEnd, tool_calls]
-        = [null, '', '', '', options?.toolsResponse || '', '', []];
-    for await (event of resp) {
-        let [thkDelta, txtDelta] = [
-            event?.content_block?.thinking || event?.delta?.thinking || '',
-            event?.content_block?.text || event?.delta?.text || '',
-        ];
+    let [event, text, thinking, signature, result, thinkEnd, tool_use]
+        = [null, '', '', '', options?.result ?? '', '', []];
+    for await (const chunk of resp) {
+        event = chunk?.content_block || chunk?.delta || {};
+        let [thkDelta, txtDelta] = [event.thinking || '', event.text || ''];
         text += txtDelta;
         thinking += thkDelta;
-        signature = signature || event?.content_block?.signature || event?.delta?.signature || '';
-        if (reasoning) {
-            thkDelta && (thkDelta === thinking)
-                && (thkDelta = `${THINK_STR}\n${thkDelta}`);
-            thinking && txtDelta && !thinkEnd
-                && (thinkEnd = thkDelta = `${thkDelta}\n${THINK_END}\n\n`);
+        signature = signature || event?.signature || '';
+        thkDelta && thkDelta === thinking
+            && (thkDelta = `${THINK_STR}\n${thkDelta}`);
+        thinking && txtDelta && !thinkEnd
+            && (thinkEnd = thkDelta = `${thkDelta}\n${THINK_END}\n\n`);
+        if (event?.type === 'tool_use') {
+            tool_use.push({ ...event, input: '' });
+        } else if (event.partial_json) {
+            tool_use[tool_use.length - 1].input += event.partial_json;
         }
-        if (event?.content_block?.type === 'tool_use') {
-            tool_calls.push({ ...event?.content_block, input: '' });
-        } else if (event?.delta?.partial_json) {
-            tool_calls[tool_calls.length - 1].input += event?.delta?.partial_json;
-        }
-        const delta = thkDelta + txtDelta;
-        if (delta === '') { continue; }
-        result += delta;
-        event.content = [{ type: TEXT, text: options?.delta ? delta : result }];
-        await ignoreErrFunc(async () => await options?.stream?.(
-            await packGptResp(event, { ...options, processing: true })
-        ), LOG);
+        txtDelta = thkDelta + txtDelta;
+        result += txtDelta;
+        await streamResp({ text: options?.delta ? txtDelta : result }, options);
     }
-    event.content = [{ type: TEXT, text }];
-    tool_calls.length && thinking
-        && event.content.unshift({ type: THINKING, thinking, signature });
+    event = {
+        role: assistant, content: [
+            ...thinking ? [{ type: THINKING, thinking, signature }] : [],
+            ...text ? [{ type: TEXT, text }] : [], ...tool_use,
+        ]
+    };
     const { toolsResult, toolsResponse } = await handleToolsCall(
-        { tool_calls }, { ...options, toolsResponse: result, flavor: CLAUDE },
+        event, { ...options, result, flavor: CLAUDE },
     );
-    if (toolsResult.length && countToolCalls(toolsResponse) < MAX_TOOL_RECURSION) {
-        toolsResult[0].content.unshift(
-            ...event?.content.filter(x => x?.type !== 'tool_use')
-        );
+    if (tool_use.length && countToolCalls(toolsResponse) < MAX_TOOL_RECURSION) {
         return await promptClaude(content, {
-            ...options, toolsResult, toolsResponse,
+            ...options, toolsResult: [...options?.toolsResult || [],
+            ...toolsResult], result: toolsResponse,
         });
     }
-    const textPart = event.content.find(x => x.type == TEXT);
-    textPart.text = [
-        ...options?.toolsResponse ? [options?.toolsResponse] : [],
-        textPart.text, ...toolsResult.length ? [
-            `⚠️ Tools recursion limit reached: ${MAX_TOOL_RECURSION}`
-        ] : [],
-    ].map(x => x.trim()).join('\n\n')
-    return packGptResp(event, options);
+    return packGptResp({ text: mergeMsgs(toolsResponse, tool_use) }, options);
 };
 
 const uploadFile = async (input, options) => {
@@ -1093,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.35",
+    "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.35",
+    "version": "1998.2.37",
     "private": false,
     "homepage": "https://github.com/Leask/utilitas",
     "main": "index.mjs",