omnikey-cli 1.2.0 → 1.4.0

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

@@ -0,0 +1,247 @@
+"use strict";
+/**
+ * Per-provider adapter tests for temperature handling.
+ *
+ * The three SDKs (`openai`, `@anthropic-ai/sdk`, `@google/genai`) are mocked
+ * at the module boundary using `vi.mock`. Mock spies are declared inside a
+ * `vi.hoisted()` block so they are available when `vi.mock` factories run
+ * (vi.mock is hoisted to the top of the file).
+ *
+ * These tests never contact any real API.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const mocks = vitest_1.vi.hoisted(() => ({
+    openaiCreate: vitest_1.vi.fn(),
+    anthropicCreate: vitest_1.vi.fn(),
+    anthropicStream: vitest_1.vi.fn(),
+    geminiGenerate: vitest_1.vi.fn(),
+    geminiGenerateStream: 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() };
+        }
+    },
+}));
+vitest_1.vi.mock('@anthropic-ai/sdk', () => ({
+    default: class MockAnthropic {
+        constructor(_opts) {
+            this.messages = { create: mocks.anthropicCreate, stream: mocks.anthropicStream };
+        }
+    },
+}));
+vitest_1.vi.mock('@google/genai', () => ({
+    GoogleGenAI: class MockGoogleGenAI {
+        constructor(_opts) {
+            this.models = {
+                generateContent: mocks.geminiGenerate,
+                generateContentStream: mocks.geminiGenerateStream,
+                generateImages: vitest_1.vi.fn(),
+            };
+        }
+    },
+    // The adapter file imports these as types-only but they still need to resolve.
+    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.anthropicCreate.mockReset();
+    mocks.anthropicStream.mockReset();
+    mocks.geminiGenerate.mockReset();
+    mocks.geminiGenerateStream.mockReset();
+});
+// ---------------------------------------------------------------------------
+// OpenAI
+// ---------------------------------------------------------------------------
+(0, vitest_1.describe)('OpenAIAdapter temperature handling', () => {
+    function mockCompleteResponse() {
+        mocks.openaiCreate.mockResolvedValueOnce({
+            choices: [{ message: { content: 'ok', tool_calls: undefined }, finish_reason: 'stop' }],
+            usage: { prompt_tokens: 1, completion_tokens: 1, total_tokens: 2 },
+        });
+    }
+    function mockStreamResponse() {
+        mocks.openaiCreate.mockResolvedValueOnce(asAsyncIterable([
+            { choices: [{ delta: { content: 'ok' } }] },
+            {
+                choices: [{ delta: {} }],
+                usage: { prompt_tokens: 1, completion_tokens: 1, total_tokens: 2 },
+            },
+        ]));
+    }
+    (0, vitest_1.it)('complete: passes temperature for gpt-4o-mini', async () => {
+        mockCompleteResponse();
+        const client = new ai_client_1.AIClient('openai', 'sk-test');
+        await client.complete('gpt-4o-mini', messages, { temperature: 0.42 });
+        const body = mocks.openaiCreate.mock.calls[0][0];
+        (0, vitest_1.expect)(body).toHaveProperty('temperature', 0.42);
+    });
+    (0, vitest_1.it)('complete: omits temperature for gpt-5.5 even if caller supplies one', async () => {
+        mockCompleteResponse();
+        const client = new ai_client_1.AIClient('openai', 'sk-test');
+        await client.complete('gpt-5.5', messages, { temperature: 0.42 });
+        const body = mocks.openaiCreate.mock.calls[0][0];
+        (0, vitest_1.expect)(body).not.toHaveProperty('temperature');
+    });
+    vitest_1.it.each(['gpt-5', 'gpt-5-mini', 'gpt-5.1', 'o1', 'o3-mini', 'o4-mini'])('complete: omits temperature for unsupported model %s', async (model) => {
+        mockCompleteResponse();
+        const client = new ai_client_1.AIClient('openai', 'sk-test');
+        await client.complete(model, messages, { temperature: 0.7 });
+        const body = mocks.openaiCreate.mock.calls[0][0];
+        (0, vitest_1.expect)(body).not.toHaveProperty('temperature');
+    });
+    (0, vitest_1.it)('streamComplete: passes temperature for gpt-4o-mini', async () => {
+        mockStreamResponse();
+        const client = new ai_client_1.AIClient('openai', 'sk-test');
+        await client.streamComplete('gpt-4o-mini', messages, { temperature: 0.31 }, () => { });
+        const body = mocks.openaiCreate.mock.calls[0][0];
+        (0, vitest_1.expect)(body).toHaveProperty('temperature', 0.31);
+        (0, vitest_1.expect)(body).toHaveProperty('stream', true);
+    });
+    (0, vitest_1.it)('streamComplete: omits temperature for gpt-5.5', async () => {
+        mockStreamResponse();
+        const client = new ai_client_1.AIClient('openai', 'sk-test');
+        await client.streamComplete('gpt-5.5', messages, { temperature: 0.31 }, () => { });
+        const body = mocks.openaiCreate.mock.calls[0][0];
+        (0, vitest_1.expect)(body).not.toHaveProperty('temperature');
+        (0, vitest_1.expect)(body).toHaveProperty('stream', true);
+    });
+    (0, vitest_1.it)('streamComplete: omits temperature even when caller passes empty options for gpt-5.5', async () => {
+        mockStreamResponse();
+        const client = new ai_client_1.AIClient('openai', 'sk-test');
+        await client.streamComplete('gpt-5.5', messages, {}, () => { });
+        const body = mocks.openaiCreate.mock.calls[0][0];
+        (0, vitest_1.expect)(body).not.toHaveProperty('temperature');
+    });
+    (0, vitest_1.it)('streamComplete: uses 0.3 default for supported model when caller omits temperature', async () => {
+        mockStreamResponse();
+        const client = new ai_client_1.AIClient('openai', 'sk-test');
+        await client.streamComplete('gpt-4o-mini', messages, {}, () => { });
+        const body = mocks.openaiCreate.mock.calls[0][0];
+        (0, vitest_1.expect)(body).toHaveProperty('temperature', 0.3);
+    });
+});
+// ---------------------------------------------------------------------------
+// Anthropic
+// ---------------------------------------------------------------------------
+(0, vitest_1.describe)('AnthropicAdapter temperature handling', () => {
+    function mockCompleteResponse() {
+        mocks.anthropicCreate.mockResolvedValueOnce({
+            content: [{ type: 'text', text: 'ok' }],
+            stop_reason: 'end_turn',
+            usage: { input_tokens: 1, output_tokens: 1 },
+        });
+    }
+    function mockStreamResponse() {
+        const finalMessage = vitest_1.vi.fn().mockResolvedValue({
+            usage: { input_tokens: 1, output_tokens: 1 },
+        });
+        const stream = asAsyncIterable([
+            { type: 'content_block_delta', delta: { type: 'text_delta', text: 'ok' } },
+        ]);
+        stream.finalMessage = finalMessage;
+        mocks.anthropicStream.mockReturnValueOnce(stream);
+    }
+    (0, vitest_1.it)('complete: passes temperature for claude-sonnet-4-5', async () => {
+        mockCompleteResponse();
+        const client = new ai_client_1.AIClient('anthropic', 'sk-anthropic-test');
+        await client.complete('claude-sonnet-4-5', messages, { temperature: 0.42 });
+        const body = mocks.anthropicCreate.mock.calls[0][0];
+        (0, vitest_1.expect)(body).toHaveProperty('temperature', 0.42);
+    });
+    vitest_1.it.each([
+        'claude-haiku-4-5-20251001',
+        'claude-opus-4-5',
+        'claude-opus-4-5-20251101',
+        'claude-opus-4-6',
+    ])('complete: passes temperature for supported model %s', async (model) => {
+        mockCompleteResponse();
+        const client = new ai_client_1.AIClient('anthropic', 'sk-anthropic-test');
+        await client.complete(model, messages, { temperature: 0.5 });
+        const body = mocks.anthropicCreate.mock.calls[0][0];
+        (0, vitest_1.expect)(body).toHaveProperty('temperature', 0.5);
+    });
+    vitest_1.it.each(['claude-opus-4-7', 'claude-opus-4-7-20260101'])('complete: omits temperature for unsupported model %s', async (model) => {
+        mockCompleteResponse();
+        const client = new ai_client_1.AIClient('anthropic', 'sk-anthropic-test');
+        await client.complete(model, messages, { temperature: 0.5 });
+        const body = mocks.anthropicCreate.mock.calls[0][0];
+        (0, vitest_1.expect)(body).not.toHaveProperty('temperature');
+    });
+    (0, vitest_1.it)('streamComplete: passes temperature for claude-sonnet-4-5', async () => {
+        mockStreamResponse();
+        const client = new ai_client_1.AIClient('anthropic', 'sk-anthropic-test');
+        await client.streamComplete('claude-sonnet-4-5', messages, { temperature: 0.6 }, () => { });
+        const body = mocks.anthropicStream.mock.calls[0][0];
+        (0, vitest_1.expect)(body).toHaveProperty('temperature', 0.6);
+    });
+    (0, vitest_1.it)('streamComplete: omits temperature for claude-opus-4-7', async () => {
+        mockStreamResponse();
+        const client = new ai_client_1.AIClient('anthropic', 'sk-anthropic-test');
+        await client.streamComplete('claude-opus-4-7', messages, { temperature: 0.6 }, () => { });
+        const body = mocks.anthropicStream.mock.calls[0][0];
+        (0, vitest_1.expect)(body).not.toHaveProperty('temperature');
+    });
+});
+// ---------------------------------------------------------------------------
+// Gemini
+// ---------------------------------------------------------------------------
+(0, vitest_1.describe)('GeminiAdapter temperature handling', () => {
+    function mockCompleteResponse() {
+        mocks.geminiGenerate.mockResolvedValueOnce({
+            candidates: [
+                {
+                    content: { parts: [{ text: 'ok' }] },
+                    finishReason: 'STOP',
+                },
+            ],
+            usageMetadata: { promptTokenCount: 1, candidatesTokenCount: 1, totalTokenCount: 2 },
+        });
+    }
+    function mockStreamResponse() {
+        mocks.geminiGenerateStream.mockResolvedValueOnce(asAsyncIterable([
+            { text: 'ok' },
+            {
+                text: '',
+                usageMetadata: { promptTokenCount: 1, candidatesTokenCount: 1, totalTokenCount: 2 },
+            },
+        ]));
+    }
+    vitest_1.it.each(['gemini-2.5-flash', 'gemini-2.5-pro', 'gemini-3-pro'])('complete: passes temperature for %s (all Gemini models accept it)', async (model) => {
+        mockCompleteResponse();
+        const client = new ai_client_1.AIClient('gemini', 'gemini-test-key');
+        await client.complete(model, messages, { temperature: 0.42 });
+        const body = mocks.geminiGenerate.mock.calls[0][0];
+        (0, vitest_1.expect)(body.config).toHaveProperty('temperature', 0.42);
+    });
+    (0, vitest_1.it)('streamComplete: passes temperature for gemini-2.5-pro', async () => {
+        mockStreamResponse();
+        const client = new ai_client_1.AIClient('gemini', 'gemini-test-key');
+        await client.streamComplete('gemini-2.5-pro', messages, { temperature: 0.31 }, () => { });
+        const body = mocks.geminiGenerateStream.mock.calls[0][0];
+        (0, vitest_1.expect)(body.config).toHaveProperty('temperature', 0.31);
+    });
+    (0, vitest_1.it)('streamComplete: applies default 0.3 when caller omits temperature', async () => {
+        mockStreamResponse();
+        const client = new ai_client_1.AIClient('gemini', 'gemini-test-key');
+        await client.streamComplete('gemini-2.5-pro', messages, {}, () => { });
+        const body = mocks.geminiGenerateStream.mock.calls[0][0];
+        (0, vitest_1.expect)(body.config).toHaveProperty('temperature', 0.3);
+    });
+});

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

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const ai_client_1 = require("../ai-client");
+(0, vitest_1.describe)('modelSupportsTemperature', () => {
+    (0, vitest_1.describe)('OpenAI', () => {
+        vitest_1.it.each([
+            ['gpt-4o-mini', true],
+            ['gpt-4o', true],
+            ['gpt-4-turbo', true],
+            ['gpt-3.5-turbo', true],
+        ])('allows temperature for %s', (model, expected) => {
+            (0, vitest_1.expect)((0, ai_client_1.modelSupportsTemperature)(model)).toBe(expected);
+        });
+        vitest_1.it.each([
+            ['gpt-5', false],
+            ['gpt-5-mini', false],
+            ['gpt-5.1', false],
+            ['gpt-5.5', false],
+            ['GPT-5.5', false], // case-insensitive
+        ])('rejects temperature for GPT-5 family member %s', (model, expected) => {
+            (0, vitest_1.expect)((0, ai_client_1.modelSupportsTemperature)(model)).toBe(expected);
+        });
+        vitest_1.it.each([
+            ['o1', false],
+            ['o1-preview', false],
+            ['o3', false],
+            ['o3-mini', false],
+            ['o4-mini', false],
+        ])('rejects temperature for reasoning model %s', (model, expected) => {
+            (0, vitest_1.expect)((0, ai_client_1.modelSupportsTemperature)(model)).toBe(expected);
+        });
+    });
+    (0, vitest_1.describe)('Gemini', () => {
+        vitest_1.it.each([
+            ['gemini-2.5-flash', true],
+            ['gemini-2.5-pro', true],
+            ['gemini-3-pro', true],
+            ['gemini-3.5-flash', true],
+        ])('allows temperature for %s', (model, expected) => {
+            (0, vitest_1.expect)((0, ai_client_1.modelSupportsTemperature)(model)).toBe(expected);
+        });
+    });
+    (0, vitest_1.describe)('Anthropic', () => {
+        vitest_1.it.each([
+            ['claude-haiku-4-5', true],
+            ['claude-haiku-4-5-20251001', true],
+            ['claude-sonnet-4-5', true],
+            ['claude-sonnet-4-5-20250929', true],
+            ['claude-opus-4-5', true],
+            ['claude-opus-4-5-20251101', true],
+            ['claude-opus-4-6', true],
+        ])('allows temperature for %s', (model, expected) => {
+            (0, vitest_1.expect)((0, ai_client_1.modelSupportsTemperature)(model)).toBe(expected);
+        });
+        vitest_1.it.each([
+            ['claude-opus-4-7', false],
+            ['claude-opus-4-7-20260101', false],
+            ['CLAUDE-OPUS-4-7', false], // case-insensitive
+        ])('rejects temperature for opus-4-7 variant %s', (model, expected) => {
+            (0, vitest_1.expect)((0, ai_client_1.modelSupportsTemperature)(model)).toBe(expected);
+        });
+    });
+});
+(0, vitest_1.describe)('getDefaultModel', () => {
+    (0, vitest_1.it)('returns the configured fast and smart tiers for each provider', () => {
+        // Don't pin exact model strings — they will be upgraded over time. Just
+        // assert that each provider returns a non-empty string for both tiers
+        // and that fast/smart differ (smart is meant to be a bigger model).
+        for (const provider of ['openai', 'gemini', 'anthropic']) {
+            const fast = (0, ai_client_1.getDefaultModel)(provider, 'fast');
+            const smart = (0, ai_client_1.getDefaultModel)(provider, 'smart');
+            (0, vitest_1.expect)(fast).toBeTruthy();
+            (0, vitest_1.expect)(smart).toBeTruthy();
+            (0, vitest_1.expect)(fast).not.toEqual(smart);
+        }
+    });
+    (0, vitest_1.it)('returns smart-tier models that are correctly classified by modelSupportsTemperature', () => {
+        // Regression guard: whenever a smart model is upgraded, the helper must
+        // continue to return the correct policy for it. This test is the single
+        // place that ties the two together so an accidental mismatch breaks the
+        // suite immediately.
+        const expectations = {
+            // OpenAI smart tier is in the GPT-5 family → no temperature.
+            openai: false,
+            // Gemini smart tier accepts temperature.
+            gemini: true,
+            // Anthropic smart tier is claude-opus-4-7 → no temperature.
+            anthropic: false,
+        };
+        for (const provider of Object.keys(expectations)) {
+            const expected = expectations[provider];
+            if (expected === null)
+                continue;
+            const smartModel = (0, ai_client_1.getDefaultModel)(provider, 'smart');
+            (0, vitest_1.expect)((0, ai_client_1.modelSupportsTemperature)(smartModel), `${provider} smart model "${smartModel}" should report temperature-support=${expected}`).toBe(expected);
+        }
+    });
+});

package/backend-dist/__tests__/featureRoutes.runEnhancementModel.test.js

@@ -0,0 +1,79 @@
+"use strict";
+/**
+ * Tests for the temperature-handling change in `runEnhancementModel`.
+ *
+ * - 'enhance' → { temperature: 0.3 }
+ * - 'grammar' → { temperature: 0.3 }
+ * - 'task'    → {}   (no temperature; smart-tier model decides for itself)
+ *
+ * Mocks `./ai-client` and `./models/subscriptionTaskTemplate` so the test
+ * stays a pure unit test and never touches the database or any SDK.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const winston_1 = __importDefault(require("winston"));
+const mocks = vitest_1.vi.hoisted(() => ({
+    streamComplete: vitest_1.vi.fn(),
+    getDefaultModel: vitest_1.vi.fn(),
+    findOne: vitest_1.vi.fn(),
+}));
+vitest_1.vi.mock('../ai-client', () => ({
+    aiClient: { streamComplete: mocks.streamComplete },
+    getDefaultModel: mocks.getDefaultModel,
+}));
+vitest_1.vi.mock('../models/subscriptionTaskTemplate', () => ({
+    SubscriptionTaskTemplate: { findOne: mocks.findOne },
+}));
+const featureRoutes_1 = require("../featureRoutes");
+function makeLogger() {
+    return winston_1.default.createLogger({
+        silent: true,
+        transports: [new winston_1.default.transports.Console({ silent: true })],
+    });
+}
+const fakeSubscription = { id: 'sub_test' };
+(0, vitest_1.beforeEach)(() => {
+    mocks.streamComplete.mockReset();
+    mocks.streamComplete.mockResolvedValue({ usage: undefined, model: 'mock-model' });
+    mocks.getDefaultModel.mockReset();
+    mocks.getDefaultModel.mockImplementation((_provider, tier) => tier === 'smart' ? 'smart-model-mock' : 'fast-model-mock');
+    mocks.findOne.mockReset();
+    // Default task template — plain text passes through `decompressString`
+    // so `getPromptForCommand('task', ...)` returns a non-empty prompt and the
+    // streamComplete path is reached.
+    mocks.findOne.mockResolvedValue({ instructions: 'You are a helpful task assistant.' });
+});
+(0, vitest_1.describe)('runEnhancementModel — temperature per command', () => {
+    (0, vitest_1.it)("passes temperature: 0.3 for cmd='enhance'", async () => {
+        const result = await (0, featureRoutes_1.runEnhancementModel)(makeLogger(), 'hello world', 'enhance', fakeSubscription);
+        (0, vitest_1.expect)(result).not.toBeNull();
+        (0, vitest_1.expect)(mocks.streamComplete).toHaveBeenCalledTimes(1);
+        const [, , options] = mocks.streamComplete.mock.calls[0];
+        (0, vitest_1.expect)(options).toEqual({ temperature: 0.3 });
+    });
+    (0, vitest_1.it)("passes temperature: 0.3 for cmd='grammar'", async () => {
+        const result = await (0, featureRoutes_1.runEnhancementModel)(makeLogger(), 'helo wrld', 'grammar', fakeSubscription);
+        (0, vitest_1.expect)(result).not.toBeNull();
+        (0, vitest_1.expect)(mocks.streamComplete).toHaveBeenCalledTimes(1);
+        const [, , options] = mocks.streamComplete.mock.calls[0];
+        (0, vitest_1.expect)(options).toEqual({ temperature: 0.3 });
+    });
+    (0, vitest_1.it)("omits temperature for cmd='task' (custom-task)", async () => {
+        const result = await (0, featureRoutes_1.runEnhancementModel)(makeLogger(), 'do the thing', 'task', fakeSubscription);
+        (0, vitest_1.expect)(result).not.toBeNull();
+        (0, vitest_1.expect)(mocks.streamComplete).toHaveBeenCalledTimes(1);
+        const [, , options] = mocks.streamComplete.mock.calls[0];
+        (0, vitest_1.expect)(options).toEqual({});
+        (0, vitest_1.expect)(options).not.toHaveProperty('temperature');
+    });
+    (0, vitest_1.it)("selects the smart-tier model for cmd='task' and fast-tier for enhance/grammar", async () => {
+        await (0, featureRoutes_1.runEnhancementModel)(makeLogger(), 'a', 'task', fakeSubscription);
+        await (0, featureRoutes_1.runEnhancementModel)(makeLogger(), 'b', 'enhance', fakeSubscription);
+        await (0, featureRoutes_1.runEnhancementModel)(makeLogger(), 'c', 'grammar', fakeSubscription);
+        const modelsCalled = mocks.streamComplete.mock.calls.map(([model]) => model);
+        (0, vitest_1.expect)(modelsCalled).toEqual(['smart-model-mock', 'fast-model-mock', 'fast-model-mock']);
+    });
+});

package/backend-dist/ai-client.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.aiClient = exports.AIClient = void 0;
 exports.getDefaultModel = getDefaultModel;
+exports.modelSupportsTemperature = modelSupportsTemperature;
 exports.getMaxMessageContentLength = getMaxMessageContentLength;
 exports.getMaxHistoryLength = getMaxHistoryLength;
 exports.getContextWindowSize = getContextWindowSize;
@@ -17,6 +18,12 @@ const config_1 = require("./config");
 // Default model mapping
 // ---------------------------------------------------------------------------
 const DEFAULT_MODELS = {
+    // Smart-tier picks track each provider's current flagship for
+    // reasoning/coding workloads. Update here when a newer model becomes
+    // generally available so both the feature routes and the agent server pick
+    // it up automatically. When swapping a smart model in, also verify whether
+    // it accepts the `temperature` parameter and update
+    // `modelSupportsTemperature` accordingly.
     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' },
@@ -24,6 +31,39 @@ const DEFAULT_MODELS = {
 function getDefaultModel(provider, tier) {
     return DEFAULT_MODELS[provider][tier];
 }
+/**
+ * Returns whether a given model accepts the `temperature` parameter.
+ *
+ * Provider-specific rules (validated against published API docs and SDKs as
+ * of late 2025 / early 2026):
+ *  - OpenAI GPT-5 family (`gpt-5`, `gpt-5-mini`, `gpt-5.1`, …): NOT supported.
+ *    The API only accepts the default value (1) and returns
+ *    `unsupported_value: 'temperature'` for anything else.
+ *  - OpenAI o-series reasoning models (`o1`, `o3`, `o4-mini`, …): NOT
+ *    supported for the same reason.
+ *  - OpenAI GPT-4 / GPT-4o / GPT-3.5: supported.
+ *  - Google Gemini (2.x and 3.x families): supported via `generationConfig`.
+ *  - Anthropic Claude (Sonnet, Haiku, and Opus 4.x): supported, with the
+ *    exception of `claude-opus-4-7` (and its dated revisions) which rejects
+ *    `temperature` just like the OpenAI GPT-5 family.
+ */
+function modelSupportsTemperature(model) {
+    // OpenAI GPT-5 family (gpt-5, gpt-5-mini, gpt-5.1, gpt-5.5, …) only
+    // accepts the default temperature (1) — anything else is rejected with
+    // `unsupported_value: 'temperature'`.
+    if (/^gpt-5(\b|[.\-])/i.test(model))
+        return false;
+    // OpenAI o-series reasoning models (o1, o3, o4-mini, …) likewise drop the
+    // `temperature` knob.
+    if (/^o[134](\b|[-_])/i.test(model))
+        return false;
+    // Anthropic's Claude Opus 4.7 line (and its dated revisions like
+    // `claude-opus-4-7-20260101`) does not accept `temperature`; the rest of
+    // the Claude 4.x family (Sonnet, Haiku, Opus 4.5/4.6) does.
+    if (/^claude-opus-4-7(\b|[-_])/i.test(model))
+        return false;
+    return true;
+}
 /**
  * Maximum character length for a single message content string per provider.
  *
@@ -88,7 +128,7 @@ class OpenAIAdapter {
             model,
             messages: oaiMessages,
             tools: tools?.length ? tools : undefined,
-            temperature: model === 'gpt-5.5' ? 1 : (options.temperature ?? 0.2),
+            ...(modelSupportsTemperature(model) ? { temperature: options.temperature ?? 0.2 } : {}),
             max_tokens: options.maxTokens,
         });
         const choice = completion.choices[0];
@@ -125,7 +165,9 @@ class OpenAIAdapter {
         const stream = await this.client.chat.completions.create({
             model,
             messages: oaiMessages,
-            temperature: options.temperature ?? 0.3,
+            ...(modelSupportsTemperature(model)
+                ? { temperature: options.temperature ?? 0.3 }
+                : {}),
             stream: true,
             stream_options: { include_usage: true },
         });
@@ -188,7 +230,7 @@ class AnthropicAdapter {
             ...(system ? { system } : {}),
             messages: anthropicMessages,
             ...(tools?.length ? { tools } : {}),
-            ...(model === 'claude-opus-4-7' ? {} : { temperature: options.temperature ?? 0.2 }),
+            ...(modelSupportsTemperature(model) ? { temperature: options.temperature ?? 0.2 } : {}),
         });
         const textContent = response.content
             .filter((b) => b.type === 'text')
@@ -235,7 +277,9 @@ class AnthropicAdapter {
             max_tokens: options.maxTokens ?? 8192,
             ...(system ? { system } : {}),
             messages: anthropicMessages,
-            temperature: options.temperature ?? 0.3,
+            ...(modelSupportsTemperature(model)
+                ? { temperature: options.temperature ?? 0.3 }
+                : {}),
         });
         for await (const event of stream) {
             if (event.type === 'content_block_delta' &&
@@ -269,7 +313,9 @@ class GeminiAdapter {
             config: {
                 ...(systemInstruction ? { systemInstruction } : {}),
                 ...(tools?.length ? { tools } : {}),
-                temperature: options.temperature ?? 0.2,
+                ...(modelSupportsTemperature(model)
+                    ? { temperature: options.temperature ?? 0.2 }
+                    : {}),
             },
         });
         const candidate = response.candidates?.[0];
@@ -320,7 +366,9 @@ class GeminiAdapter {
             contents,
             config: {
                 ...(systemInstruction ? { systemInstruction } : {}),
-                temperature: options.temperature ?? 0.3,
+                ...(modelSupportsTemperature(model)
+                    ? { temperature: options.temperature ?? 0.3 }
+                    : {}),
             },
         });
         let usage;

package/backend-dist/featureRoutes.js

@@ -56,13 +56,12 @@ async function getPromptForCommand(logger, cmd, subscription) {
     return '';
 }
 function getModelForCommand(cmd) {
+    // 'task' is the custom-task command and routes to the smart-tier model.
+    // 'enhance' and 'grammar' use the fast tier. The actual model strings live
+    // in ai-client.ts (DEFAULT_MODELS) so all callers stay in sync when we
+    // upgrade to a newer flagship model.
     const tier = cmd === 'task' ? 'smart' : 'fast';
-    const 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' },
-    };
-    return models[config_1.config.aiProvider]?.[tier] ?? 'gpt-4o-mini';
+    return (0, ai_client_1.getDefaultModel)(config_1.config.aiProvider, tier);
 }
 function createMessagesParams(cmd, input, prompt) {
     if (cmd === 'task') {
@@ -100,7 +99,14 @@ async function runEnhancementModel(logger, text, cmd, subscription, onDelta) {
     const messages = createMessagesParams(cmd, trimmed, prompt);
     let rawResponse = '';
     let usage;
-    const result = await ai_client_1.aiClient.streamComplete(model, messages, { temperature: 0.3 }, (delta) => {
+    // Smart-tier models (used by the custom-task command) include OpenAI's
+    // GPT-5 family, which rejects any non-default `temperature`. Even on
+    // providers where the smart model still accepts it (Gemini, Anthropic),
+    // omitting `temperature` keeps the request shape uniform across providers
+    // and lets each model use its own tuned default. The fast-tier models used
+    // by `enhance` and `grammar` keep the previous 0.3 default.
+    const completionOptions = cmd === 'task' ? {} : { temperature: 0.3 };
+    const result = await ai_client_1.aiClient.streamComplete(model, messages, completionOptions, (delta) => {
         rawResponse += delta;
         if (onDelta)
             onDelta(delta);

package/backend-dist/index.js

@@ -15,8 +15,8 @@ const logger_1 = require("./logger");
 const taskInstructionRoutes_1 = require("./taskInstructionRoutes");
 const scheduledJobRoutes_1 = require("./scheduledJobRoutes");
 const mcpServerRoutes_1 = require("./mcpServerRoutes");
-const scheduledJobExecutor_1 = require("./scheduledJobExecutor");
-const sessionGrouping_1 = require("./agent/sessionGrouping");
+const spawn_1 = require("./workers/spawn");
+const scheduledJobWorkerClient_1 = require("./workers/scheduledJobWorkerClient");
 const config_1 = require("./config");
 const agentServer_1 = require("./agent/agentServer");
 // Importing AgentSession and ScheduledJob ensures the models are registered with Sequelize before initDatabase().
@@ -185,6 +185,7 @@ app.get('*', (_req, res) => {
     res.sendFile(path_1.default.join(process.cwd(), 'public', 'index.html'));
 });
 let server = null;
+const backgroundWorkers = [];
 async function start() {
     try {
         await (0, db_1.initDatabase)(logger_1.logger);
@@ -201,8 +202,15 @@ async function start() {
             (0, agentServer_1.attachAgentWebSocketServer)(server);
         }
         if (config_1.config.isSelfHosted) {
-            (0, scheduledJobExecutor_1.startScheduledJobExecutor)();
-            (0, sessionGrouping_1.startGroupingCronJob)();
+            // Run the schedulers in dedicated worker threads so their DB
+            // polling / cron ticks never block the HTTP event loop.
+            const scheduledJobWorker = (0, spawn_1.spawnWorker)('scheduledJobWorker');
+            backgroundWorkers.push(scheduledJobWorker);
+            backgroundWorkers.push((0, spawn_1.spawnWorker)('groupingWorker'));
+            // Expose the worker handle so HTTP routes (e.g. POST /:id/run-now)
+            // can dispatch immediate executions into the worker thread instead
+            // of running them in-process and blocking the event loop.
+            (0, scheduledJobWorkerClient_1.setScheduledJobWorker)(scheduledJobWorker);
         }
     }
     catch (err) {
@@ -211,21 +219,31 @@ async function start() {
     }
 }
 start();
+async function stopBackgroundWorkers() {
+    if (!backgroundWorkers.length)
+        return;
+    logger_1.logger.info('Stopping background workers...', { count: backgroundWorkers.length });
+    (0, scheduledJobWorkerClient_1.setScheduledJobWorker)(null);
+    await Promise.allSettled(backgroundWorkers.map((w) => w.stop()));
+}
 function gracefulShutdown(signal) {
     logger_1.logger.info(`Received ${signal}. Starting graceful shutdown...`);
+    const finish = (code) => {
+        void stopBackgroundWorkers().finally(() => process.exit(code));
+    };
     if (!server) {
         logger_1.logger.info('Server was not started or already closed. Exiting process.');
-        process.exit(0);
+        finish(0);
         return;
     }
     server.close((err) => {
         if (err) {
             logger_1.logger.error('Error during HTTP server shutdown.', { error: err });
-            process.exitCode = 1;
+            finish(1);
             return;
         }
         logger_1.logger.info('HTTP server closed. Exiting process.');
-        process.exit(0);
+        finish(0);
     });
 }
 process.on('SIGINT', () => gracefulShutdown('SIGINT'));

package/backend-dist/scheduledJobRoutes.js

@@ -9,6 +9,7 @@ const zod_1 = __importDefault(require("zod"));
 const authMiddleware_1 = require("./authMiddleware");
 const scheduledJob_1 = require("./models/scheduledJob");
 const scheduledJobExecutor_1 = require("./scheduledJobExecutor");
+const scheduledJobWorkerClient_1 = require("./workers/scheduledJobWorkerClient");
 const CRON_REGEX = /^(\S+\s){4}\S+$/;
 const jobSchema = zod_1.default.object({
     label: zod_1.default.string().min(1).max(200),
@@ -172,9 +173,19 @@ function scheduledJobRouter() {
             if (!job) {
                 return res.status(404).json({ error: 'Scheduled job not found.' });
             }
-            void (0, scheduledJobExecutor_1.executeJob)(job).catch((err) => {
-                logger.error('run-now execution failed.', { jobId: job.id, error: err });
-            });
+            // Prefer the background worker (self-hosted) so the execution
+            // doesn't block this HTTP handler or any other request on the main
+            // event loop. Fall back to in-process execution when no worker is
+            // running (e.g. cloud deployments or during shutdown).
+            const dispatched = (0, scheduledJobWorkerClient_1.triggerJobInWorker)(job.id);
+            if (!dispatched) {
+                void (0, scheduledJobExecutor_1.executeJob)(job).catch((err) => {
+                    logger.error('run-now execution failed.', { jobId: job.id, error: err });
+                });
+            }
+            else {
+                logger.info('run-now dispatched to scheduledJobWorker.', { jobId: job.id });
+            }
             res.json(formatJob(job));
         }
         catch (err) {

package/backend-dist/workers/groupingWorker.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const workerBootstrap_1 = require("./workerBootstrap");
+const sessionGrouping_1 = require("../agent/sessionGrouping");
+void (0, workerBootstrap_1.bootstrapWorker)('groupingWorker', () => {
+    (0, sessionGrouping_1.startGroupingCronJob)();
+});

package/backend-dist/workers/scheduledJobWorker.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const scheduledJob_1 = require("../models/scheduledJob");
+const scheduledJobExecutor_1 = require("../scheduledJobExecutor");
+const logger_1 = require("../logger");
+const workerBootstrap_1 = require("./workerBootstrap");
+void (0, workerBootstrap_1.bootstrapWorker)('scheduledJobWorker', () => {
+    (0, scheduledJobExecutor_1.startScheduledJobExecutor)();
+}, {
+    onMessage: async (msg) => {
+        if (msg.type !== 'runJob')
+            return;
+        const job = await scheduledJob_1.ScheduledJob.findByPk(msg.jobId);
+        if (!job) {
+            logger_1.logger.warn('runJob: scheduled job not found in worker.', { jobId: msg.jobId });
+            return;
+        }
+        logger_1.logger.info('runJob: executing scheduled job inside worker.', {
+            jobId: job.id,
+            label: job.label,
+        });
+        // executeJob already guards against concurrent runs of the same jobId
+        // (via RUNNING_JOB_IDS) and updates lastRunAt / nextRunAt itself, so we
+        // just fire-and-forget here and let errors surface through its own
+        // logger.error call.
+        await (0, scheduledJobExecutor_1.executeJob)(job).catch((err) => {
+            logger_1.logger.error('runJob: execution failed.', { jobId: job.id, error: err });
+        });
+    },
+});

package/backend-dist/workers/scheduledJobWorkerClient.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setScheduledJobWorker = setScheduledJobWorker;
+exports.triggerJobInWorker = triggerJobInWorker;
+let scheduledJobWorker = null;
+/**
+ * Register the scheduledJobWorker handle so HTTP routes can post messages to
+ * it. Called once from `index.ts` after the worker is spawned.
+ */
+function setScheduledJobWorker(worker) {
+    scheduledJobWorker = worker;
+}
+/**
+ * Ask the scheduledJobWorker to execute a job immediately. Returns true if
+ * the message was dispatched, false if no worker is currently running (e.g.
+ * non-self-hosted deployments where the executor still runs in-process). The
+ * caller is expected to fall back to an in-process `executeJob` when this
+ * returns false.
+ */
+function triggerJobInWorker(jobId) {
+    if (!scheduledJobWorker)
+        return false;
+    scheduledJobWorker.postMessage({ type: 'runJob', jobId });
+    return true;
+}

package/backend-dist/workers/spawn.js

@@ -0,0 +1,115 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.spawnWorker = spawnWorker;
+const path_1 = __importDefault(require("path"));
+const worker_threads_1 = require("worker_threads");
+const logger_1 = require("../logger");
+// Distance (ms) between auto-restart attempts after an unexpected exit.
+// Keeps a crashed worker from spinning a tight restart loop while still
+// recovering quickly from transient errors.
+const RESTART_DELAY_MS = 5000;
+/**
+ * Resolve the on-disk path to a worker entry file.
+ *
+ * - Production / `yarn start`: the project is compiled to `dist/` and the
+ *   running file's extension is `.js`. The compiled worker lives next to
+ *   this file at `dist/workers/<name>.js`.
+ * - Development / `yarn dev`: ts-node-dev runs the original `.ts` sources.
+ *   `__filename` ends with `.ts`, so we point the worker at the matching
+ *   `.ts` file and rely on `ts-node/register` (loaded via `execArgv`) to
+ *   transpile it on the fly inside the worker thread.
+ */
+function resolveWorkerEntry(workerName) {
+    const isTs = __filename.endsWith('.ts');
+    const ext = isTs ? '.ts' : '.js';
+    const entry = path_1.default.join(__dirname, `${workerName}${ext}`);
+    return { entry, isTs };
+}
+/**
+ * Spawn a worker thread and automatically restart it if it exits unexpectedly.
+ *
+ * The returned handle exposes a `postMessage()` method for typed RPC and a
+ * `stop()` method that disables auto-restart before terminating the worker.
+ */
+function spawnWorker(workerName) {
+    let stopped = false;
+    let restartTimer = null;
+    const handle = {
+        name: workerName,
+        // Replaced by start(); seeded with a placeholder so TS is happy.
+        worker: null,
+        postMessage: (msg) => {
+            const w = handle.worker;
+            if (!w) {
+                logger_1.logger.warn('Dropping message to worker that has not started yet.', {
+                    workerName,
+                    messageType: msg.type,
+                });
+                return;
+            }
+            try {
+                w.postMessage(msg);
+            }
+            catch (err) {
+                logger_1.logger.error('Failed to post message to worker.', {
+                    workerName,
+                    messageType: msg.type,
+                    error: err,
+                });
+            }
+        },
+        stop: async () => {
+            stopped = true;
+            if (restartTimer) {
+                clearTimeout(restartTimer);
+                restartTimer = null;
+            }
+            const w = handle.worker;
+            if (!w)
+                return;
+            try {
+                await w.terminate();
+            }
+            catch (err) {
+                logger_1.logger.error('Failed to terminate worker.', { workerName, error: err });
+            }
+        },
+    };
+    const start = () => {
+        const { entry, isTs } = resolveWorkerEntry(workerName);
+        const execArgv = isTs ? ['-r', 'ts-node/register/transpile-only'] : [];
+        logger_1.logger.info('Spawning background worker.', { workerName, entry });
+        const worker = new worker_threads_1.Worker(entry, {
+            execArgv,
+            // Forward stdout/stderr through the parent so worker logs surface in the
+            // same console / log aggregator as the main process.
+            stdout: false,
+            stderr: false,
+        });
+        handle.worker = worker;
+        worker.on('error', (err) => {
+            logger_1.logger.error('Worker emitted error.', { workerName, error: err });
+        });
+        worker.on('exit', (code) => {
+            if (stopped) {
+                logger_1.logger.info('Worker exited after stop.', { workerName, code });
+                return;
+            }
+            logger_1.logger.error('Worker exited unexpectedly; scheduling restart.', {
+                workerName,
+                code,
+                restartDelayMs: RESTART_DELAY_MS,
+            });
+            restartTimer = setTimeout(() => {
+                restartTimer = null;
+                if (!stopped)
+                    start();
+            }, RESTART_DELAY_MS);
+        });
+    };
+    start();
+    return handle;
+}

package/backend-dist/workers/workerBootstrap.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bootstrapWorker = bootstrapWorker;
+const worker_threads_1 = require("worker_threads");
+const db_1 = require("../db");
+const logger_1 = require("../logger");
+// Importing the models registers them with Sequelize before initDatabase()
+// runs inside the worker. Workers share the same model definitions as the
+// main process but each owns its own Sequelize connection.
+require("../models/agentSession");
+require("../models/scheduledJob");
+require("../models/mcpServer");
+/**
+ * Initialize a background worker thread.
+ *
+ * Each worker owns its own Sequelize connection (db.ts is evaluated fresh in
+ * the worker's V8 isolate), so DB calls performed here do not contend with
+ * the main process's connection pool or block the HTTP event loop.
+ *
+ * The `run` callback receives the initialized logger and should kick off any
+ * long-running schedulers. It must never throw — uncaught errors crash the
+ * worker, and the parent will auto-restart it after a short delay.
+ */
+async function bootstrapWorker(workerName, run, options = {}) {
+    try {
+        await (0, db_1.initDatabase)(logger_1.logger);
+        logger_1.logger.info('Worker database connection ready.', { workerName });
+        await run();
+        logger_1.logger.info('Worker entry returned; scheduler is now active.', { workerName });
+    }
+    catch (err) {
+        logger_1.logger.error('Worker bootstrap failed.', { workerName, error: err });
+        // Exit non-zero so the parent's `exit` handler treats this as a crash
+        // and schedules a restart instead of silently leaving the worker dead.
+        process.exit(1);
+    }
+    worker_threads_1.parentPort?.on('message', (raw) => {
+        // Defensive: messages can technically be any structured-clone-safe value.
+        const msg = raw;
+        if (!msg || typeof msg !== 'object' || typeof msg.type !== 'string') {
+            logger_1.logger.warn('Worker received malformed message; ignoring.', { workerName, raw });
+            return;
+        }
+        if (msg.type === 'shutdown') {
+            logger_1.logger.info('Worker received shutdown signal; exiting.', { workerName });
+            process.exit(0);
+        }
+        if (options.onMessage) {
+            void (async () => {
+                try {
+                    await options.onMessage(msg);
+                }
+                catch (err) {
+                    logger_1.logger.error('Worker message handler threw.', {
+                        workerName,
+                        messageType: msg.type,
+                        error: err,
+                    });
+                }
+            })();
+        }
+    });
+}

package/package.json

@@ -4,7 +4,7 @@
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
-  "version": "1.2.0",
+  "version": "1.4.0",
   "description": "CLI for onboarding users to Omnikey AI and configuring OPENAI_API_KEY. Use Yarn for install/build.",
   "engines": {
     "node": ">=14.0.0",