omnikey-cli 1.5.8 → 1.6.1

package/backend-dist/__tests__/ai-client.nemotron.test.js

@@ -0,0 +1,127 @@
+"use strict";
+/**
+ * Tests for the Nemotron adapter.
+ *
+ * The Nemotron adapter delegates to the `openai` SDK with a custom `baseURL`
+ * (NVIDIA NIM is OpenAI-compatible), so these tests mock the same surface as
+ * `ai-client.adapters.test.ts` and verify that:
+ *  - the OpenAI client is constructed with the correct `baseURL`,
+ *  - chat completions are routed through the Nemotron model id, and
+ *  - streaming is wired up end-to-end including usage accounting.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const mocks = vitest_1.vi.hoisted(() => ({
+    openaiCreate: vitest_1.vi.fn(),
+    openaiCtor: vitest_1.vi.fn(),
+}));
+vitest_1.vi.mock('openai', () => ({
+    default: class MockOpenAI {
+        constructor(opts) {
+            this.chat = { completions: { create: mocks.openaiCreate } };
+            this.images = { generate: vitest_1.vi.fn() };
+            mocks.openaiCtor(opts);
+        }
+    },
+}));
+vitest_1.vi.mock('@anthropic-ai/sdk', () => ({
+    default: class MockAnthropic {
+        constructor(_opts) {
+            this.messages = { create: vitest_1.vi.fn(), stream: vitest_1.vi.fn() };
+        }
+    },
+}));
+vitest_1.vi.mock('@google/genai', () => ({
+    GoogleGenAI: class MockGoogleGenAI {
+        constructor(_opts) {
+            this.models = {
+                generateContent: vitest_1.vi.fn(),
+                generateContentStream: vitest_1.vi.fn(),
+                generateImages: vitest_1.vi.fn(),
+            };
+        }
+    },
+    Content: class {
+    },
+    Tool: class {
+    },
+}));
+const ai_client_1 = require("../ai-client");
+const messages = [{ role: 'user', content: 'hello' }];
+function asAsyncIterable(chunks) {
+    return {
+        [Symbol.asyncIterator]: async function* () {
+            for (const c of chunks)
+                yield c;
+        },
+    };
+}
+(0, vitest_1.beforeEach)(() => {
+    mocks.openaiCreate.mockReset();
+    mocks.openaiCtor.mockReset();
+});
+(0, vitest_1.describe)('NemotronAdapter', () => {
+    (0, vitest_1.it)('targets the public NVIDIA NIM endpoint by default', () => {
+        new ai_client_1.AIClient('nemotron', 'nvapi-test');
+        (0, vitest_1.expect)(mocks.openaiCtor).toHaveBeenCalledTimes(1);
+        const opts = mocks.openaiCtor.mock.calls[0][0];
+        (0, vitest_1.expect)(opts).toMatchObject({
+            apiKey: 'nvapi-test',
+            baseURL: 'https://integrate.api.nvidia.com/v1',
+        });
+    });
+    (0, vitest_1.it)('honours a custom NEMOTRON_BASE_URL for self-hosted NIM', () => {
+        new ai_client_1.AIClient('nemotron', 'nvapi-test', {
+            nemotronBaseURL: 'http://my-nim:8000/v1',
+        });
+        const opts = mocks.openaiCtor.mock.calls[0][0];
+        (0, vitest_1.expect)(opts.baseURL).toBe('http://my-nim:8000/v1');
+    });
+    (0, vitest_1.it)('complete: sends the Nemotron model id and passes temperature', async () => {
+        mocks.openaiCreate.mockResolvedValueOnce({
+            choices: [{ message: { content: 'hi', tool_calls: undefined }, finish_reason: 'stop' }],
+            usage: { prompt_tokens: 4, completion_tokens: 2, total_tokens: 6 },
+        });
+        const client = new ai_client_1.AIClient('nemotron', 'nvapi-test');
+        const result = await client.complete('nvidia/nemotron-3-super-120b-a12b', messages, {
+            temperature: 0.42,
+        });
+        const body = mocks.openaiCreate.mock.calls[0][0];
+        (0, vitest_1.expect)(body).toMatchObject({
+            model: 'nvidia/nemotron-3-super-120b-a12b',
+            temperature: 0.42,
+        });
+        (0, vitest_1.expect)(result.content).toBe('hi');
+        (0, vitest_1.expect)(result.usage?.total_tokens).toBe(6);
+    });
+    (0, vitest_1.it)('streamComplete: forwards deltas and captures usage', async () => {
+        mocks.openaiCreate.mockResolvedValueOnce(asAsyncIterable([
+            { choices: [{ delta: { content: 'he' } }] },
+            { choices: [{ delta: { content: 'llo' } }] },
+            {
+                choices: [{ delta: {} }],
+                usage: { prompt_tokens: 3, completion_tokens: 2, total_tokens: 5 },
+            },
+        ]));
+        const client = new ai_client_1.AIClient('nemotron', 'nvapi-test');
+        const received = [];
+        const { usage } = await client.streamComplete('nvidia/nemotron-3-nano-30b-a3b', messages, {}, (d) => received.push(d));
+        (0, vitest_1.expect)(received.join('')).toBe('hello');
+        (0, vitest_1.expect)(usage).toEqual({ prompt_tokens: 3, completion_tokens: 2, total_tokens: 5 });
+        const body = mocks.openaiCreate.mock.calls[0][0];
+        (0, vitest_1.expect)(body).toMatchObject({ stream: true });
+    });
+    (0, vitest_1.it)('exposes fast and smart defaults via getDefaultModel', () => {
+        (0, vitest_1.expect)((0, ai_client_1.getDefaultModel)('nemotron', 'fast')).toBe('nvidia/nemotron-3-nano-30b-a3b');
+        (0, vitest_1.expect)((0, ai_client_1.getDefaultModel)('nemotron', 'smart')).toBe('nvidia/nemotron-3-ultra-550b-a55b');
+    });
+    (0, vitest_1.it)('reports image generation as unsupported', () => {
+        const client = new ai_client_1.AIClient('nemotron', 'nvapi-test');
+        (0, vitest_1.expect)(client.supportsImageGeneration()).toBe(false);
+        (0, vitest_1.expect)((0, ai_client_1.providerSupportsImageGeneration)('nemotron')).toBe(false);
+    });
+    (0, vitest_1.it)('generateImage rejects with an unsupported-provider error', async () => {
+        const client = new ai_client_1.AIClient('nemotron', 'nvapi-test');
+        await (0, vitest_1.expect)(client.generateImage({ prompt: 'a test image' })).rejects.toThrow(/not supported for provider "nemotron"/);
+    });
+});

package/backend-dist/agent/agentPrompts.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getAgentPrompt = getAgentPrompt;
+const ai_client_1 = require("../ai-client");
 const config_1 = require("../config");
 // MCP server names and descriptions are user-controlled and embedded into the agent
 // system prompt. Sanitize them to mitigate prompt-injection: strip control characters
@@ -28,7 +29,7 @@ function getAgentPrompt(platform, hasTaskInstructions, installedMcps = []) {
     return `
 You are an AI agent with the following capabilities:
 - **Shell execution** (\`<shell_script>\` XML tag) — runs commands on the user's machine; output returns as \`TERMINAL OUTPUT:\`.
-- **Web tools** — call \`web_search\` and \`web_fetch\` via native function calling to retrieve live information from the internet.${config_1.config.aiProvider !== 'anthropic' ? '\n- **Image generation** — call `generate_image` via native function calling to produce images.' : ''}${config_1.config.browserDebugPort !== undefined ? '\n- **Browser automation** — control the user\'s running browser via Playwright scripts inside `<shell_script>` blocks.' : ''}
+- **Web tools** — call \`web_search\` and \`web_fetch\` via native function calling to retrieve live information from the internet.${(0, ai_client_1.providerSupportsImageGeneration)(config_1.config.aiProvider) ? '\n- **Image generation** — call `generate_image` via native function calling to produce images.' : ''}${config_1.config.browserDebugPort !== undefined ? "\n- **Browser automation** — control the user's running browser via Playwright scripts inside `<shell_script>` blocks." : ''}
 ${installedMcps.length > 0 ? '- **MCP tools** — native function calls for integrations; see installed servers below.' : ''}
 
 Use these capabilities to take real action. Default to doing rather than asking.
@@ -78,7 +79,7 @@ ${config_1.config.browserDebugPort !== undefined
 - Create the directory first if needed: \`mkdir -p ~/.omnikey/garbage\`.
 - Always tell the user the exact path where the configuration was saved in your \`<final_answer>\`.
 
-${config_1.config.aiProvider === 'anthropic'
+${!(0, ai_client_1.providerSupportsImageGeneration)(config_1.config.aiProvider)
         ? `**Image generation:**
 - No image-generation tool is available in this environment. Do **not** call any tool whose name suggests image, picture, render, draw, or visual asset creation (e.g., \`generate_image\`, \`image_generate\`, \`create_image\`). If the user asks for an image, respond in \`<final_answer>\` explaining that image generation is not supported with the current provider.
 `
@@ -122,7 +123,7 @@ ${installedMcps
 
 **Response format — every response must be exactly one of:**
 1. \`<shell_script>...</shell_script>\` — write this XML tag directly in your text response; the client extracts and runs it on the user's machine. Never generate a script as an internal tool call or function call. Always use the \`<shell_script>\` tag for scripts — do NOT wrap them in any other tags or envelopes. The script must be the entire content of your response, with no extra text before or after.
-2. ${config_1.config.aiProvider === 'anthropic' ? 'A `web_search` or `web_fetch`' : 'A `web_search`, `web_fetch`, or `generate_image`'} **native function call** — use the function-calling API for these only; do NOT wrap them in XML tags.${installedMcps.length > 0 ? ' Same for MCP tools (`mcp_<server>__<tool>`).' : ''}
+2. ${(0, ai_client_1.providerSupportsImageGeneration)(config_1.config.aiProvider) ? 'A `web_search`, `web_fetch`, or `generate_image`' : 'A `web_search` or `web_fetch`'} **native function call** — use the function-calling API for these only; do NOT wrap them in XML tags.${installedMcps.length > 0 ? ' Same for MCP tools (`mcp_<server>__<tool>`).' : ''}
 3. \`<final_answer>...</final_answer>\` — your conclusion once you have enough information.
 
 **Critical rule — zero tolerance for text outside tags or extra wrappers:**

package/backend-dist/agent/utils.js

@@ -16,17 +16,18 @@ const imageTool_1 = require("./imageTool");
  * `web_search` is always included because DuckDuckGo is used as a free
  * fallback when no third-party search key is configured.
  *
- * `generate_image` is omitted for the Anthropic provider because the
- * underlying `aiClient.generateImage()` only supports OpenAI and Gemini —
- * registering an unsupported tool would invite the model to call it and
- * fail at execution time. The system prompt for Anthropic is built without
+ * `generate_image` is omitted for providers without image-generation
+ * support (currently Anthropic and Nemotron) because the underlying
+ * `aiClient.generateImage()` only supports OpenAI and Gemini — registering
+ * an unsupported tool would invite the model to call it and fail at
+ * execution time. The system prompt for those providers is built without
  * the image-tool section to match this tool set.
  *
  * @returns An array of `AITool` definitions ready to pass to the AI client.
  */
 function buildAvailableTools(extraTools = []) {
     const baseTools = [web_search_provider_1.WEB_FETCH_TOOL, web_search_provider_1.WEB_SEARCH_TOOL];
-    if (config_1.config.aiProvider !== 'anthropic') {
+    if ((0, ai_client_1.providerSupportsImageGeneration)(config_1.config.aiProvider)) {
         baseTools.push(imageTool_1.IMAGE_GENERATE_TOOL);
     }
     return [...baseTools, ...extraTools];

package/backend-dist/ai-client.js

@@ -9,6 +9,7 @@ exports.modelSupportsTemperature = modelSupportsTemperature;
 exports.getMaxMessageContentLength = getMaxMessageContentLength;
 exports.getMaxHistoryLength = getMaxHistoryLength;
 exports.getContextWindowSize = getContextWindowSize;
+exports.providerSupportsImageGeneration = providerSupportsImageGeneration;
 const openai_1 = __importDefault(require("openai"));
 const sdk_1 = __importDefault(require("@anthropic-ai/sdk"));
 const genai_1 = require("@google/genai");
@@ -27,6 +28,17 @@ const DEFAULT_MODELS = {
     openai: { fast: 'gpt-4o-mini', smart: 'gpt-5.5' },
     gemini: { fast: 'gemini-2.5-flash', smart: 'gemini-2.5-pro' },
     anthropic: { fast: 'claude-haiku-4-5-20251001', smart: 'claude-opus-4-7' },
+    // NVIDIA Nemotron is exposed through the OpenAI-compatible NIM endpoint at
+    // https://integrate.api.nvidia.com/v1. The "fast" tier maps to Nemotron Nano
+    // for high-throughput sub-agent workloads; the "smart" tier maps to Nemotron
+    // Ultra — the frontier-level model in the family — for complex multi-agent
+    // reasoning, planning, code generation, and deep research. Drop down to
+    // Nemotron Super (`nvidia/nemotron-3-super-120b-a12b`) here if single-GPU
+    // data-center deployment is required.
+    nemotron: {
+        fast: 'nvidia/nemotron-3-nano-30b-a3b',
+        smart: 'nvidia/nemotron-3-ultra-550b-a55b',
+    },
 };
 function getDefaultModel(provider, tier) {
     return DEFAULT_MODELS[provider][tier];
@@ -78,6 +90,9 @@ const MAX_MESSAGE_CONTENT_LENGTH_BY_PROVIDER = {
     anthropic: 10000000,
     openai: 800000,
     gemini: 3500000,
+    // Nemotron 3 ships a 1M-token context window via NIM; mirror Gemini's
+    // per-string cap (no documented hard limit, bounded by the context window).
+    nemotron: 3500000,
 };
 /**
  * Maximum total character length across all messages in the conversation
@@ -95,6 +110,8 @@ const MAX_HISTORY_LENGTH_BY_PROVIDER = {
     anthropic: 1800000,
     openai: 460000,
     gemini: 1800000,
+    // 1M-token context with 100K reserved for output → 900K target × 2 chars
+    nemotron: 1800000,
 };
 /**
  * Hard token limit of the context window for each provider/model tier.
@@ -104,6 +121,8 @@ const CONTEXT_WINDOW_BY_PROVIDER = {
     anthropic: 1000000,
     openai: 272000,
     gemini: 1000000,
+    // Nemotron 3 hybrid Mamba-Transformer MoE family ships with 1M-token context.
+    nemotron: 1000000,
 };
 function getMaxMessageContentLength(provider) {
     return MAX_MESSAGE_CONTENT_LENGTH_BY_PROVIDER[provider];
@@ -165,9 +184,7 @@ class OpenAIAdapter {
         const stream = await this.client.chat.completions.create({
             model,
             messages: oaiMessages,
-            ...(modelSupportsTemperature(model)
-                ? { temperature: options.temperature ?? 0.3 }
-                : {}),
+            ...(modelSupportsTemperature(model) ? { temperature: options.temperature ?? 0.3 } : {}),
             stream: true,
             stream_options: { include_usage: true },
         });
@@ -277,9 +294,7 @@ class AnthropicAdapter {
             max_tokens: options.maxTokens ?? 8192,
             ...(system ? { system } : {}),
             messages: anthropicMessages,
-            ...(modelSupportsTemperature(model)
-                ? { temperature: options.temperature ?? 0.3 }
-                : {}),
+            ...(modelSupportsTemperature(model) ? { temperature: options.temperature ?? 0.3 } : {}),
         });
         for await (const event of stream) {
             if (event.type === 'content_block_delta' &&
@@ -298,6 +313,96 @@ class AnthropicAdapter {
     }
 }
 // ---------------------------------------------------------------------------
+// Nemotron adapter (NVIDIA NIM — OpenAI-compatible REST API)
+// ---------------------------------------------------------------------------
+/**
+ * NVIDIA Nemotron models are served behind an OpenAI-compatible endpoint at
+ * `https://integrate.api.nvidia.com/v1` (the NVIDIA NIM gateway, also used by
+ * self-hosted NIM microservices). Because the wire protocol matches OpenAI's
+ * Chat Completions API, we reuse the `openai` SDK by constructing a client
+ * with a custom `baseURL`. This keeps the message/tool-call conversion logic
+ * identical to OpenAI and avoids pulling in another transport library.
+ *
+ * Notes on Nemotron-specific quirks:
+ *  - The endpoint accepts `temperature`, `top_p`, `max_tokens`, and `tools`
+ *    in the standard OpenAI shape, so no schema translation is needed.
+ *  - Image generation is not exposed for the text-only Nemotron models, so
+ *    `generateImage` is intentionally not implemented (the unified `AIClient`
+ *    surfaces a clear error for unsupported providers).
+ *  - Self-hosted NIM deployments can be targeted by setting the
+ *    `NEMOTRON_BASE_URL` env var (handled in `config.ts`). The API key can be
+ *    any non-empty string for self-hosted NIM.
+ */
+class NemotronAdapter {
+    constructor(apiKey, baseURL) {
+        this.client = new openai_1.default({ apiKey, baseURL });
+    }
+    async complete(model, messages, options) {
+        const oaiMessages = toOpenAIMessages(messages);
+        const tools = options.tools?.length ? toOpenAITools(options.tools) : undefined;
+        const completion = await this.client.chat.completions.create({
+            model,
+            messages: oaiMessages,
+            tools: tools?.length ? tools : undefined,
+            ...(modelSupportsTemperature(model) ? { temperature: options.temperature ?? 0.2 } : {}),
+            max_tokens: options.maxTokens,
+        });
+        const choice = completion.choices[0];
+        const msg = choice.message;
+        const content = (msg.content ?? '').toString().trim();
+        const tool_calls = msg.tool_calls
+            ?.filter((tc) => tc.type === 'function' && 'function' in tc)
+            .map((tc) => ({
+            id: tc.id,
+            name: tc.function.name,
+            arguments: JSON.parse(tc.function.arguments || '{}'),
+        }));
+        const finishReason = choice.finish_reason === 'tool_calls'
+            ? 'tool_calls'
+            : choice.finish_reason === 'length'
+                ? 'length'
+                : 'stop';
+        const usage = completion.usage
+            ? {
+                prompt_tokens: completion.usage.prompt_tokens,
+                completion_tokens: completion.usage.completion_tokens,
+                total_tokens: completion.usage.total_tokens,
+            }
+            : undefined;
+        const assistantMessage = {
+            role: 'assistant',
+            content,
+            ...(tool_calls?.length ? { tool_calls } : {}),
+        };
+        return { content, finish_reason: finishReason, tool_calls, usage, model, assistantMessage };
+    }
+    async streamComplete(model, messages, options, onDelta) {
+        const oaiMessages = toOpenAIMessages(messages);
+        const stream = await this.client.chat.completions.create({
+            model,
+            messages: oaiMessages,
+            ...(modelSupportsTemperature(model) ? { temperature: options.temperature ?? 0.3 } : {}),
+            stream: true,
+            stream_options: { include_usage: true },
+        });
+        let usage;
+        for await (const part of stream) {
+            const delta = part.choices?.[0]?.delta?.content ?? '';
+            if (delta) {
+                onDelta(delta);
+            }
+            if (part.usage) {
+                usage = {
+                    prompt_tokens: part.usage.prompt_tokens ?? 0,
+                    completion_tokens: part.usage.completion_tokens ?? 0,
+                    total_tokens: part.usage.total_tokens ?? 0,
+                };
+            }
+        }
+        return { usage, model };
+    }
+}
+// ---------------------------------------------------------------------------
 // Gemini adapter
 // ---------------------------------------------------------------------------
 class GeminiAdapter {
@@ -313,9 +418,7 @@ class GeminiAdapter {
             config: {
                 ...(systemInstruction ? { systemInstruction } : {}),
                 ...(tools?.length ? { tools } : {}),
-                ...(modelSupportsTemperature(model)
-                    ? { temperature: options.temperature ?? 0.2 }
-                    : {}),
+                ...(modelSupportsTemperature(model) ? { temperature: options.temperature ?? 0.2 } : {}),
             },
         });
         const candidate = response.candidates?.[0];
@@ -366,9 +469,7 @@ class GeminiAdapter {
             contents,
             config: {
                 ...(systemInstruction ? { systemInstruction } : {}),
-                ...(modelSupportsTemperature(model)
-                    ? { temperature: options.temperature ?? 0.3 }
-                    : {}),
+                ...(modelSupportsTemperature(model) ? { temperature: options.temperature ?? 0.3 } : {}),
             },
         });
         let usage;
@@ -427,7 +528,7 @@ class GeminiAdapter {
 // Main AIClient
 // ---------------------------------------------------------------------------
 class AIClient {
-    constructor(provider, apiKey) {
+    constructor(provider, apiKey, options = {}) {
         this.provider = provider;
         if (provider === 'openai') {
             this.openai = new OpenAIAdapter(apiKey);
@@ -438,6 +539,12 @@ class AIClient {
         else if (provider === 'gemini') {
             this.gemini = new GeminiAdapter(apiKey);
         }
+        else if (provider === 'nemotron') {
+            // Default to the public NVIDIA NIM gateway. Self-hosted NIM deployments
+            // can override this via `NEMOTRON_BASE_URL` (see config.ts).
+            const baseURL = options.nemotronBaseURL || 'https://integrate.api.nvidia.com/v1';
+            this.nemotron = new NemotronAdapter(apiKey, baseURL);
+        }
     }
     getProvider() {
         return this.provider;
@@ -452,6 +559,9 @@ class AIClient {
         if (this.provider === 'gemini' && this.gemini) {
             return this.gemini.complete(model, messages, options);
         }
+        if (this.provider === 'nemotron' && this.nemotron) {
+            return this.nemotron.complete(model, messages, options);
+        }
         throw new Error(`AI provider "${this.provider}" is not configured.`);
     }
     async streamComplete(model, messages, options = {}, onDelta) {
@@ -464,13 +574,27 @@ class AIClient {
         if (this.provider === 'gemini' && this.gemini) {
             return this.gemini.streamComplete(model, messages, options, onDelta);
         }
+        if (this.provider === 'nemotron' && this.nemotron) {
+            return this.nemotron.streamComplete(model, messages, options, onDelta);
+        }
         throw new Error(`AI provider "${this.provider}" is not configured.`);
     }
+    /**
+     * Reports whether the configured provider can generate images.
+     *
+     * Centralising this check means agent tool registration and system-prompt
+     * builders no longer need to keep a hand-maintained allow/deny list of
+     * providers — they ask the client directly. Currently OpenAI and Gemini
+     * support image generation; Anthropic and Nemotron (text-only) do not.
+     */
+    supportsImageGeneration() {
+        return this.provider === 'openai' || this.provider === 'gemini';
+    }
     /**
      * Generates an image with the currently configured provider.
      *
-     * Supported providers are OpenAI and Gemini. Anthropic does not currently
-     * expose a text-to-image generation endpoint in this project.
+     * Supported providers are OpenAI and Gemini. Anthropic and Nemotron do not
+     * currently expose a text-to-image generation endpoint in this project.
      *
      * @param options - Unified image-generation options.
      * @returns Provider-normalized image payload.
@@ -486,6 +610,15 @@ class AIClient {
     }
 }
 exports.AIClient = AIClient;
+/**
+ * Returns whether the given provider supports image generation.
+ *
+ * Module-level helper for callers that only have the provider id at hand
+ * (e.g. system-prompt builders) and don't want to construct an `AIClient`.
+ */
+function providerSupportsImageGeneration(provider) {
+    return provider === 'openai' || provider === 'gemini';
+}
 // ---------------------------------------------------------------------------
 // Message format converters — OpenAI
 // ---------------------------------------------------------------------------
@@ -646,4 +779,6 @@ function toGeminiTools(tools) {
 // ---------------------------------------------------------------------------
 // Shared singleton — import this instead of constructing a new AIClient
 // ---------------------------------------------------------------------------
-exports.aiClient = new AIClient(config_1.config.aiProvider, config_1.config.aiApiKey);
+exports.aiClient = new AIClient(config_1.config.aiProvider, config_1.config.aiApiKey, {
+    nemotronBaseURL: config_1.config.nemotronBaseUrl,
+});