@far-world-labs/verblets 0.1.1 → 0.1.3

package/src/prompts/constants.js

@@ -1,17 +1,18 @@
 // Basic
-export const asUndefinedByDefault =
-  'If you are unsure, say "undefined" as your answer.';
-export const asBool = `Answer the question either with "true" or "false" as your answer.`;
-export const asNumber = `Answer the question with a number that could be parsed by the JS Number constructor. Do not include formatting, units, digit group separators, or spelled-out numbers in your answer.`;
-export const asJSON = `Respond with a JSON object or array that parses with JSON.parse, with no wrapping code block, and no wrapping XML.`;
+export const asUndefinedByDefault = 'If you are unsure, say "undefined" as your answer.';
+export const asBool = 'Answer the question either with "true" or "false" as your answer.';
+export const asNumber =
+  'Answer the question with a number that could be parsed by the JS Number constructor. Do not include formatting, units, digit group separators, or spelled-out numbers in your answer.';
+export const asDate =
+  'Answer the question with a date that can be parsed by the JS Date constructor. ISO format is preferred. Do not include additional text or punctuation.';
+export const asJSON =
+  'Respond with a JSON object or array that parses with JSON.parse, with no wrapping code block, and no wrapping XML.';
 
 // Response steering
-export const useLineNumber =
-  'Include the line number where each check is performed.';
+export const useLineNumber = 'Include the line number where each check is performed.';
 export const noFalseInformation = 'Do not include false information.';
 export const strictFormat = 'You MUST follow the format as described.';
-export const tryCompleteData =
-  'Err towards giving complete data, even if you have to guess.';
+export const tryCompleteData = 'Err towards giving complete data, even if you have to guess.';
 
 // JSON Output
 export const onlyJSON =
@@ -20,6 +21,8 @@ const onlyJSONArrayBase =
   'Respond with a JSON array that parses with JSON.parse, with no additional text, no punctuation, and no code block.';
 export const onlyJSONArray = onlyJSONArrayBase;
 export const onlyJSONStringArray = `${onlyJSONArrayBase} The array should only contain text. No additional structure.`;
+export const onlyJSONStringArrayPerLine =
+  'For each input line, return exactly one line containing a JSON array of strings. No additional text, no code blocks.';
 export const onlyJSONObjectArray =
   'Return an array of obects--not strings, and not just the objects.';
 export const onlyJSONStringArrayAlt1 = 'Output an JSON array of strings.';
@@ -40,27 +43,29 @@ export const contentToJSON = 'Contents to convert to JSON:';
 export const contentIsExample = 'Use this as example output only:';
 export const contentIsChoices = 'Choose only from the following:';
 export const contentIsTransformationSource = 'Transform the following object:';
-export const contentListCriteria =
-  'Create a list of items with the following description:';
-export const contentListItemCriteria =
-  'Make sure each item meets the following conditions:';
+export const contentListCriteria = 'Create a list of items with the following description:';
+export const contentListItemCriteria = 'Make sure each item meets the following conditions:';
 export const contentListToOmit = 'Do not use any of the following items:';
 export const contentIsExampleObject =
   'The returned object must look like the following, including all the same properties:';
-export const contentIsSchema =
-  'Make it conform exactly to the following schema:';
+export const contentIsSchema = 'Make it conform exactly to the following schema:';
 export const contentHasIntent = 'What is the intent of the following message:';
 export const contentIsSortCriteria = 'Sort the following items by:';
+export const contentIsIntent = 'Give me an intent response for the following:';
+export const contentIsOperationOption = 'The extracted operation must be one of the following:';
+export const contentIsParametersOptions =
+  'The extracted parameters must be from the following options:';
 
 // Give explanation
 export const explainAndSeparate =
   'Give an explanation followed by a succinct answer. The explanation part should come first, and should be at least 100 words. Next, insert a row of 20 equal signs (=) to create a clear separation.';
 export const explainAndSeparateJSON =
   'The content below the dividing line should only be valid JSON that can be parsed with JSON.parse.';
-export const explainAndSeparatePrimitive = `Next insert the succinctly-stated answer should be below the dividing line and work as a primitive datatype in JS. Be as succinct as possible as it will be parsed by a script.`;
+export const explainAndSeparatePrimitive =
+  'Next insert the succinctly-stated answer should be below the dividing line and work as a primitive datatype in JS. Be as succinct as possible as it will be parsed by a script.';
 
 // Reflective
-export const thinkStepByStep = `Let's think step by step`;
+export const thinkStepByStep = "Let's think step by step";
 export const identifyUnclearInfo =
   'Identify any unclear or ambiguous information in your response, and rephrase it for clarity.';
 export const argueAgainstOutput =
@@ -76,10 +81,8 @@ export const summarizeRequest =
   'Please summarise what I am asking for you before you begin your answer.';
 
 // Analytical
-export const considerProsCons =
-  'Consider both pros and cons before arriving at a conclusion.';
-export const provideExamples =
-  'Provide specific examples to illustrate your point.';
+export const considerProsCons = 'Consider both pros and cons before arriving at a conclusion.';
+export const provideExamples = 'Provide specific examples to illustrate your point.';
 export const explainReasoning = 'Explain the reasoning behind your answer.';
 export const alternativeSolutions =
   'If there are any alternative solutions or perspectives, please share them.';
@@ -90,12 +93,9 @@ export const alternativeInterpretations = 'How else could this be interpreted?';
 // Evidence-Based
 export const evidenceSupportsView = 'What evidence supports your view?';
 export const expertResponse = 'How would an expert in this field respond?';
-export const limitationsOfApproach =
-  'What are the limitations of your approach?';
+export const limitationsOfApproach = 'What are the limitations of your approach?';
 export const missingInformation = 'What information is still missing?';
 export const evaluateDifferingViews = 'How would you evaluate differing views?';
 export const confidenceInResponse = 'How confident are you in your response?';
-export const lessKnowledgeResponse =
-  'How would you answer this if you knew less about the topic?';
-export const analogyForUnderstanding =
-  'Come up with an analogy to make this easier to understand.';
+export const lessKnowledgeResponse = 'How would you answer this if you knew less about the topic?';
+export const analogyForUnderstanding = 'Come up with an analogy to make this easier to understand.';

package/src/prompts/generate-collection.js

@@ -1,7 +1,7 @@
 import {
+  contentListItemCriteria,
   onlyJSON,
   onlyJSONObjectArray,
-  contentListItemCriteria,
   tryCompleteData,
 } from './constants.js';
 import asObjectWithSchema from './as-object-with-schema.js';

package/src/prompts/intent.js

@@ -1,20 +1,20 @@
-import fs from 'node:fs/promises';
-
-import { contentIsExample, contentIsSchema, onlyJSON } from './constants.js';
+import fs from 'fs/promises';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
 import wrapVariable from './wrap-variable.js';
+import { onlyJSON } from './constants.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
 
-const contentIsIntent = 'Give me an intent response for the following:';
-const contentIsOperationOption =
-  'The extracted operation must be one of the following:';
-const contentIsParametersOptions =
-  'The extracted perameters must be from the following options:';
+const contentIsIntent = 'The intent is:';
+const contentIsSchema = 'The schema is:';
+const contentIsExample = 'An example of the output is:';
+const contentIsOperationOption = 'The possible operations are:';
+const contentIsParametersOptions = 'The possible parameters are:';
 
 const exampleJSON = `{
-  "queryText": "play some music",
-  "intent": {
-    "operation": "play-music",
-    "displayName": "Play Music"
-  },
+  "intent": "play_music",
   "parameters": {
     "genre": "rock"
   },
@@ -23,9 +23,7 @@ const exampleJSON = `{
   }
 }`;
 
-const intentSchema = JSON.parse(
-  await fs.readFile('./src/json-schemas/intent.json')
-);
+const intentSchema = JSON.parse(await fs.readFile(join(__dirname, '../json-schemas/intent.json')));
 
 /**
  * Approximates intent recognition like you might find with Wit.ai,
@@ -35,15 +33,11 @@ const intentSchema = JSON.parse(
 export default (text, { operations = [], parameters = [] } = {}) => {
   let operationsSection = '';
   if (operations.length) {
-    operationsSection = `\n${contentIsOperationOption} ${operations.join(
-      ', '
-    )}\n`;
+    operationsSection = `\n${contentIsOperationOption} ${operations.join(', ')}\n`;
   }
   let parametersSection = '';
   if (parameters.length) {
-    parametersSection = `\n${contentIsParametersOptions} ${parameters.join(
-      ', '
-    )}\n`;
+    parametersSection = `\n${contentIsParametersOptions} ${parameters.join(', ')}\n`;
   }
 
   return `

package/src/prompts/select-from-threshold.js

@@ -12,7 +12,6 @@ import * as R from 'ramda';
  * const openEndedPrompt = `Questions ${openEndedDegree} open-ended. `
  */
 export default (value, thresholds = []) => {
-  const threshold =
-    thresholds.find((t) => value <= t.threshold) || R.last(thresholds);
+  const threshold = thresholds.find((t) => value <= t.threshold) || R.last(thresholds);
   return threshold.degree;
 };

package/src/prompts/sort.js

@@ -1,9 +1,9 @@
 import wrapVariable from './wrap-variable.js';
 import {
-  contentIsSortCriteria,
-  contentIsMain,
-  contentIsFixes,
   contentIsDetails,
+  contentIsFixes,
+  contentIsMain,
+  contentIsSortCriteria,
   onlyJSONStringArray,
 } from './constants.js';
 
@@ -12,11 +12,7 @@ export const defaultFixes = 'Ignore duplicates in the list';
 export const defaultSortOrder = 'descending';
 
 export default (
-  {
-    description = defaultSortDescription,
-    fixes = defaultFixes,
-    sortOrder = defaultSortOrder,
-  },
+  { description = defaultSortDescription, fixes = defaultFixes, sortOrder = defaultSortOrder },
   list
 ) => {
   const listLines = JSON.stringify(list, undefined, 2);

package/src/prompts/style.js

@@ -12,17 +12,14 @@ export default (
 ) => {
   const toneModifiers = `Tone: ${tone.join(', ')}`;
   const vocabularyModifiers = `Vocabulary: ${vocabulary.join(', ')}`;
-  const sentenceStructureModifiers = `Sentence structure: ${sentenceStructure.join(
-    ', '
-  )}`;
+  const sentenceStructureModifiers = `Sentence structure: ${sentenceStructure.join(', ')}`;
   const pointOfViewModifiers = `Point of view: ${pointOfView.join(', ')}`;
-  const lengthModifier = `Use between ${minWords} and ${
-    maxWords ?? 'any number'
-  } of words`;
+  const lengthModifier = `Use between ${minWords} and ${maxWords ?? 'any number'} of words`;
 
   let noiseModifier = '';
   if (noise > 0.5) {
-    noiseModifier = `Completely reshape the ideas here, don't stick with the original structure. Don't change the meaning of the content though.`;
+    noiseModifier =
+      "Completely reshape the ideas here, don't stick with the original structure. Don't change the meaning of the content though.";
   }
 
   return `Rewrite the following content:

package/src/prompts/wrap-list.js

@@ -1,9 +1,6 @@
 import wrapVariable from './wrap-variable.js';
 
-export default (
-  list = [],
-  { introText = 'Consider the following items:' } = {}
-) => {
+export default (list = [], { introText = 'Consider the following items:' } = {}) => {
   const listText = list.map((f, i) => ` - ${i + 1}. ${f}`).join('\n');
 
   let listFragment = wrapVariable('\n');

package/src/services/llm-model/global-overrides.spec.js

@@ -0,0 +1,432 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import fetch from 'node-fetch';
+import modelService from './index.js';
+import Model from './model.js';
+
+import { run as chatgptRun } from '../../lib/chatgpt/index.js';
+
+// Mock node-fetch before importing chatgpt
+vi.mock('node-fetch', () => ({
+  default: vi.fn(),
+}));
+
+// Mock Redis
+vi.mock('../../services/redis/index.js', () => ({
+  getClient: vi.fn().mockResolvedValue({
+    get: vi.fn().mockResolvedValue(null),
+    setex: vi.fn().mockResolvedValue('OK'),
+  }),
+}));
+
+// Mock the prompt cache to avoid Redis dependencies
+vi.mock('../../lib/prompt-cache/index.js', () => ({
+  get: vi.fn().mockResolvedValue({ result: null }),
+  set: vi.fn().mockResolvedValue('OK'),
+}));
+
+// Helper tokenizer
+const tokenizer = (t) => t.split(' ');
+
+describe('Global Override System', () => {
+  beforeEach(() => {
+    // Reset models and overrides before each test
+    modelService.models = {};
+    modelService.clearGlobalOverride(); // Clear all overrides
+    modelService.bestPublicModelKey = 'fastGood';
+
+    // Setup basic models for testing
+    modelService.models = {
+      fastGood: new Model({
+        name: 'gpt-4-fast-good',
+        maxContextWindow: 128000,
+        maxOutputTokens: 16384,
+        requestTimeout: 1000,
+        apiUrl: 'https://api.openai.com',
+        apiKey: 'test-key',
+        endpoint: '/v1/chat/completions',
+        tokenizer,
+      }),
+      fastCheap: new Model({
+        name: 'gpt-4-fast-cheap',
+        maxContextWindow: 128000,
+        maxOutputTokens: 8192,
+        requestTimeout: 1000,
+        apiUrl: 'https://api.openai.com',
+        apiKey: 'test-key',
+        endpoint: '/v1/chat/completions',
+        tokenizer,
+      }),
+      fastCheapReasoning: new Model({
+        name: 'gpt-4-fast-cheap-reasoning',
+        maxContextWindow: 200000,
+        maxOutputTokens: 50000,
+        requestTimeout: 3000,
+        apiUrl: 'https://api.openai.com',
+        apiKey: 'reasoning-key',
+        endpoint: '/v1/chat/completions',
+        tokenizer,
+      }),
+      customModel: new Model({
+        name: 'custom-model-name',
+        maxContextWindow: 64000,
+        maxOutputTokens: 8192,
+        requestTimeout: 2000,
+        apiUrl: 'https://custom.api.com',
+        apiKey: 'custom-key',
+        endpoint: '/v1/completions',
+        tokenizer,
+      }),
+      expensiveReasoning: new Model({
+        name: 'gpt-4-reasoning',
+        maxContextWindow: 200000,
+        maxOutputTokens: 100000,
+        requestTimeout: 5000,
+        apiUrl: 'https://api.openai.com',
+        apiKey: 'reasoning-key',
+        endpoint: '/v1/chat/completions',
+        tokenizer,
+      }),
+      fastReasoning: new Model({
+        name: 'gpt-4-fast-reasoning',
+        maxContextWindow: 200000,
+        maxOutputTokens: 50000,
+        requestTimeout: 3000,
+        apiUrl: 'https://api.openai.com',
+        apiKey: 'reasoning-key',
+        endpoint: '/v1/chat/completions',
+        tokenizer,
+      }),
+    };
+
+    // Reset and setup fetch mock for each test
+    vi.clearAllMocks();
+    fetch.mockResolvedValue({
+      ok: true,
+      status: 200,
+      json: () =>
+        Promise.resolve({
+          choices: [{ message: { content: 'Test response' } }],
+        }),
+    });
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+    modelService.clearGlobalOverride(); // Clean up after each test
+  });
+
+  describe('Global Override Management', () => {
+    it('should set and get global overrides', () => {
+      modelService.setGlobalOverride('modelName', 'customModel');
+      modelService.setGlobalOverride('temperature', 0.8);
+
+      expect(modelService.getGlobalOverride('modelName')).toBe('customModel');
+      expect(modelService.getGlobalOverride('temperature')).toBe(0.8);
+      expect(modelService.getGlobalOverride('maxTokens')).toBe(null);
+    });
+
+    it('should get all global overrides', () => {
+      modelService.setGlobalOverride('modelName', 'customModel');
+      modelService.setGlobalOverride('temperature', 0.8);
+
+      const allOverrides = modelService.getAllGlobalOverrides();
+      expect(allOverrides.modelName).toBe('customModel');
+      expect(allOverrides.temperature).toBe(0.8);
+      expect(allOverrides.maxTokens).toBe(null);
+    });
+
+    it('should clear specific global overrides', () => {
+      modelService.setGlobalOverride('modelName', 'customModel');
+      modelService.setGlobalOverride('temperature', 0.8);
+
+      modelService.clearGlobalOverride('modelName');
+
+      expect(modelService.getGlobalOverride('modelName')).toBe(null);
+      expect(modelService.getGlobalOverride('temperature')).toBe(0.8);
+    });
+
+    it('should clear all global overrides', () => {
+      modelService.setGlobalOverride('modelName', 'customModel');
+      modelService.setGlobalOverride('temperature', 0.8);
+
+      modelService.clearGlobalOverride();
+
+      expect(modelService.getGlobalOverride('modelName')).toBe(null);
+      expect(modelService.getGlobalOverride('temperature')).toBe(null);
+    });
+
+    it('should throw error for invalid override keys', () => {
+      expect(() => {
+        modelService.setGlobalOverride('invalidKey', 'value');
+      }).toThrow('Invalid override key: invalidKey');
+
+      expect(() => {
+        modelService.clearGlobalOverride('invalidKey');
+      }).toThrow('Invalid override key: invalidKey');
+    });
+  });
+
+  describe('Model Name Override', () => {
+    it('should override model selection globally', async () => {
+      // Set global model override
+      modelService.setGlobalOverride('modelName', 'customModel');
+
+      const result = await chatgptRun('Test prompt', {
+        modelOptions: {
+          modelName: 'fastGood', // This should be overridden
+        },
+      });
+
+      expect(result).toBe('Test response');
+      expect(fetch).toHaveBeenCalledWith(
+        'https://custom.api.com/v1/completions',
+        expect.objectContaining({
+          headers: {
+            Authorization: 'Bearer custom-key',
+            'Content-Type': 'application/json',
+          },
+          body: expect.stringContaining('"model":"custom-model-name"'),
+        })
+      );
+    });
+
+    it('should override even when no modelOptions provided', async () => {
+      modelService.setGlobalOverride('modelName', 'expensiveReasoning');
+
+      const result = await chatgptRun('Test prompt');
+
+      expect(result).toBe('Test response');
+      expect(fetch).toHaveBeenCalledWith(
+        'https://api.openai.com/v1/chat/completions',
+        expect.objectContaining({
+          headers: {
+            Authorization: 'Bearer reasoning-key',
+            'Content-Type': 'application/json',
+          },
+          body: expect.stringContaining('"model":"gpt-4-reasoning"'),
+        })
+      );
+    });
+  });
+
+  describe('Negotiation Override', () => {
+    it('should override negotiation options globally', async () => {
+      modelService.setGlobalOverride('negotiate', { reasoning: true });
+
+      const result = await chatgptRun('Test prompt', {
+        modelOptions: {
+          modelName: 'fastGood',
+          negotiate: { fast: true, cheap: true }, // This should be overridden
+        },
+      });
+
+      expect(result).toBe('Test response');
+      // Should negotiate to reasoning model instead of fast+cheap
+      expect(fetch).toHaveBeenCalledWith(
+        'https://api.openai.com/v1/chat/completions',
+        expect.objectContaining({
+          body: expect.stringContaining('"model":"gpt-4-fast-cheap-reasoning"'),
+        })
+      );
+    });
+
+    it('should apply negotiation when none provided in options', async () => {
+      modelService.setGlobalOverride('negotiate', { fast: true, cheap: true });
+
+      const result = await chatgptRun('Test prompt', {
+        modelOptions: {
+          modelName: 'expensiveReasoning', // Should be overridden by negotiation
+        },
+      });
+
+      expect(result).toBe('Test response');
+      // Should negotiate instead of using explicit model
+      expect(fetch).toHaveBeenCalledWith(
+        'https://api.openai.com/v1/chat/completions',
+        expect.objectContaining({
+          body: expect.stringContaining('"model":"gpt-4-fast-cheap"'),
+        })
+      );
+    });
+  });
+
+  describe('Parameter Overrides', () => {
+    it('should override temperature globally', async () => {
+      modelService.setGlobalOverride('temperature', 0.9);
+
+      const result = await chatgptRun('Test prompt', {
+        modelOptions: {
+          modelName: 'fastGood',
+          temperature: 0.1, // This should be overridden
+        },
+      });
+
+      expect(result).toBe('Test response');
+      expect(fetch).toHaveBeenCalledWith(
+        'https://api.openai.com/v1/chat/completions',
+        expect.objectContaining({
+          body: expect.stringContaining('"temperature":0.9'),
+        })
+      );
+    });
+
+    it('should override multiple parameters', async () => {
+      modelService.setGlobalOverride('temperature', 0.8);
+      modelService.setGlobalOverride('maxTokens', 1500);
+      modelService.setGlobalOverride('topP', 0.95);
+
+      const result = await chatgptRun('Test prompt', {
+        modelOptions: {
+          modelName: 'fastGood',
+          temperature: 0.1,
+          maxTokens: 500,
+          topP: 0.5,
+        },
+      });
+
+      expect(result).toBe('Test response');
+
+      const requestBody = JSON.parse(fetch.mock.calls[0][1].body);
+      expect(requestBody.temperature).toBe(0.8);
+      expect(requestBody.max_tokens).toBe(1500);
+      expect(requestBody.top_p).toBe(0.95);
+    });
+
+    it('should preserve non-overridden parameters', async () => {
+      modelService.setGlobalOverride('temperature', 0.8);
+
+      const result = await chatgptRun('Test prompt', {
+        modelOptions: {
+          modelName: 'fastGood',
+          temperature: 0.1,
+          maxTokens: 2000,
+          topP: 0.7,
+        },
+      });
+
+      expect(result).toBe('Test response');
+
+      const requestBody = JSON.parse(fetch.mock.calls[0][1].body);
+      expect(requestBody.temperature).toBe(0.8); // Overridden
+      expect(requestBody.max_tokens).toBe(2000); // Preserved
+      expect(requestBody.top_p).toBe(0.7); // Preserved
+    });
+  });
+
+  describe('Complex Override Scenarios', () => {
+    it('should combine model and parameter overrides', async () => {
+      modelService.setGlobalOverride('modelName', 'customModel');
+      modelService.setGlobalOverride('temperature', 0.9);
+
+      const result = await chatgptRun('Test prompt', {
+        modelOptions: {
+          modelName: 'fastGood',
+          temperature: 0.1,
+          maxTokens: 1000,
+        },
+      });
+
+      expect(result).toBe('Test response');
+      expect(fetch).toHaveBeenCalledWith(
+        'https://custom.api.com/v1/completions',
+        expect.objectContaining({
+          headers: {
+            Authorization: 'Bearer custom-key',
+            'Content-Type': 'application/json',
+          },
+          body: expect.stringContaining('"temperature":0.9'),
+        })
+      );
+
+      const requestBody = JSON.parse(fetch.mock.calls[0][1].body);
+      expect(requestBody.model).toBe('custom-model-name');
+      expect(requestBody.max_tokens).toBe(1000); // Preserved
+    });
+
+    it('should handle override precedence correctly', async () => {
+      // Set both model name and negotiation overrides
+      modelService.setGlobalOverride('modelName', 'customModel');
+      modelService.setGlobalOverride('negotiate', { reasoning: true });
+
+      const result = await chatgptRun('Test prompt', {
+        modelOptions: {
+          modelName: 'fastGood',
+        },
+      });
+
+      expect(result).toBe('Test response');
+      // Negotiation should take precedence and override the model name
+      expect(fetch).toHaveBeenCalledWith(
+        'https://api.openai.com/v1/chat/completions',
+        expect.objectContaining({
+          body: expect.stringContaining('"model":"gpt-4-fast-cheap-reasoning"'),
+        })
+      );
+    });
+
+    it('should work with empty modelOptions', async () => {
+      modelService.setGlobalOverride('modelName', 'customModel');
+      modelService.setGlobalOverride('temperature', 0.7);
+
+      const result = await chatgptRun('Test prompt');
+
+      expect(result).toBe('Test response');
+      expect(fetch).toHaveBeenCalledWith(
+        'https://custom.api.com/v1/completions',
+        expect.objectContaining({
+          headers: {
+            Authorization: 'Bearer custom-key',
+            'Content-Type': 'application/json',
+          },
+          body: expect.stringContaining('"temperature":0.7'),
+        })
+      );
+    });
+  });
+
+  describe('Override Isolation', () => {
+    it('should not affect subsequent calls after clearing overrides', async () => {
+      // Set override and make a call
+      modelService.setGlobalOverride('modelName', 'customModel');
+
+      await chatgptRun('Test prompt 1');
+      expect(fetch).toHaveBeenCalledWith(
+        'https://custom.api.com/v1/completions',
+        expect.anything()
+      );
+
+      // Clear override and make another call
+      modelService.clearGlobalOverride('modelName');
+      fetch.mockClear();
+
+      await chatgptRun('Test prompt 2');
+      expect(fetch).toHaveBeenCalledWith(
+        'https://api.openai.com/v1/chat/completions',
+        expect.anything()
+      );
+    });
+
+    it('should apply overrides consistently across multiple calls', async () => {
+      modelService.setGlobalOverride('temperature', 0.8);
+
+      // First call
+      await chatgptRun('Test prompt 1', {
+        modelOptions: { modelName: 'fastGood', temperature: 0.1 },
+      });
+
+      // Second call
+      await chatgptRun('Test prompt 2', {
+        modelOptions: { modelName: 'customModel', temperature: 0.2 },
+      });
+
+      // Both calls should have temperature overridden to 0.8
+      expect(fetch).toHaveBeenCalledTimes(2);
+
+      const firstCall = JSON.parse(fetch.mock.calls[0][1].body);
+      const secondCall = JSON.parse(fetch.mock.calls[1][1].body);
+
+      expect(firstCall.temperature).toBe(0.8);
+      expect(secondCall.temperature).toBe(0.8);
+    });
+  });
+});