utilitas 1998.2.34 → 1998.2.35

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,
     },
 ];
 
@@ -764,18 +769,18 @@ 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]
+        = [[], [], [], null, options?.result ? options?.result.trim() : ''];
     const resp = async (msg) => {
-        toolsResponse = [...toolsResponse ? [toolsResponse] : [], msg].join('\n');
+        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);
     };
     if (msg?.tool_calls?.length) {
-        await resp(TOOLS_STR);
+        await resp(`\n${TOOLS_STR}`);
         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;
@@ -785,9 +790,8 @@ const handleToolsCall = async (msg, options) => {
             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 +799,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,
                             }
                         }
                     });
@@ -815,14 +818,17 @@ const handleToolsCall = async (msg, options) => {
                 x.def?.function?.name || x?.def?.name, name
             ));
             if (!f?.func) {
-                content.push(packMsg(`Function call failed, invalid function name: ${name}`, true));
+                content.push(packMsg(`Function call failed: invalid function name ${name}`, true));
                 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}`);
@@ -864,81 +870,75 @@ 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, [],
+    [options.audioMimeType, options.suffix] = [pcm16, 'pcm.wav'];
+    let [result, resultAudio, chunk, resultTools] = [
+        options?.result ? `${options?.result}\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);
-                }
+    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 (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);
         }
-        chunk.choices?.[0] || (chunk.choices = [{}]); // handle empty choices for Azure APIs
+        if (deltaText === '' && !deltaAudio.length) { continue; }
+        result += deltaText;
+        resultAudio = Buffer.concat([resultAudio, deltaAudio]);
+        const respAudio = options?.delta ? deltaAudio : resultAudio;
         chunk.choices[0].message = {
-            content: resultText, tool_calls: resultTools,
-            ...resultAudio.length ? { audio: { data: resultAudio } } : {},
+            content: options?.delta ? deltaText : result,
+            ...respAudio.length ? { audio: { data: respAudio } } : {},
         };
-        resp = chunk;
+        await ignoreErrFunc(async () => await options?.stream?.(
+            await packGptResp(chunk, { ...options, processing: true })
+        ), LOG);
     }
-    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')
+    chunk.choices?.[0] || (chunk.choices = [{}]); // handle empty choices for Azure APIs
+    chunk.choices[0].message = {
+        content: result, tool_calls: resultTools,
+        ...resultAudio.length ? { audio: { data: resultAudio } } : {},
+    };
+    const { toolsResult, toolsResponse } = await handleToolsCall(
+        chunk?.choices?.[0]?.message, { ...options, result }
     );
-    return await (toolsResult.length && !options?.toolsResult ? promptChatGPT(
-        content, { ...options || {}, toolsResult, toolsResponse }
-    ) : packGptResp(resp, options));
+
+    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);
 };
 
-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);
@@ -972,7 +972,7 @@ const promptClaude = async (content, options = {}) => {
         messages: [
             ...options?.messages || [], buildClaudeMessage(content, options),
             ...options?.toolsResult || [],
-        ], stream: !!options?.stream, ...reasoning ? {
+        ], stream: true, ...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,57 @@ const promptClaude = async (content, options = {}) => {
             tool_choice: { type: 'auto' },
         } : {},
     });
-    let [event, txtResult, thinking, signature, result, thinkEnd, tool_calls]
+    let [event, text, 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);
+    for await (event of resp) {
+        let [thkDelta, txtDelta] = [
+            event?.content_block?.thinking || event?.delta?.thinking || '',
+            event?.content_block?.text || event?.delta?.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`);
         }
-        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') || [];
+        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);
     }
+    event.content = [{ type: TEXT, text }];
+    tool_calls.length && thinking
+        && event.content.unshift({ type: THINKING, thinking, signature });
     const { toolsResult, toolsResponse } = await handleToolsCall(
-        { tool_calls }, { ...options, currentResponse: result, flavor: CLAUDE },
+        { tool_calls }, { ...options, toolsResponse: result, flavor: CLAUDE },
     );
-    if (toolsResult.length && !options?.toolsResult) {
+    if (toolsResult.length && countToolCalls(toolsResponse) < MAX_TOOL_RECURSION) {
         toolsResult[0].content.unshift(
             ...event?.content.filter(x => x?.type !== 'tool_use')
         );
         return await promptClaude(content, {
             ...options, toolsResult, 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);
+    }
+    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);
 };
 
 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.35",
     "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.35",
     "private": false,
     "homepage": "https://github.com/Leask/utilitas",
     "main": "index.mjs",