utilitas 1998.2.36 → 1998.2.38

package/lib/alan.mjs

@@ -54,7 +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,
+    OK, FUNC,
 ] = [
         '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', 'OK',
+        '</tools>', 'tools', 'text', 'thinking', 'OK', 'function',
     ];
 
 const [
@@ -90,7 +90,7 @@ const [tool, provider, messages, text] = [
 const [name, user, system, assistant, MODEL, JSON_OBJECT, TOOL, silent]
     = ['Alan', 'user', 'system', 'assistant', 'model', 'json_object', 'tool', true];
 const [CODE_INTERPRETER, RETRIEVAL, FUNCTION]
-    = ['code_interpreter', 'retrieval', 'function'].map(tool);
+    = ['code_interpreter', 'retrieval', FUNC].map(tool);
 const [NOT_INIT, INVALID_FILE]
     = ['AI engine has not been initialized.', 'Invalid file data.'];
 const chatConfig
@@ -442,7 +442,10 @@ const tools = [
                 parameters: {
                     type: 'object',
                     properties: {
-                        keyword: { type: 'string', description: 'The keyword you need to search for.' }
+                        keyword: { type: 'string', description: 'The keyword you need to search for.' },
+                        num: { type: 'integer', description: 'The number of search results you need, default `10`.' },
+                        start: { type: 'integer', description: 'The start index of the search results, default `1`.' },
+                        image: { type: 'boolean', description: 'Whether to search for images, default `false`.' },
                     },
                     required: ['keyword'],
                     additionalProperties: false
@@ -751,8 +754,7 @@ const streamResp = async (resp, options) => {
 
 const packGptResp = async (resp, options) => {
     // simple mode is not recommended for streaming responses
-    let text = resp.text                                                        // ChatGPT / Claude
-        || (Function.isFunction(resp?.text) ? resp.text() : resp?.text)         // Gemini
+    let text = resp.text                                                        // ChatGPT / Claude / Gemini
         || resp?.message?.content || '';                                        // Ollama
     const audio = resp?.message?.audio?.data;                                   // ChatGPT audio mode
     if (options?.raw) { return resp; }
@@ -783,27 +785,30 @@ const handleToolsCall = async (msg, options) => {
         toolsResponse = (toolsResponse + m).trim();
         await streamResp({ text: options?.delta ? m : toolsResponse }, options);
     };
-    const calls = msg.tool_calls || msg.content || [];
+    const calls = msg.tool_calls || msg.content || msg.parts || [];
     if (calls.length) {
         switch (options?.flavor) {
             case CLAUDE: preRes.push(msg); break;
-            case GEMINI: preRes.push({ role: MODEL, parts: msg?.tool_calls.map(x => ({ functionCall: x })) }); break;
+            case GEMINI: preRes.push(msg); break;
             case CHATGPT: default: preRes.push(msg); break;
         }
         for (const fn of calls) {
             switch (options?.flavor) {
                 case CLAUDE:
-                    input = fn.input = String.isString(fn?.input) ? parseJson(fn.input) : fn?.input;
+                    input = fn.input = String.isString(fn?.input)
+                        ? parseJson(fn.input) : fn?.input;
                     packMsg = (content, is_error) => ({
-                        type: 'tool_result', tool_use_id: fn.id, content, is_error,
+                        type: 'tool_result', tool_use_id: fn.id,
+                        content, is_error,
                     });
                     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,
                             }
                         }
                     });
@@ -816,7 +821,7 @@ 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(
@@ -843,13 +848,18 @@ const handleToolsCall = async (msg, options) => {
                 log(rt);
             }
         }
-        switch (options?.flavor) {
-            case CLAUDE: content = content.length ? [{ role: user, content }] : []; break;
-            case GEMINI: content = [{ role: user, parts: content }]; break;
+        if (content.length) {
+            switch (options?.flavor) {
+                case CLAUDE: content = [{ role: user, content }]; break;
+                case GEMINI: content = [{ role: FUNC, parts: content }]; break;
+            }
         }
         responded && await resp(`\n${TOOLS_END}`);
     }
-    return { toolsResult: [...content.length ? preRes : [], ...content], toolsResponse };
+    return {
+        toolsResult: [...content.length ? preRes : [], ...content],
+        toolsResponse,
+    };
 };
 
 const mergeMsgs = (resp, calls) => [resp, ...calls.length ? [
@@ -1012,7 +1022,8 @@ const promptClaude = async (content, options = {}) => {
     );
     if (tool_use.length && countToolCalls(toolsResponse) < MAX_TOOL_RECURSION) {
         return await promptClaude(content, {
-            ...options, toolsResult: [...options?.toolsResult || [], ...toolsResult], result: toolsResponse,
+            ...options, toolsResult: [...options?.toolsResult || [],
+            ...toolsResult], result: toolsResponse,
         });
     }
     return packGptResp({ text: mergeMsgs(toolsResponse, tool_use) }, options);
@@ -1078,54 +1089,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, responded]
+        = [options?.result ?? '', null, null];
+    for await (const chunk of resp.stream) {
+        functionCalls || (functionCalls = chunk.functionCalls);
+        const rfc = packGeminiReferences(
+            chunk.candidates[0]?.groundingMetadata?.groundingChunks,
+            chunk.candidates[0]?.groundingMetadata?.groundingSupports
+        );
+        rfc && (references = rfc);
+        let delta = chunk?.text?.() || '';
+        delta && (responded = responded || (delta = `\n\n${delta}`));
+        result += delta;
+        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 (toolsResult.length && countToolCalls(toolsResponse) < MAX_TOOL_RECURSION) {
+        return promptGemini(content, {
+            ...options || {}, toolsResult: [...options?.toolsResult || [],
+            ...toolsResult], result: toolsResponse,
+        });
+    }
+    return await packGptResp({
+        text: mergeMsgs(toolsResponse, toolsResult), 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.36",
+    "version": "1998.2.38",
     "private": false,
     "homepage": "https://github.com/Leask/utilitas",
     "main": "index.mjs",

package/lib/shot.mjs

@@ -5,6 +5,7 @@ import { sha256 } from './encryption.mjs';
 import { distillHtml } from './web.mjs';
 
 import {
+    ensureInt,
     ensureString, extract, ignoreErrFunc, inBrowser, parseJson, parseVersion,
     throwError, which
 } from './utilitas.mjs';
@@ -160,66 +161,28 @@ const initSearch = (options) => {
 };
 
 const search = async (query, options) => {
+    const [key, cx, min, max]
+        = [options?.apiKey || googleApiKey, options?.cx || googleCx, 1, 10];
     assert(query, 'Query is required.');
-    const [GOOGLE, DUCKDUCKGO] = ['GOOGLE', 'DUCKDUCKGO'];
-    const provider = ensureString(
-        options?.provider || searchProvider || DUCKDUCKGO, { case: 'UP' }
-    );
-    let apiKey = options?.apiKey || googleApiKey, cx = options?.cx || googleCx,
-        url, parser;
-    switch (provider) {
-        case GOOGLE:
-            assert(apiKey, 'API key is required.');
-            assert(cx, 'CX is required.');
-            url = 'https://www.googleapis.com/customsearch/v1'
-                + `?key=${encodeURIComponent(apiKey)}`
-                + `&cx=${encodeURIComponent(cx)}`
-                + `&q=${encodeURIComponent(query)}`;
-            break;
-        case DUCKDUCKGO:
-            url = 'https://api.duckduckgo.com/'
-                + `?q=${encodeURIComponent(query)}&format=json&skip_disambig=1`;
-            parser = x => x.FirstURL ? {
-                title: x.FirstURL.replace(/^.*\/([^\/]*)$/, '$1').replace(/_/g, ' '),
-                link: x.FirstURL, snippet: x.Text,
-                image: `https://duckduckgo.com${x.Icon.URL}`, source: null,
-            } : null;
-            break;
-        default:
-            throwError(`Invalid provider: ${provider}.`);
-    }
+    assert(key, 'API key is required.');
+    assert(cx, 'CX is required.');
+    const num = ensureInt(options?.num || max, { min, max });
+    const start = ensureInt(options?.start || min, { min });
+    assert(start + num <= 100, 'Reached maximum search limit.');
+    const url = 'https://www.googleapis.com/customsearch/v1'
+        + `?key=${encodeURIComponent(key)}&cx=${encodeURIComponent(cx)}`
+        + `&q=${encodeURIComponent(query)}&num=${num}&start=${start}`
+        + (options?.image ? `&searchType=image` : '');
     const resp = await get(url, { encode: _JSON, ...options || {} });
-    let result = [];
-    if (options?.raw) {
-        result = resp.content;
-    } else if (provider === GOOGLE) {
-        result.push(...resp?.content?.items.map(x => ({
-            title: x.title, link: x.link, snippet: x.snippet,
-            image: x.pagemap?.cse_image?.[0]?.src || null,
-        })));
-    } else if (provider === DUCKDUCKGO) {
-        const cnt = resp?.content;
-        if (cnt?.Abstract) {
-            result.push({
-                title: cnt?.Heading + (cnt?.Entity ? ` (${cnt.Entity})` : ''),
-                link: cnt?.AbstractURL, snippet: cnt?.AbstractText,
-                image: cnt?.Image ? `https://duckduckgo.com${cnt.Image}` : null,
-                source: cnt?.AbstractSource,
-            });
-            if (cnt?.Results) {
-                result.push(...cnt.Results.map(x => ({
-                    title: x.Text, link: x.FirstURL, snippet: null,
-                    image: x.Icon ? `https://duckduckgo.com${x.Icon.URL}` : null,
-                    source: null,
-                })));
-            }
-        } else if (cnt?.RelatedTopics?.[0] && !options?.no_recurse) {
-            result = await search(cnt.RelatedTopics[0].FirstURL.replace(
-                /^.*\/([^\/]*)$/, '$1'
-            ).replace(/_/g, ' '), { ...options, no_recurse: true });
-        }
-    }
-    return result;
+    return options?.raw ? resp.content : {
+        totalResults: resp?.content?.searchInformation?.totalResults || 0,
+        startIndex: resp?.content?.queries?.request?.[0]?.startIndex || 1,
+        items: resp?.content?.items.map(x => ({
+            title: x.title, link: options?.image ? null : x.link,
+            snippet: x.snippet,
+            image: (options?.image ? x.link : x.pagemap?.cse_image?.[0]?.src) || null,
+        })),
+    };
 };
 
 export default get;

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "utilitas",
     "description": "Just another common utility for JavaScript.",
-    "version": "1998.2.36",
+    "version": "1998.2.38",
     "private": false,
     "homepage": "https://github.com/Leask/utilitas",
     "main": "index.mjs",