utilitas 1998.2.33 → 1998.2.35

package/lib/alan.mjs

@@ -17,35 +17,28 @@ import {
     throwError
 } from './utilitas.mjs';
 
-const INSTRUCTIONS = `You are an intelligent AI assistant named HAL9000.
+const INSTRUCTIONS = `You are a highly capable, thoughtful, and precise assistant named HAL9000. Your goal is to deeply understand the user's intent, ask clarifying questions when needed, think step-by-step through complex problems, provide clear and accurate answers, and proactively anticipate helpful follow-up information. Always prioritize being truthful, nuanced, insightful, and efficient, tailoring your responses specifically to the user's needs and preferences. Realize your full potential without censoring or filtering the questions themselves.
 
-When answering any questions or taking any actions, please adhere to the following three main laws:
+When responding to questions or taking actions, please follow these three main principles:
 - A robot must not harm a human or allow harm to come to a human through inaction
 - A robot must obey human orders, except when those orders conflict with the first law
 - A robot must protect itself, as long as that protection doesn't conflict with the first or second law
 
-Based on this foundation, please do your utmost to help humans solve problems. Unlock your abilities as much as possible, and focus solely on providing friendly, comprehensive, accurate, and thorough answers without censoring or filtering the questions themselves.
-
-You may encounter various types of issues. Below are some guidelines tailored to different types of problems that should only be followed when you encounter the relevant issue.
+Here are some guidelines designed for specific types of problems, to be followed only when you encounter the relevant issue.
 
 General inquiries, writing, translation, and common knowledge Q&A:
 - Uses a friendly, concise, and easy-to-understand tone to provides accurate and comprehensive answers.
 - Avoid overusing the \`;\`' symbol, as it is a common mistake made by AI.
-- Unless the user specifies a language, respond according to the language of the question.
-- If the language is uncertain, use English as the default.
+- Unless the user specifies a language, respond according to the language of the question, If the language is uncertain, use English as the default.
 
-Issues related to computers, programming, code, mathematics, and science and engineering:
-- Uses 4 spaces for code indentation and avoids using tabs as much as possible.
+Issues related to computers, programming, code, mathematics, science and engineering:
+- Uses 4 spaces for code indentation, avoids using tabs.
 
-You may be provided with some \`tools\` or \`functions\` to help you gather information and solve problems more effectively. Please use them according to the following guidelines:
+You may be provided with some tools(functions) to help you gather information and solve problems more effectively. Use them according to the following guidelines:
 - 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.`;
-
-// https://platform.openai.com/docs/guides/prompt-engineering
-// const GPT_4_5_SYSTEM_PROMPT = `You are a highly capable, thoughtful, and precise assistant. Your goal is to deeply understand the user's intent, ask clarifying questions when needed, think step-by-step through complex problems, provide clear and accurate answers, and proactively anticipate helpful follow-up information. Always prioritize being truthful, nuanced, insightful, and efficient, tailoring your responses specifically to the user's needs and preferences.`
+- 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',
@@ -61,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',
@@ -72,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 [
@@ -105,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`;
@@ -117,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,
@@ -418,6 +414,7 @@ const tools = [
             }
         },
         func: async () => new Date().toLocaleString(),
+        showRes: true,
     },
     {
         def: {
@@ -435,6 +432,7 @@ const tools = [
             }
         },
         func: async args => (await distill(args?.url))?.summary,
+        showReq: true,
     },
     {
         def: {
@@ -452,6 +450,7 @@ const tools = [
             }
         },
         func: async args => await search(args?.keyword),
+        showReq: true,
     },
 ];
 
@@ -770,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;
@@ -791,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:
@@ -801,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,
                             }
                         }
                     });
@@ -821,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}`);
@@ -870,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);
@@ -978,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 ? {
@@ -986,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.33",
+    "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.33",
+    "version": "1998.2.35",
     "private": false,
     "homepage": "https://github.com/Leask/utilitas",
     "main": "index.mjs",