testronaut 1.1.1 → 1.2.0

package/tests/coreTests/turnLoop.test.js

@@ -0,0 +1,177 @@
+// tests/turnLoopTests/turnLoop.test.js
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+
+// ─────────────────────────────────────────────
+// Hoisted shared state (visible to mock factories)
+// ─────────────────────────────────────────────
+const { shared } = vi.hoisted(() => {
+  return {
+    shared: {
+      // LLM chat mock will be attached here by the llmFactory mock
+      chatMock: null,
+
+      // Browser tool spies available to the chromeBrowser mock
+      chromeToolSpies: {
+        click_text: vi.fn(async () => JSON.stringify({ ok: true, clicked: 'Hello' })),
+        get_dom: vi.fn(async () => '<html>dom</html>'),
+        screenshot: vi.fn(async () =>
+          JSON.stringify({
+            _testronaut_file_event: 'download',
+            fileName: 'shot.png',
+            bytes: 1234,
+            mode: 'save',
+          })
+        ),
+      },
+    },
+  };
+});
+
+// ─────────────────────────────────────────────
+// Mocks
+// ─────────────────────────────────────────────
+
+vi.mock('../../llm/modelResolver.js', () => ({
+  resolveProviderModel: () => ({ provider: 'stub', model: 'stub-model' }),
+}));
+
+// Use hoisted shared.chatMock
+vi.mock('../../llm/llmFactory.js', () => ({
+  getLLM: () => {
+    shared.chatMock = vi.fn();
+    return { chat: shared.chatMock };
+  },
+}));
+
+vi.mock('../../tools/tokenControl.js', () => ({
+  tokenEstimate: vi.fn(async () => 0),
+  tokenUseCoolOff: vi.fn(async (totalTokensUsed, turnTimestamps) => ({
+    shouldBackoff: false,
+    totalTokensUsed,
+    turnTimestamps,
+  })),
+  recordTokenUsage: vi.fn(() => {}),
+  pruneOldTokenUsage: vi.fn((turnTimestamps) => ({
+    turnTimestamps,
+    totalTokensUsed: turnTimestamps.reduce((a, [, t]) => a + t, 0),
+  })),
+  updateLimitsFromHeaders: vi.fn(() => {}),
+}));
+
+vi.mock('../../tools/toolSchema.js', () => ({
+  default: [
+    { type: 'function', function: { name: 'click_text', description: 'click by text', parameters: {} } },
+    { type: 'function', function: { name: 'get_dom', description: 'get DOM html', parameters: {} } },
+    { type: 'function', function: { name: 'screenshot', description: 'take a screenshot', parameters: {} } },
+  ],
+}));
+
+// Use hoisted shared.chromeToolSpies
+vi.mock('../../tools/chromeBrowser.js', () => ({
+  CHROME_TOOL_MAP: shared.chromeToolSpies,
+}));
+
+vi.mock('../../tools/turnLoopUtils.js', async () => {
+  const real = await vi.importActual('../../tools/turnLoopUtils.js');
+  return {
+    ...real,
+    finalResponseHandler: (msg) => {
+      const content = (msg?.content || '').toString();
+      if (content.includes('FINAL')) {
+        return { finalMessage: 'Mission complete', success: true };
+      }
+      return null;
+    },
+    validateAndInsertMissingToolResponses: () => true,
+    wait: vi.fn(async () => {}),
+  };
+});
+
+vi.mock('../../core/turnIntent.js', () => ({
+  summarizeTurnIntentFromMessage: (msg) => `plan:${(msg?.content || '').slice(0, 20)}`,
+}));
+
+vi.mock('../../core/redaction.js', () => ({
+  redactArgs: (name, args) => args,
+}));
+
+// Import SUT after mocks
+import { turnLoop } from '../../core/turnLoop.js';
+
+// Helper
+function baseMessages() {
+  return [
+    { role: 'system', content: 'You are Testronaut.' },
+    { role: 'user', content: 'Start mission' },
+  ];
+}
+
+describe('turnLoop', () => {
+  let browser;
+
+  beforeEach(() => {
+    browser = {};
+    // reset spies and chat mock
+    shared.chromeToolSpies.click_text.mockClear();
+    shared.chromeToolSpies.get_dom.mockClear();
+    shared.chromeToolSpies.screenshot.mockClear();
+    if (shared.chatMock) shared.chatMock.mockReset();
+  });
+
+  it('handles a final response in a single turn (no tools)', async () => {
+    shared.chatMock.mockResolvedValueOnce({
+      message: { role: 'assistant', content: 'FINAL: success' },
+      usage: { total_tokens: 42 },
+      headers: {},
+    });
+
+    const messages = baseMessages();
+    const result = await turnLoop(browser, messages, 1, 0, 0, {}, { steps: [], missionName: 'demo' });
+
+    expect(result).toBeTruthy();
+    expect(result.steps?.length).toBe(1);
+    const step = result.steps[0];
+    expect(step.tokensUsed).toBe(42);
+    expect(step.summary).toContain('plan:FINAL: success');
+    expect(step.result).toMatch(/✅|Success/);
+
+    expect(shared.chromeToolSpies.click_text).not.toHaveBeenCalled();
+    expect(shared.chromeToolSpies.get_dom).not.toHaveBeenCalled();
+  });
+
+  it('executes a tool call, injects DOM, then finishes on next turn', async () => {
+    shared.chatMock.mockResolvedValueOnce({
+      message: {
+        role: 'assistant',
+        content: '',
+        tool_calls: [
+          {
+            id: 'tool_1',
+            type: 'function',
+            function: { name: 'click_text', arguments: JSON.stringify({ text: 'Hello' }) },
+          },
+        ],
+      },
+      usage: { total_tokens: 10 },
+    });
+
+    shared.chatMock.mockResolvedValueOnce({
+      message: { role: 'assistant', content: 'FINAL: done' },
+      usage: { total_tokens: 5 },
+    });
+
+    const messages = baseMessages();
+    const res = await turnLoop(browser, messages, 2, 0, 0, {}, { steps: [], missionName: 'demo' });
+
+    expect(res).toBeTruthy();
+    expect(res.steps.length).toBe(2);
+
+    const step1 = res.steps[0];
+    expect(step1.result).toBe('✅ Passed');
+    expect(shared.chromeToolSpies.click_text).toHaveBeenCalledTimes(1);
+    expect(shared.chromeToolSpies.get_dom).toHaveBeenCalled();
+
+    const step2 = res.steps[1];
+    expect(step2.result).toMatch(/Success/);
+  });
+});

package/tests/llmTests/geminiProvider.test.js

@@ -0,0 +1,191 @@
+// tests/llmTests/geminiProvider.test.js
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+
+// Hoisted shared so the mock factory can access/record state
+const { shared } = vi.hoisted(() => ({
+  shared: {
+    apiKey: null,
+    getModelOpts: null,
+    lastContents: null,
+    // default response generator; tests can override
+    generateResponse: () => ({
+      response: {
+        candidates: [
+          { content: { parts: [{ text: 'hello' }] } }
+        ],
+        usageMetadata: { totalTokenCount: 123 },
+      },
+    }),
+  },
+}));
+
+// Mock the Google SDK
+vi.mock('@google/generative-ai', () => {
+  class FakeModel {
+    constructor(opts) { shared.getModelOpts = opts; }
+    async generateContent({ contents }) {
+      shared.lastContents = contents;
+      return shared.generateResponse();
+    }
+  }
+  class GoogleGenerativeAI {
+    constructor(key) { shared.apiKey = key; }
+    getGenerativeModel(opts) { shared.getModelOpts = opts; return new FakeModel(opts); }
+  }
+  return { GoogleGenerativeAI };
+});
+
+// Import SUT after mocks
+import { GeminiProvider } from '../../llm/gemini/geminiProvider.js';
+
+describe('GeminiProvider', () => {
+  beforeEach(() => {
+    shared.apiKey = null;
+    shared.getModelOpts = null;
+    shared.lastContents = null;
+    // reset default response
+    shared.generateResponse = () => ({
+      response: {
+        candidates: [{ content: { parts: [{ text: 'hello' }] } }],
+        usageMetadata: { totalTokenCount: 123 },
+      },
+    });
+  });
+
+  it('throws if constructed without apiKey', () => {
+    expect(() => new GeminiProvider({})).toThrow(/GEMINI_API_KEY/i);
+  });
+
+  it('passes apiKey and model/tools into the SDK correctly', async () => {
+    const prov = new GeminiProvider({ apiKey: 'gk-123' });
+
+    const tools = [
+      { type: 'function', function: { name: 'foo', description: 'Foo', parameters: { type: 'object' } } },
+      { type: 'function', function: { name: 'bar', parameters: { type: 'object', properties: { x: { type: 'string' } } } } },
+    ];
+
+    await prov.chat({
+      model: 'gemini-2.5-flash',
+      messages: [{ role: 'user', content: 'hi' }],
+      tools,
+    });
+
+    expect(shared.apiKey).toBe('gk-123');
+    expect(shared.getModelOpts?.model).toBe('gemini-2.5-flash');
+    // Tools converted to Gemini functionDeclarations wrapper
+    expect(Array.isArray(shared.getModelOpts?.tools)).toBe(true);
+    expect(shared.getModelOpts.tools[0].functionDeclarations.map(d => d.name)).toEqual(['foo', 'bar']);
+  });
+
+  it('converts OpenAI-like messages → Gemini contents (system prefix + tool calls + tool results)', async () => {
+    const prov = new GeminiProvider({ apiKey: 'gk-xyz' });
+
+    // Build a conversation:
+    // - system
+    // - user (should get system prefix injected)
+    // - assistant with tool_calls
+    // - tool result
+    // - assistant normal text
+    const messages = [
+      { role: 'system', content: 'You are helpful.' },
+      { role: 'user', content: 'search for x' },
+      {
+        role: 'assistant',
+        tool_calls: [
+          { id: '1', type: 'function', function: { name: 'search', arguments: JSON.stringify({ q: 'x' }) } },
+        ],
+      },
+      {
+        role: 'tool',
+        tool_call_id: '1',
+        name: 'search',
+        type: 'function',
+        content: JSON.stringify({ results: [1, 2, 3] }),
+      },
+      { role: 'assistant', content: 'Here are results.' },
+    ];
+
+    await prov.chat({ model: 'gemini-2.5-pro', messages });
+
+    const c = shared.lastContents;
+    expect(Array.isArray(c)).toBe(true);
+
+    // 1) First item: user with injected system prefix
+    expect(c[0].role).toBe('user');
+    expect(c[0].parts[0].text).toMatch(/^\[system]\nYou are helpful\./);
+    expect(c[0].parts[1].text).toBe('search for x');
+
+    // 2) Assistant tool call → model role with functionCall
+    expect(c[1].role).toBe('model');
+    expect(c[1].parts[0].functionCall).toEqual({ name: 'search', args: { q: 'x' } });
+
+    // 3) Tool result → user role with JSON marker
+    expect(c[2].role).toBe('user');
+    const toolJson = JSON.parse(c[2].parts[0].text);
+    expect(toolJson._tool_result).toBe(true);
+    expect(toolJson.tool_call_id).toBe('1');
+    expect(toolJson.name).toBe('search');
+
+    // 4) Final assistant text → model role with text
+    expect(c[3].role).toBe('model');
+    expect(c[3].parts[0].text).toBe('Here are results.');
+  });
+
+  it('maps Gemini candidate parts → OpenAI-like assistant message and usage', async () => {
+    // Make the fake SDK return a functionCall + text
+    shared.generateResponse = () => ({
+      response: {
+        candidates: [
+          {
+            content: {
+              parts: [
+                { functionCall: { name: 'open', args: { url: 'https://example.com' } } },
+                { text: 'Ok!' },
+              ],
+            },
+          },
+        ],
+        usageMetadata: { totalTokenCount: 999, other: 'meta' },
+      },
+    });
+
+    const prov = new GeminiProvider({ apiKey: 'gk-abc' });
+    const { message, usage } = await prov.chat({
+      model: 'gemini-2.5-flash',
+      messages: [{ role: 'user', content: 'go' }],
+    });
+
+    expect(message.role).toBe('assistant');
+    expect(message.content).toBe('Ok!');
+    expect(Array.isArray(message.tool_calls)).toBe(true);
+    expect(message.tool_calls[0].function.name).toBe('open');
+    expect(JSON.parse(message.tool_calls[0].function.arguments)).toEqual({ url: 'https://example.com' });
+
+    expect(usage.total_tokens).toBe(999);
+    expect(usage.providerRaw).toEqual({ totalTokenCount: 999, other: 'meta' });
+  });
+
+  it('supports image parts (encoded to inlineData)', async () => {
+    const prov = new GeminiProvider({ apiKey: 'gk-xyz' });
+
+    const imageBytes = Buffer.from([1, 2, 3, 4]);
+    await prov.chat({
+      model: 'gemini-2.5-flash',
+      messages: [
+        {
+          role: 'user',
+          content: [
+            { type: 'text', text: 'see image' },
+            { type: 'image', mimeType: 'image/png', data: imageBytes },
+          ],
+        },
+      ],
+    });
+
+    const c = shared.lastContents;
+    expect(c[0].role).toBe('user');
+    expect(c[0].parts[0].text).toBe('see image');
+    expect(c[0].parts[1].inlineData.mimeType).toBe('image/png');
+    expect(typeof c[0].parts[1].inlineData.data).toBe('string'); // base64
+  });
+});

package/tests/llmTests/llmFactory.test.js

@@ -0,0 +1,78 @@
+// tests/llmTests/llmFactory.test.js
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+
+// Hoisted shared spies so mock factories can access them
+const { shared } = vi.hoisted(() => ({
+  shared: {
+    openAICtor: vi.fn(),
+    geminiCtor: vi.fn(),
+  },
+}));
+
+// Mock provider classes; constructors record received options
+vi.mock('../../llm/openAI/openaiProvider.js', () => ({
+  OpenAIProvider: function (opts) {
+    shared.openAICtor(opts);
+    // minimal adapter surface used by callers
+    this.chat = vi.fn(async () => ({ message: { role: 'assistant', content: 'ok' }, usage: {} }));
+  },
+}));
+
+vi.mock('../../llm/gemini/geminiProvider.js', () => ({
+  GeminiProvider: function (opts) {
+    shared.geminiCtor(opts);
+    this.chat = vi.fn(async () => ({ message: { role: 'assistant', content: 'ok' }, usage: {} }));
+  },
+}));
+
+// Import SUT after mocks
+import { getLLM } from '../../llm/llmFactory.js';
+
+const ORIGINAL_ENV = { ...process.env };
+
+describe('getLLM', () => {
+  beforeEach(() => {
+    process.env = { ...ORIGINAL_ENV };
+    shared.openAICtor.mockClear();
+    shared.geminiCtor.mockClear();
+  });
+
+  afterEach(() => {
+    process.env = { ...ORIGINAL_ENV };
+  });
+
+  it('creates OpenAI provider (case-insensitive) and passes env key', () => {
+    process.env.OPENAI_API_KEY = 'sk-openai-123';
+    const llm = getLLM('OpEnAi');
+    expect(typeof llm.chat).toBe('function');
+    expect(shared.openAICtor).toHaveBeenCalledTimes(1);
+    expect(shared.openAICtor).toHaveBeenCalledWith(
+      expect.objectContaining({ apiKey: 'sk-openai-123' })
+    );
+    expect(shared.geminiCtor).not.toHaveBeenCalled();
+  });
+
+  it('creates Gemini provider and passes env key', () => {
+    process.env.GEMINI_API_KEY = 'gk-gemini-abc';
+    const llm = getLLM('gemini');
+    expect(typeof llm.chat).toBe('function');
+    expect(shared.geminiCtor).toHaveBeenCalledTimes(1);
+    expect(shared.geminiCtor).toHaveBeenCalledWith(
+      expect.objectContaining({ apiKey: 'gk-gemini-abc' })
+    );
+    expect(shared.openAICtor).not.toHaveBeenCalled();
+  });
+
+  it('merges opts after env so explicit opts.apiKey overrides env', () => {
+    process.env.OPENAI_API_KEY = 'sk-env-will-be-overridden';
+    const llm = getLLM('openai', { apiKey: 'sk-passed-in' });
+    expect(shared.openAICtor).toHaveBeenCalledWith(
+      expect.objectContaining({ apiKey: 'sk-passed-in' })
+    );
+    expect(typeof llm.chat).toBe('function');
+  });
+
+  it('throws on unsupported provider', () => {
+    expect(() => getLLM('anthropic')).toThrow(/Unsupported LLM provider/i);
+  });
+});

package/tests/llmTests/modelResolver.test.js

@@ -0,0 +1,119 @@
+// tests/llmTests/modelResolver.test.js
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+
+import { resolveProviderModel } from '../../llm/modelResolver.js';
+
+const ORIGINAL_ENV = { ...process.env };
+const originalCwd = process.cwd();
+
+function makeTempProject() {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'testronaut-'));
+}
+function writeConfig(dir, obj) {
+  fs.writeFileSync(path.join(dir, 'testronaut-config.json'), JSON.stringify(obj, null, 2), 'utf8');
+}
+function clearResolverEnv() {
+  delete process.env.TESTRONAUT_PROVIDER;
+  delete process.env.TESTRONAUT_MODEL;
+}
+
+beforeEach(() => {
+  process.env = { ...ORIGINAL_ENV };
+  clearResolverEnv();
+});
+
+afterEach(() => {
+  process.env = { ...ORIGINAL_ENV };
+  process.chdir(originalCwd);
+});
+
+describe('resolveProviderModel', () => {
+  it('returns env provider/model when both set', () => {
+    process.env.TESTRONAUT_PROVIDER = 'gemini';
+    process.env.TESTRONAUT_MODEL = 'gemini-2.5-flash';
+    const res = resolveProviderModel();
+    expect(res).toEqual({ provider: 'gemini', model: 'gemini-2.5-flash' });
+  });
+
+  it('reads provider/model from config file when present', () => {
+    const temp = makeTempProject();
+    writeConfig(temp, { provider: 'openai', model: 'gpt-5' });
+
+    const res = resolveProviderModel({ cwd: temp }); // 👈 pass cwd
+    expect(res.provider).toBe('openai');
+    expect(res.model).toBe('gpt-5');
+  });
+
+  it('applies env override for only one value (env model overrides config model)', () => {
+    const temp = makeTempProject();
+    writeConfig(temp, { provider: 'openai', model: 'gpt-4o' });
+    process.env.TESTRONAUT_MODEL = 'gpt-5-mini';
+
+    const res = resolveProviderModel({ cwd: temp });
+    expect(res.provider).toBe('openai');
+    expect(res.model).toBe('gpt-5-mini');
+  });
+
+  it('handles legacy config with model="openai"', () => {
+    const temp = makeTempProject();
+    writeConfig(temp, { model: 'openai' });
+
+    const res = resolveProviderModel({ cwd: temp });
+    expect(res).toEqual({ provider: 'openai', model: 'gpt-4o' });
+  });
+
+  it('returns defaults when config missing', () => {
+    const temp = makeTempProject();
+    const res = resolveProviderModel({ cwd: temp });
+    expect(res).toEqual({ provider: 'openai', model: 'gpt-4o' });
+  });
+
+  it('returns defaults when JSON parsing fails', () => {
+    const temp = makeTempProject();
+    fs.writeFileSync(path.join(temp, 'testronaut-config.json'), '{bad json', 'utf8');
+
+    const res = resolveProviderModel({ cwd: temp });
+    expect(res.provider).toBe('openai');
+    expect(res.model).toBe('gpt-4o');
+  });
+
+  it('trims env vars and treats empty strings as absent', () => {
+    process.env.TESTRONAUT_PROVIDER = '  openai  ';
+    process.env.TESTRONAUT_MODEL = '   gpt-5   ';
+    let res = resolveProviderModel();
+    expect(res).toEqual({ provider: 'openai', model: 'gpt-5' });
+
+    process.env.TESTRONAUT_PROVIDER = '   ';
+    process.env.TESTRONAUT_MODEL = '   ';
+    res = resolveProviderModel();
+    // falls back to defaults when env vars are just whitespace
+    expect(res).toEqual({ provider: 'openai', model: 'gpt-4o' });
+  });
+
+  it('prefers config when only provider is in env and model only in config', () => {
+    process.env.TESTRONAUT_PROVIDER = 'gemini';
+    const temp = fs.mkdtempSync(path.join(os.tmpdir(), 'testronaut-'));
+    fs.writeFileSync(
+      path.join(temp, 'testronaut-config.json'),
+      JSON.stringify({ provider: 'openai', model: 'gemini-2.5-flash' }),
+      'utf8'
+    );
+    const res = resolveProviderModel({ cwd: temp });
+    expect(res).toEqual({ provider: 'gemini', model: 'gemini-2.5-flash' });
+  });
+
+  it('ignores unrelated keys in config and still resolves', () => {
+    const temp = fs.mkdtempSync(path.join(os.tmpdir(), 'testronaut-'));
+    fs.writeFileSync(
+      path.join(temp, 'testronaut-config.json'),
+      JSON.stringify({ provider: 'openai', model: 'gpt-4o', extra: { foo: 1 } }),
+      'utf8'
+    );
+    const res = resolveProviderModel({ cwd: temp });
+    expect(res).toEqual({ provider: 'openai', model: 'gpt-4o' });
+  });
+
+});

package/tests/llmTests/openAIProvider.test.js

@@ -0,0 +1,117 @@
+// tests/llmTests/openAIProvider.test.js
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+
+// Hoisted shared so the mock factory can access/record state
+const { shared } = vi.hoisted(() => ({
+  shared: {
+    ctorOpts: null,
+    lastCreateArgs: null,
+    // default response; tests can override
+    responseFactory: () => ({
+      choices: [{ message: { role: 'assistant', content: 'hello' } }],
+      usage: { total_tokens: 321, prompt_tokens: 100, completion_tokens: 221 },
+      headers: { 'x-ratelimit-limit-tokens': '90000' },
+    }),
+  },
+}));
+
+// Mock the OpenAI SDK surface we use
+vi.mock('openai', () => {
+  class FakeChatCompletions {
+    async create(args) {
+      shared.lastCreateArgs = args;
+      return shared.responseFactory();
+    }
+  }
+  class FakeChat {
+    constructor() {
+      this.completions = new FakeChatCompletions();
+    }
+  }
+  class OpenAI {
+    constructor(opts) {
+      shared.ctorOpts = opts;
+      this.chat = new FakeChat();
+    }
+  }
+  return { default: OpenAI };
+});
+
+// Import SUT after mocks
+import { OpenAIProvider } from '../../llm/openAI/openaiProvider.js';
+
+describe('OpenAIProvider', () => {
+  beforeEach(() => {
+    shared.ctorOpts = null;
+    shared.lastCreateArgs = null;
+    shared.responseFactory = () => ({
+      choices: [{ message: { role: 'assistant', content: 'hello' } }],
+      usage: { total_tokens: 321, prompt_tokens: 100, completion_tokens: 221 },
+      headers: { 'x-ratelimit-limit-tokens': '90000' },
+    });
+  });
+
+  it('throws without apiKey', () => {
+    expect(() => new OpenAIProvider({})).toThrow(/OPENAI_API_KEY/i);
+  });
+
+  it('passes apiKey to OpenAI constructor', () => {
+    const p = new OpenAIProvider({ apiKey: 'sk-test-123' });
+    expect(shared.ctorOpts).toEqual({ apiKey: 'sk-test-123' });
+    expect(typeof p.chat).toBe('function');
+  });
+
+  it('calls chat.completions.create with model/messages/tools', async () => {
+    const prov = new OpenAIProvider({ apiKey: 'sk-abc' });
+    const tools = [{ type: 'function', function: { name: 'doThing', parameters: { type: 'object' } } }];
+
+    await prov.chat({
+      model: 'gpt-4o',
+      messages: [{ role: 'user', content: 'hi' }],
+      tools,
+    });
+
+    expect(shared.lastCreateArgs).toEqual({
+      model: 'gpt-4o',
+      messages: [{ role: 'user', content: 'hi' }],
+      tools,
+    });
+  });
+
+  it('returns normalized message, usage, and headers', async () => {
+    const prov = new OpenAIProvider({ apiKey: 'sk-abc' });
+    const { message, usage, headers } = await prov.chat({
+      model: 'gpt-4o',
+      messages: [{ role: 'user', content: 'go' }],
+    });
+
+    expect(message).toEqual({ role: 'assistant', content: 'hello' });
+    expect(usage.total_tokens).toBe(321);
+    expect(usage.providerRaw).toEqual({ total_tokens: 321, prompt_tokens: 100, completion_tokens: 221 });
+    expect(headers).toEqual({ 'x-ratelimit-limit-tokens': '90000' });
+  });
+
+  it('handles SDK variants with headers on response.response.headers', async () => {
+    shared.responseFactory = () => ({
+      choices: [{ message: { role: 'assistant', content: 'ok' } }],
+      usage: { total_tokens: 11 },
+      response: { headers: { 'x-ratelimit-limit-tokens': '12345' } },
+    });
+
+    const prov = new OpenAIProvider({ apiKey: 'sk-abc' });
+    const { headers } = await prov.chat({ model: 'gpt-4o', messages: [] });
+    expect(headers).toEqual({ 'x-ratelimit-limit-tokens': '12345' });
+  });
+
+  it('provides a default assistant message when choices are empty', async () => {
+    shared.responseFactory = () => ({
+      choices: [],
+      usage: {},
+      headers: {},
+    });
+
+    const prov = new OpenAIProvider({ apiKey: 'sk-abc' });
+    const { message } = await prov.chat({ model: 'gpt-4o', messages: [] });
+    expect(message).toEqual({ role: 'assistant', content: '' });
+  });
+});