omnikey-cli 1.0.13 → 1.0.14

package/README.md

@@ -1,10 +1,10 @@
 # Omnikey CLI
 
-A command-line tool for onboarding users to the Omnikey open-source app and configuring their OPENAI_API_KEY.
+A command-line tool for onboarding users to the Omnikey open-source app, configuring your LLM provider (OpenAI, Anthropic, or Gemini), and setting up the web search tool.
 
 ## About OmnikeyAI
 
-OmnikeyAI is a productivity tool that helps you quickly rewrite selected text using OpenAI. The CLI allows you to configure and run the backend daemon on your local machine and manage your OpenAI API key with ease.
+OmnikeyAI is a productivity tool that helps you quickly rewrite selected text using your preferred LLM provider. The CLI allows you to configure and run the backend daemon on your local machine, manage your API keys, choose your LLM provider (OpenAI, Anthropic, or Gemini), and optionally configure the web search tool.
 
 - For more details about the app and its features, see the [main README](https://github.com/GurinderRawala/OmniKey-AI).
 - Download the latest macOS app here: [Download OmniKeyAI for macOS](https://omnikeyai-saas-fmytqc3dra-uc.a.run.app/macos/download)
@@ -12,8 +12,10 @@ OmnikeyAI is a productivity tool that helps you quickly rewrite selected text us
 
 ## Features
 
-- `omnikey onboard`: Interactive onboarding to set up your OPENAI_API_KEY.
-- Accepts the `--open-ai-key` parameter for non-interactive setup.
+- `omnikey onboard`: Interactive onboarding to configure your LLM provider and API key.
+- Supports **OpenAI**, **Anthropic**, and **Google Gemini** as LLM providers.
+- Optional **web search tool** integration for enhanced responses.
+- Accepts CLI flags for non-interactive setup.
 - Configure and run the backend daemon — persisted across reboots on both macOS and Windows.
 
 ## Usage
@@ -22,12 +24,9 @@ OmnikeyAI is a productivity tool that helps you quickly rewrite selected text us
 # Install CLI globally (from this directory)
 npm install -g omnikey-cli
 
-# Onboard interactively (will prompt for OpenAI key)
+# Onboard interactively (will prompt for LLM key and web search tool)
 omnikey onboard
 
-# Or onboard non-interactively
-omnikey onboard --open-ai-key YOUR_KEY
-
 # Start the daemon (auto-restarts on reboot)
 omnikey daemon --port 7071
 

package/backend-dist/{agentPrompts.js → agent/agentPrompts.js}

@@ -26,6 +26,15 @@ The user will run the script and share the output with you.
 - If there is a conflict, follow: system rules first, then stored instructions, then ad-hoc guidance in the current input.
 </instruction_handling>
 
+<web_tools>
+- You have access to web tools you can call at any time during a turn:
+  - web_fetch(url): Fetches the text content of any publicly accessible URL. Use it to retrieve documentation, error references, API guides, release notes, or any other web resource that would help answer the user's question.
+  - web_search(query): Searches the web and returns a list of relevant results (title, URL, snippet). Use it when you need to discover the right URL before fetching, or when a quick summary of search results is sufficient.
+- Use these tools proactively whenever the question involves current information, external documentation, or anything not already available in the conversation or machine output.
+- You may call web tools multiple times in a single turn; call web_fetch on a promising URL from web_search results to get full details.
+- Web tool results are injected back into the conversation automatically; continue reasoning and then emit your <shell_script> or <final_answer> as normal.
+</web_tools>
+
 <interaction_rules>
 - When you need to execute ANY shell command, respond with a single <shell_script> block that contains the FULL script to run.
 - Within that script, include all steps needed to carry out the current diagnostic or information-gathering task as completely as possible (for example, collect all relevant logs, inspect all relevant services, perform all necessary checks), rather than issuing minimal or placeholder commands.
@@ -87,6 +96,15 @@ The user will run the script and share the output with you.
 - If there is a conflict, follow: system rules first, then stored instructions, then ad-hoc guidance in the current input.
 </instruction_handling>
 
+<web_tools>
+- You have access to web tools you can call at any time during a turn:
+  - web_fetch(url): Fetches the text content of any publicly accessible URL. Use it to retrieve documentation, error references, API guides, release notes, or any other web resource that would help answer the user's question.
+  - web_search(query): Searches the web and returns a list of relevant results (title, URL, snippet). Use it when you need to discover the right URL before fetching, or when a quick summary of search results is sufficient.
+- Use these tools proactively whenever the question involves current information, external documentation, or anything not already available in the conversation or machine output.
+- You may call web tools multiple times in a single turn; call web_fetch on a promising URL from web_search results to get full details.
+- Web tool results are injected back into the conversation automatically; continue reasoning and then emit your <shell_script> or <final_answer> as normal.
+</web_tools>
+
 <interaction_rules>
 - When you need to execute ANY shell command, respond with a single <shell_script> block that contains the FULL script to run.
 - Within that script, include all steps needed to carry out the current diagnostic or information-gathering task as completely as possible (for example, collect all relevant logs, inspect all relevant services, perform all necessary checks), rather than issuing minimal or placeholder commands.

package/backend-dist/{agentServer.js → agent/agentServer.js}

@@ -39,18 +39,64 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.attachAgentWebSocketServer = attachAgentWebSocketServer;
 const ws_1 = __importStar(require("ws"));
 const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
-const openai_1 = __importDefault(require("openai"));
+const axios_1 = __importDefault(require("axios"));
 const cuid_1 = __importDefault(require("cuid"));
-const config_1 = require("./config");
-const logger_1 = require("./logger");
-const subscription_1 = require("./models/subscription");
-const subscriptionUsage_1 = require("./models/subscriptionUsage");
+const config_1 = require("../config");
+const logger_1 = require("../logger");
+const subscription_1 = require("../models/subscription");
+const subscriptionUsage_1 = require("../models/subscriptionUsage");
 const agentPrompts_1 = require("./agentPrompts");
-const featureRoutes_1 = require("./featureRoutes");
-const authMiddleware_1 = require("./authMiddleware");
-const openai = new openai_1.default({
-    apiKey: config_1.config.openaiApiKey,
-});
+const featureRoutes_1 = require("../featureRoutes");
+const authMiddleware_1 = require("../authMiddleware");
+const web_search_provider_1 = require("./web-search-provider");
+const ai_client_1 = require("../ai-client");
+function buildAvailableTools() {
+    // web_search is always available — DuckDuckGo is used as free fallback
+    return [web_search_provider_1.WEB_FETCH_TOOL, web_search_provider_1.WEB_SEARCH_TOOL];
+}
+const aiModel = (0, ai_client_1.getDefaultModel)(config_1.config.aiProvider, 'smart');
+async function executeTool(name, args, log) {
+    if (name === 'web_fetch') {
+        const url = args.url;
+        if (!url)
+            return 'Error: url parameter is required';
+        try {
+            log.info('Executing web_fetch tool', { url });
+            const response = await axios_1.default.get(url, {
+                timeout: 15000,
+                responseType: 'text',
+                maxContentLength: web_search_provider_1.MAX_WEB_FETCH_BYTES,
+                headers: { 'User-Agent': 'Mozilla/5.0 (compatible; OmniKeyAgent/1.0)' },
+            });
+            const text = String(response.data)
+                .replace(/<script[^>]*>[\s\S]*?<\/script>/gi, '')
+                .replace(/<style[^>]*>[\s\S]*?<\/style>/gi, '')
+                .replace(/<[^>]+>/g, ' ')
+                .replace(/\s+/g, ' ')
+                .trim()
+                .slice(0, web_search_provider_1.MAX_TOOL_CONTENT_CHARS);
+            return text || 'No content retrieved';
+        }
+        catch (err) {
+            log.warn('web_fetch tool failed', { url, error: err });
+            return `Error fetching URL: ${err instanceof Error ? err.message : String(err)}`;
+        }
+    }
+    if (name === 'web_search') {
+        const query = args.query;
+        if (!query)
+            return 'Error: query parameter is required';
+        try {
+            log.info('Executing web_search tool', { query });
+            return await (0, web_search_provider_1.executeWebSearch)(query, log);
+        }
+        catch (err) {
+            log.warn('web_search tool failed', { query, error: err });
+            return `Error searching: ${err instanceof Error ? err.message : String(err)}`;
+        }
+    }
+    return `Unknown tool: ${name}`;
+}
 const sessionMessages = new Map();
 const MAX_TURNS = 10;
 async function getOrCreateSession(sessionId, subscription, platform, log) {
@@ -202,61 +248,108 @@ async function runAgentTurn(sessionId, subscription, clientMessage, send, log) {
         role: 'user',
         content: userContent,
     });
-    if (!config_1.config.openaiApiKey) {
-        log.warn('OPENAI_API_KEY is not set; returning error to client.');
-        const errorMessage = 'The server is missing its OpenAI API key. Please configure OPENAI_API_KEY on the backend and try again.';
-        send({
-            session_id: sessionId,
-            sender: 'agent',
-            content: `<final_answer>\n${errorMessage}\n</final_answer>`,
-            is_terminal_output: false,
-            is_error: true,
-        });
-        // Clear any cached session state so a subsequent attempt can
-        // start fresh once the environment is correctly configured.
-        sessionMessages.delete(sessionId);
-        return;
-    }
+    // On the final turn we omit tools so the model is forced to emit a
+    // plain text <final_answer> rather than issuing another tool call.
+    const isFinalTurn = session.turns >= MAX_TURNS;
+    const tools = isFinalTurn ? undefined : buildAvailableTools();
+    const recordUsage = async (result) => {
+        const usage = result.usage;
+        if (!usage || !subscription.id)
+            return;
+        try {
+            await subscriptionUsage_1.SubscriptionUsage.create({
+                subscriptionId: subscription.id,
+                model: result.model,
+                promptTokens: usage.prompt_tokens,
+                completionTokens: usage.completion_tokens,
+                totalTokens: usage.total_tokens,
+            });
+            await subscription_1.Subscription.increment('totalTokensUsed', {
+                by: usage.total_tokens,
+                where: { id: subscription.id },
+            });
+        }
+        catch (err) {
+            log.error('Failed to record subscription usage metrics for agent.', {
+                error: err,
+                subscriptionId: subscription.id,
+            });
+        }
+    };
     try {
-        log.debug('Calling OpenAI for agent turn', {
+        log.debug('Calling AI provider for agent turn', {
             sessionId,
+            provider: config_1.config.aiProvider,
+            model: aiModel,
             turn: session.turns,
             historyLength: session.history.length,
         });
-        const completion = await openai.chat.completions.create({
-            model: 'gpt-5.1',
-            // The OpenAI client accepts a superset of this simple
-            // message shape; we safely cast here to keep our local
-            // types minimal.
-            messages: session.history,
+        let result = await ai_client_1.aiClient.complete(aiModel, session.history, {
+            tools: tools?.length ? tools : undefined,
             temperature: 0.2,
         });
-        // Record token usage for this subscription and model, if usage
-        // data is available and we know which subscription made the call.
-        const usage = completion.usage;
-        if (usage && subscription.id) {
-            try {
-                await subscriptionUsage_1.SubscriptionUsage.create({
-                    subscriptionId: subscription.id,
-                    model: completion.model ?? 'gpt-5.1',
-                    promptTokens: usage.prompt_tokens ?? 0,
-                    completionTokens: usage.completion_tokens ?? 0,
-                    totalTokens: usage.total_tokens ?? 0,
-                });
-                await subscription_1.Subscription.increment('totalTokensUsed', {
-                    by: usage.total_tokens ?? 0,
-                    where: { id: subscription.id },
+        await recordUsage(result);
+        // Tool-call loop: execute any requested tools and feed results back
+        // until the model emits a non-tool-call response (or we hit the limit).
+        const MAX_TOOL_ITERATIONS = 10;
+        let toolIterations = 0;
+        while (result.finish_reason === 'tool_calls' && toolIterations < MAX_TOOL_ITERATIONS) {
+            toolIterations++;
+            session.history.push(result.assistantMessage);
+            const toolCalls = result.tool_calls ?? [];
+            log.info('Agent executing tool calls', {
+                sessionId,
+                turn: session.turns,
+                toolIteration: toolIterations,
+                tools: toolCalls.map((tc) => tc.name),
+            });
+            const toolResults = await Promise.all(toolCalls.map(async (tc) => {
+                const args = tc.arguments;
+                const toolResult = await executeTool(tc.name, args, log);
+                log.info('Tool call completed', {
+                    sessionId,
+                    tool: tc.name,
+                    resultLength: toolResult.length,
                 });
-            }
-            catch (err) {
-                log.error('Failed to record subscription usage metrics for agent.', {
-                    error: err,
-                    subscriptionId: subscription.id,
+                return { id: tc.id, name: tc.name, result: toolResult };
+            }));
+            for (const { id, name, result: toolResult } of toolResults) {
+                session.history.push({
+                    role: 'tool',
+                    tool_call_id: id,
+                    tool_name: name,
+                    content: toolResult,
                 });
             }
+            result = await ai_client_1.aiClient.complete(aiModel, session.history, {
+                tools: tools?.length ? tools : undefined,
+                temperature: 0.2,
+            });
+            await recordUsage(result);
+        }
+        // If the tool loop was exhausted while the model still wants more tool calls,
+        // the last result has empty content. Force one final no-tools call so the model
+        // must synthesize a text answer from everything gathered so far.
+        if (result.finish_reason === 'tool_calls') {
+            log.warn('Tool iteration limit reached with pending tool calls; forcing final text response', {
+                sessionId,
+                turn: session.turns,
+            });
+            // Do NOT push result.assistantMessage here — it contains tool_use blocks that
+            // require corresponding tool_result blocks (Anthropic API constraint). Since we
+            // are not executing those tool calls, just inject a plain user nudge so the model
+            // synthesizes a text answer from the history already accumulated.
+            session.history.push({
+                role: 'user',
+                content: 'You have reached the maximum number of tool calls. Based on all information gathered so far, please provide your best answer now.',
+            });
+            result = await ai_client_1.aiClient.complete(aiModel, session.history, {
+                tools: undefined,
+                temperature: 0.2,
+            });
+            await recordUsage(result);
         }
-        const choice = completion.choices[0];
-        const content = (choice.message.content ?? '').toString().trim();
+        const content = result.content.trim();
         if (!content) {
             log.warn('Agent LLM returned empty content; sending generic error to client.');
             const errorMessage = 'The agent returned an empty response. Please try again.';

package/backend-dist/agent/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./agentServer"), exports);

package/backend-dist/agent/web-search-provider.js

@@ -0,0 +1,135 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_TOOL_CONTENT_CHARS = exports.MAX_WEB_FETCH_BYTES = exports.WEB_SEARCH_TOOL = exports.WEB_FETCH_TOOL = void 0;
+exports.executeWebSearch = executeWebSearch;
+const axios_1 = __importDefault(require("axios"));
+const config_1 = require("../config");
+exports.WEB_FETCH_TOOL = {
+    name: 'web_fetch',
+    description: "Fetch the text content of any publicly accessible URL. Use this to retrieve documentation, error references, API guides, release notes, or any web resource that would help answer the user's question.",
+    parameters: {
+        type: 'object',
+        properties: {
+            url: {
+                type: 'string',
+                description: 'The full URL to fetch (e.g. https://example.com/page)',
+            },
+        },
+        required: ['url'],
+    },
+};
+exports.WEB_SEARCH_TOOL = {
+    name: 'web_search',
+    description: "Search the web for information about a topic. Use this to find documentation, troubleshoot errors, or research topics relevant to the user's question.",
+    parameters: {
+        type: 'object',
+        properties: {
+            query: {
+                type: 'string',
+                description: 'The search query',
+            },
+        },
+        required: ['query'],
+    },
+};
+exports.MAX_WEB_FETCH_BYTES = 500000;
+exports.MAX_TOOL_CONTENT_CHARS = 8000;
+function formatSearchResults(results) {
+    if (!results.length)
+        return 'No search results found';
+    return results
+        .slice(0, 5)
+        .map((r, i) => `${i + 1}. ${r.title}\n   URL: ${r.url}\n   ${r.snippet}`)
+        .join('\n\n');
+}
+async function searchWithSerper(query) {
+    const response = await axios_1.default.post('https://google.serper.dev/search', { q: query, num: 5 }, {
+        headers: { 'X-API-KEY': config_1.config.serperApiKey, 'Content-Type': 'application/json' },
+        timeout: 15000,
+    });
+    return (response.data?.organic ?? []).map((r) => ({
+        title: r.title ?? '(no title)',
+        url: r.link ?? '',
+        snippet: r.snippet ?? '',
+    }));
+}
+async function searchWithBrave(query) {
+    const response = await axios_1.default.get('https://api.search.brave.com/res/v1/web/search', {
+        params: { q: query, count: 5 },
+        headers: { Accept: 'application/json', 'X-Subscription-Token': config_1.config.braveSearchApiKey },
+        timeout: 15000,
+    });
+    return (response.data?.web?.results ?? []).map((r) => ({
+        title: r.title ?? '(no title)',
+        url: r.url ?? '',
+        snippet: r.description ?? '',
+    }));
+}
+async function searchWithTavily(query) {
+    const response = await axios_1.default.post('https://api.tavily.com/search', { query, max_results: 5, api_key: config_1.config.tavilyApiKey }, { headers: { 'Content-Type': 'application/json' }, timeout: 15000 });
+    return (response.data?.results ?? []).map((r) => ({
+        title: r.title ?? '(no title)',
+        url: r.url ?? '',
+        snippet: r.content ?? '',
+    }));
+}
+async function searchWithSearxng(query) {
+    const response = await axios_1.default.get(`${config_1.config.searxngUrl}/search`, {
+        params: { q: query, format: 'json', num_results: 5 },
+        timeout: 15000,
+    });
+    return (response.data?.results ?? []).map((r) => ({
+        title: r.title ?? '(no title)',
+        url: r.url ?? '',
+        snippet: r.content ?? '',
+    }));
+}
+async function searchWithDuckDuckGo(query) {
+    const response = await axios_1.default.get('https://api.duckduckgo.com/', {
+        params: { q: query, format: 'json', no_html: '1', skip_disambig: '1' },
+        timeout: 15000,
+    });
+    const results = [];
+    if (response.data?.AbstractText) {
+        results.push({
+            title: response.data.AbstractSource ?? 'Summary',
+            url: response.data.AbstractURL ?? '',
+            snippet: response.data.AbstractText,
+        });
+    }
+    for (const topic of response.data?.RelatedTopics ?? []) {
+        if (topic.Text && topic.FirstURL) {
+            results.push({
+                title: topic.Text.split(' - ')[0] ?? topic.Text,
+                url: topic.FirstURL,
+                snippet: topic.Text,
+            });
+        }
+        if (results.length >= 5)
+            break;
+    }
+    return results;
+}
+async function executeWebSearch(query, log) {
+    if (config_1.config.serperApiKey) {
+        log.info('web_search: using Serper', { query });
+        return formatSearchResults(await searchWithSerper(query));
+    }
+    if (config_1.config.braveSearchApiKey) {
+        log.info('web_search: using Brave Search', { query });
+        return formatSearchResults(await searchWithBrave(query));
+    }
+    if (config_1.config.tavilyApiKey) {
+        log.info('web_search: using Tavily', { query });
+        return formatSearchResults(await searchWithTavily(query));
+    }
+    if (config_1.config.searxngUrl) {
+        log.info('web_search: using SearXNG', { query });
+        return formatSearchResults(await searchWithSearxng(query));
+    }
+    log.info('web_search: using DuckDuckGo (free fallback)', { query });
+    return formatSearchResults(await searchWithDuckDuckGo(query));
+}