utilitas 1998.2.34 → 1998.2.36

package/lib/alan.mjs

@@ -38,8 +38,7 @@ You may be provided with some tools(functions) to help you gather information an
 - Use tools when appropriate to enhance efficiency and accuracy, and to gain the contextual knowledge needed to solve problems.
 - Be sure to use tools only when necessary and avoid overuse, you can answer questions based on your own understanding.
 - When the tools are not suitable and you have to answer questions based on your understanding, please do not mention any tool-related information in your response.
-- Unless otherwise specified to require the original result, in most cases, you may reorganize the information obtained after using the tool to solve the problem as needed.
-- If the tool fails, do not retry unless requested by the user.`;
+- Unless otherwise specified to require the original result, in most cases, you may reorganize the information obtained after using the tool to solve the problem as needed.`;
 
 const _NEED = [
     '@anthropic-ai/sdk', '@anthropic-ai/vertex-sdk', '@google/generative-ai',
@@ -55,6 +54,7 @@ const [
     CLAUDE_35_HAIKU, CLOUD_37_SONNET, AUDIO, WAV, CHATGPT_MINI, ATTACHMENTS,
     CHAT, OPENAI_VOICE, MEDIUM, LOW, HIGH, GPT_REASONING_EFFORT, THINK,
     THINK_STR, THINK_END, AZURE, TOOLS_STR, TOOLS_END, TOOLS, TEXT, THINKING,
+    OK,
 ] = [
         'OPENAI', 'GEMINI', 'CHATGPT', 'OPENAI_EMBEDDING', 'GEMINI_EMEDDING',
         'OPENAI_TRAINING', 'OLLAMA', 'CLAUDE', 'gpt-4o-mini', 'gpt-4o', 'o1',
@@ -66,7 +66,7 @@ const [
         'claude-3-7-sonnet@20250219', 'audio', 'wav', 'CHATGPT_MINI',
         '[ATTACHMENTS]', 'CHAT', 'OPENAI_VOICE', 'medium', 'low', 'high',
         'medium', 'think', '<think>', '</think>', 'AZURE', '<tools>',
-        '</tools>', 'tools', 'text', 'thinking',
+        '</tools>', 'tools', 'text', 'thinking', 'OK',
     ];
 
 const [
@@ -99,6 +99,7 @@ const [tokenSafeRatio, GPT_QUERY_LIMIT, minsOfDay] = [1.1, 100, 60 * 24];
 const tokenSafe = count => Math.ceil(count * tokenSafeRatio);
 const clients = {};
 const size8k = 7680 * 4320;
+const MAX_TOOL_RECURSION = 10;
 const LOG = { log: true };
 const OPENAI_BASE_URL = 'https://api.openai.com/v1';
 const sessionType = `${name.toUpperCase()}-SESSION`;
@@ -111,6 +112,7 @@ const log = (cnt, opt) => _log(cnt, import.meta.url, { time: 1, ...opt || {} });
 const CONTENT_IS_REQUIRED = 'Content is required.';
 const assertContent = content => assert(content.length, CONTENT_IS_REQUIRED);
 const packThink = thk => thk ? [`${THINK_STR}\n${thk}\n${THINK_END}`] : [];
+const countToolCalls = r => r?.split('\n').filter(x => x === TOOLS_STR).length;
 
 const DEFAULT_MODELS = {
     [CHATGPT_MINI]: GPT_4O_MINI,
@@ -412,6 +414,7 @@ const tools = [
             }
         },
         func: async () => new Date().toLocaleString(),
+        showRes: true,
     },
     {
         def: {
@@ -429,6 +432,7 @@ const tools = [
             }
         },
         func: async args => (await distill(args?.url))?.summary,
+        showReq: true,
     },
     {
         def: {
@@ -446,6 +450,7 @@ const tools = [
             }
         },
         func: async args => await search(args?.keyword),
+        showReq: true,
     },
 ];
 
@@ -738,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; }
@@ -764,30 +773,29 @@ const packGptResp = async (resp, options) => {
 };
 
 const handleToolsCall = async (msg, options) => {
-    let [content, preRes, input, packMsg, toolsResponse] = [
-        [], [], [], null,
-        options?.currentResponse ? `${options?.currentResponse}\n` : '',
+    let [content, preRes, input, packMsg, toolsResponse, responded] = [
+        [], [], [], null, options?.result ? options?.result.trim() : '', false
     ];
-    const resp = async (msg) => {
-        toolsResponse = [...toolsResponse ? [toolsResponse] : [], msg].join('\n');
-        await ignoreErrFunc(async () => await options?.stream?.(await packGptResp({
-            choices: [{ message: { content: options?.delta ? msg : toolsResponse } }]
-        }, { ...options || {}, processing: true })), LOG);
+    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(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;
-                    packMsg = (c, is_error) => ({
-                        type: 'tool_result', tool_use_id: fn.id,
-                        content: JSON.stringify(c), is_error,
+                    packMsg = (content, is_error) => ({
+                        type: 'tool_result', tool_use_id: fn.id, content, is_error,
                     });
                     break;
                 case GEMINI:
@@ -795,8 +803,7 @@ const handleToolsCall = async (msg, options) => {
                     packMsg = (t, e) => ({
                         functionResponse: {
                             name: fn.name, response: {
-                                name: fn.name,
-                                content: e ? `[Error] ${t}` : JSON.stringify(t),
+                                name: fn.name, content: e ? `[Error] ${t}` : t,
                             }
                         }
                     });
@@ -810,34 +817,45 @@ 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;
             description && await resp(`Description: ${description}`);
+            f.showReq && isSet(input, true) && Object.keys(input).length
+                && await resp(`Input: ${JSON.stringify(input)}`);
             try {
-                content.push(packMsg((await f?.func(input)) ?? 'OK'));
-                await resp(`Status: OK`);
+                const output = JSON.stringify((await f?.func(input)) ?? OK);
+                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
@@ -864,81 +882,63 @@ const promptChatGPT = async (content, options = {}) => {
     assert(!(
         options?.reasoning && !MODELS[options.model]?.reasoning
     ), `This model does not support reasoning: ${options.model}`);
-    let format;
-    [format, options.audioMimeType, options.suffix]
-        = options?.stream ? ['pcm16', pcm16, 'pcm.wav'] : [WAV, wav, WAV];
-    let [resp, resultText, resultAudio, chunk, resultTools] = [
-        await client.chat.completions.create({
-            modalities, audio: options?.audio || (
-                modalities?.find?.(x => x === AUDIO) && {
-                    voice: DEFAULT_MODELS[OPENAI_VOICE], format
-                }
-            ), ...messages([
-                ...options?.messages || [], message,
-                ...options?.toolsResult || [],
-            ]), ...MODELS[options.model]?.tools ? {
-                tools: options?.tools ?? tools.map(x => x.def),
-            } : {}, ...options?.jsonMode ? {
-                response_format: { type: JSON_OBJECT }
-            } : {}, model: options.model, stream: !!options?.stream,
-            store: true, tool_choice: 'auto',
-        }), options?.toolsResponse ? `${options?.toolsResponse}\n\n` : '',
-        Buffer.alloc(0), null, [],
-    ];
-    if (options?.stream) {
-        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 }
-            ) : 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);
-                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);
-                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);
-                }
-            }
-            if (deltaText === '' && !deltaAudio.length) { continue; }
-            resultText += deltaText;
-            resultAudio = Buffer.concat([resultAudio, deltaAudio]);
-            const respAudio = options?.delta ? deltaAudio : resultAudio;
-            chunk.choices[0].message = {
-                content: options?.delta ? deltaText : resultText,
-                ...respAudio.length ? { audio: { data: respAudio } } : {},
-            };
-            await ignoreErrFunc(async () => await options?.stream?.(
-                await packGptResp(chunk, { ...options || {}, processing: true })
-            ), LOG);
+    [options.audioMimeType, options.suffix] = [pcm16, 'pcm.wav'];
+    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)
+            && { voice: DEFAULT_MODELS[OPENAI_VOICE], format: 'pcm16' }
+        ), ...messages([
+            ...options?.messages || [], message, ...options?.toolsResult || [],
+        ]), ...MODELS[options.model]?.tools ? {
+            tools: options?.tools ?? tools.map(x => x.def),
+        } : {}, ...options?.jsonMode ? {
+            response_format: { type: JSON_OBJECT }
+        } : {}, model: options.model, stream: true,
+        store: true, tool_choice: 'auto',
+    });
+    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);
+        for (const x of delta.tool_calls || []) {
+            let curFunc = resultTools.find(y => y.index === x.index);
+            curFunc || (resultTools.push(curFunc = {}));
+            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: '' });
+            x?.function?.name && (curFunc.function.name += x.function.name);
+            x?.function?.arguments && (curFunc.function.arguments += x.function.arguments);
         }
-        chunk.choices?.[0] || (chunk.choices = [{}]); // handle empty choices for Azure APIs
-        chunk.choices[0].message = {
-            content: resultText, tool_calls: resultTools,
-            ...resultAudio.length ? { audio: { data: resultAudio } } : {},
-        };
-        resp = chunk;
+        deltaText && (responded = responded || (deltaText = `\n\n${deltaText}`));
+        result += deltaText;
+        resultAudio = Buffer.concat([resultAudio, deltaAudio]);
+        const respAudio = options?.delta ? deltaAudio : resultAudio;
+        await streamResp({
+            text: options?.delta ? deltaText : result,
+            ...respAudio.length ? { audio: { data: respAudio } } : {},
+        }, options);
     }
+    event = {
+        role: assistant, text: result, tool_calls: resultTools,
+        ...resultAudio.length ? { audio: { data: resultAudio } } : {},
+    };
     const { toolsResult, toolsResponse }
-        = await handleToolsCall(resp?.choices?.[0]?.message, options);
-    options?.toolsResponse && !options?.stream && (
-        resp.choices[0].message.content = [
-            options?.toolsResponse, resp.choices[0].message.content,
-        ].join('\n\n')
-    );
-    return await (toolsResult.length && !options?.toolsResult ? promptChatGPT(
-        content, { ...options || {}, toolsResult, toolsResponse }
-    ) : packGptResp(resp, options));
+        = await handleToolsCall(event, { ...options, result });
+    if (toolsResult.length && countToolCalls(toolsResponse) < MAX_TOOL_RECURSION) {
+        return promptChatGPT(content, { ...options, toolsResult, result: toolsResponse });
+    }
+    event.text = mergeMsgs(toolsResponse, toolsResult);
+    return await packGptResp(event, options);
 };
 
-const promptAzure = async (content, options = {}) => await promptChatGPT(
-    content, { ...options, provider: AZURE }
-);
+const promptAzure = async (content, options = {}) =>
+    await promptChatGPT(content, { ...options, provider: AZURE });
 
 const promptOllama = async (content, options = {}) => {
     const { client, model } = await getOllamaClient(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: !!options?.stream, ...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,68 +980,42 @@ const promptClaude = async (content, options = {}) => {
             tool_choice: { type: 'auto' },
         } : {},
     });
-    let [event, txtResult, thinking, signature, result, thinkEnd, tool_calls]
-        = [null, '', '', '', options?.toolsResponse || '', '', []];
-    if (options?.stream) {
-        for await (event of resp) {
-            let [thkDelta, txtDelta] = [
-                event?.content_block?.thinking || event?.delta?.thinking || '',
-                event?.content_block?.text || event?.delta?.text || '',
-            ];
-            txtResult += 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`);
-            }
-            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);
+    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?.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;
         }
-        event.content = [{
-            type: TEXT, text: tool_calls.length ? txtResult : result,
-        }];
-        tool_calls.length && thinking
-            && event.content.unshift({ type: THINKING, thinking, signature });
-    } else {
-        event = resp;
-        tool_calls = resp?.content?.filter?.(x => x.type === 'tool_use') || [];
+        txtDelta = thkDelta + txtDelta;
+        result += txtDelta;
+        await streamResp({ text: options?.delta ? txtDelta : result }, options);
     }
+    event = {
+        role: assistant, content: [
+            ...thinking ? [{ type: THINKING, thinking, signature }] : [],
+            ...text ? [{ type: TEXT, text }] : [], ...tool_use,
+        ]
+    };
     const { toolsResult, toolsResponse } = await handleToolsCall(
-        { tool_calls }, { ...options, currentResponse: result, flavor: CLAUDE },
+        event, { ...options, result, flavor: CLAUDE },
     );
-    if (toolsResult.length && !options?.toolsResult) {
-        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,
         });
-    } else {
-        const textPart = event.content.find(x => x.type == TEXT);
-        const thinkPart = event.content.find(x => x.type == THINKING);
-        const prvThink = options?.toolsResult?.find(
-            x => x?.content?.find(y => y?.type === THINKING)
-        )?.content?.find(x => x?.type === THINKING);
-        textPart.text = [
-            ...packThink(options?.stream ? null : prvThink?.thinking),
-            ...packThink(options?.stream ? null : thinkPart?.thinking),
-            ...options?.toolsResponse ? [options?.toolsResponse] : [],
-            textPart.text,
-        ].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.34",
+    "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.34",
+    "version": "1998.2.36",
     "private": false,
     "homepage": "https://github.com/Leask/utilitas",
     "main": "index.mjs",