utilitas 1998.2.35 → 1998.2.36

package/lib/alan.mjs

@@ -743,14 +743,18 @@ 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
+    let text = resp.text                                                        // ChatGPT / Claude
         || (Function.isFunction(resp?.text) ? resp.text() : resp?.text)         // Gemini
-        || resp?.content?.find(x => x.type === TEXT)?.text                      // Claude
         || 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 +773,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 || [];
+    if (calls.length) {
         switch (options?.flavor) {
-            case CLAUDE: preRes.push({ role: assistant, content: msg?.tool_calls }); break;
+            case CLAUDE: preRes.push(msg); 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 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;
@@ -813,12 +817,15 @@ const handleToolsCall = async (msg, options) => {
                     break;
             }
             const name = fn?.function?.name || 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 +837,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 +883,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 +898,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 +966,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 +980,42 @@ 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) => {

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.36",
     "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.36",
     "private": false,
     "homepage": "https://github.com/Leask/utilitas",
     "main": "index.mjs",