@startsimpli/llm 0.4.19 → 0.4.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@startsimpli/llm",
-  "version": "0.4.19",
+  "version": "0.4.21",
   "description": "Generic LLM service infrastructure — provider abstraction, retry logic, JSON extraction",
   "main": "./src/index.ts",
   "types": "./src/index.ts",

package/src/__tests__/openai-provider.test.ts

@@ -64,42 +64,111 @@ afterEach(() => {
   vi.unstubAllGlobals();
 });
 
-describe('the token-limit parameter', () => {
-  it.each(['gpt-5', 'gpt-5.1', 'gpt-5.2'])(
-    '%s gets max_completion_tokens and never max_tokens',
+/** Make the next fetch answer 400 with an OpenAI error body (formats captured from the API 2026-10-02). */
+function reject(error: { message: string; code?: string | null; param?: string | null }) {
+  fetchMock.mockImplementationOnce(async (_url: unknown, init: RequestInit) => {
+    sent.push(JSON.parse(String(init.body)) as Sent);
+    return { ok: false, status: 400, json: async () => ({ error: { type: 'invalid_request_error', ...error } }) } as unknown as Response;
+  });
+}
+
+describe('any model the account can call works: no model-name rules', () => {
+  it.each(['gpt-4o', 'gpt-4o-mini', 'ft:gpt-4.1-mini-2025-04-14:org:x:1', 'gpt-5.5', 'gpt-6.1-sol', 'some-model-nobody-has-heard-of'])(
+    '%s gets max_completion_tokens (accepted by every chat model) and never max_tokens',
     async (model) => {
       await provider(model).generate('u', 's');
-
       expect(sent[0]!.max_completion_tokens).toBeGreaterThan(0);
       expect(sent[0]!.max_tokens).toBeUndefined();
     },
   );
 
-  it('an UNRELEASED gpt-5 model is handled by family, not by a hardcoded list', async () => {
-    // bd startsim-768w.38.26. The day this id ships, a literal deny-list sends
-    // it max_tokens and every call 400s — silently, from the caller's view.
-    await provider('gpt-5.3').generate('u', 's');
+  it('sends the configured temperature to every model until one refuses it', async () => {
+    await provider('gpt-6-sol').generate('u', 's');
+    await provider('gpt-4o').generate('u', 's');
+    expect(sent.map((b) => b.temperature)).toEqual([0.2, 0.2]);
+  });
+});
 
-    expect(sent[0]!.max_completion_tokens).toBeGreaterThan(0);
-    expect(sent[0]!.max_tokens).toBeUndefined();
+describe('adapting to what a model refuses', () => {
+  it('drops temperature when the model only takes its default, and remembers', async () => {
+    const p = provider('gpt-6-sol');
+    reject({ code: 'unsupported_value', param: 'temperature', message: "Unsupported value: 'temperature' does not support 0.2 with this model. Only the default (1) value is supported." });
+    const res = await p.generate('u', 's');
+    expect(res.content).toBe('{"ok":true}');
+    expect(sent).toHaveLength(2);
+    expect(sent[0]!.temperature).toBe(0.2);
+    expect(sent[1]!.temperature).toBeUndefined();
+    // second call: no retry, temperature already known to be refused
+    await p.generate('u', 's');
+    expect(sent).toHaveLength(3);
+    expect(sent[2]!.temperature).toBeUndefined();
   });
 
-  it('gpt-4o keeps max_tokens, which it accepts', async () => {
-    // The fix must not break the models that were working.
-    await provider('gpt-4o').generate('u', 's');
+  it('moves to the nearest supported reasoning effort the API lists', async () => {
+    const p = provider('gpt-6.1-sol');
+    reject({ code: 'unsupported_value', param: 'reasoning_effort', message: "Unsupported value: 'reasoning_effort' does not support 'none' with this model. Supported values are: 'low', 'medium', 'high', and 'xhigh'." });
+    await p.generate('u', 's', { reasoningEffort: 'none', maxTokens: 256 });
+    expect(sent[0]!.reasoning_effort).toBe('none');
+    expect(sent[1]!.reasoning_effort).toBe('low');
+    expect(sent[1]!.max_completion_tokens).toBeGreaterThan(256); // headroom for the effort actually sent
+    await p.generate('u', 's', { reasoningEffort: 'none' });
+    expect(sent[2]!.reasoning_effort).toBe('low');
+  });
 
-    expect(sent[0]!.max_tokens).toBeGreaterThan(0);
-    expect(sent[0]!.max_completion_tokens).toBeUndefined();
+  it('drops reasoning_effort for a model that does not reason', async () => {
+    const p = provider('gpt-4o');
+    reject({ code: null, param: null, message: 'Unrecognized request argument supplied: reasoning_effort' });
+    await p.generate('u', 's', { reasoningEffort: 'low', maxTokens: 300 });
+    expect(sent[1]!.reasoning_effort).toBeUndefined();
+    expect(sent[1]!.max_completion_tokens).toBe(300); // no reasoning, no headroom
   });
 
-  it('honours an explicit maxTokens on whichever parameter the model takes', async () => {
-    // For the gpt-5 family maxTokens is the ANSWER budget; reasoning headroom is
-    // added on top (see the reasoning describe below). none = no reasoning.
-    await provider('gpt-5.2').generate('u', 's', { maxTokens: 123, reasoningEffort: 'none' });
-    await provider('gpt-4o').generate('u', 's', { maxTokens: 123 });
+  it('clamps the token cap to what the model says it supports', async () => {
+    const p = provider('gpt-4o');
+    reject({ code: 'invalid_value', param: 'max_tokens', message: 'max_tokens is too large: 20288. This model supports at most 16384 completion tokens, whereas you provided 20288.' });
+    await p.generate('u', 's', { maxTokens: 8000 });
+    expect(sent[1]!.max_completion_tokens).toBe(16384);
+  });
+
+  it('does not loop: an error it cannot act on, or the same lesson twice, throws', async () => {
+    const p = provider('gpt-6-sol');
+    reject({ code: 'invalid_value', param: 'messages', message: 'Invalid messages.' });
+    await expect(p.generate('u', 's')).rejects.toThrow();
+    expect(sent).toHaveLength(1);
+
+    const q = provider('gpt-6-sol');
+    const tempErr = { code: 'unsupported_value', param: 'temperature', message: "Unsupported value: 'temperature' does not support 0.2 with this model." };
+    reject(tempErr);
+    reject(tempErr);
+    await expect(q.generate('u', 's')).rejects.toThrow();
+    expect(sent).toHaveLength(3);
+  });
 
-    expect(sent[0]!.max_completion_tokens).toBe(123);
-    expect(sent[1]!.max_tokens).toBe(123);
+  it('parallel first calls all succeed: a lesson learned by one request applies to the others in flight', async () => {
+    // Regression: crochet's assembly pipeline fires its connection calls in
+    // parallel. All of them sent 'none' before any answer; the first 400 taught
+    // the provider 'low', and the others saw that lesson as already learned and
+    // threw instead of retrying (gpt-6-astra: 12 of 12 connections failed).
+    const p = provider('gpt-6.1-sol');
+    const effortErr = { code: 'unsupported_value', param: 'reasoning_effort', message: "Unsupported value: 'reasoning_effort' does not support 'none' with this model. Supported values are: 'low', 'medium', 'high', and 'xhigh'." };
+    reject(effortErr);
+    reject(effortErr);
+    reject(effortErr);
+    const results = await Promise.all([1, 2, 3].map(() => p.generate('u', 's', { reasoningEffort: 'none' })));
+    expect(results.every((r) => r.content === '{"ok":true}')).toBe(true);
+    expect(sent.slice(3).every((b) => b.reasoning_effort === 'low')).toBe(true);
+  });
+
+  it('adapts on the tool-calling path too', async () => {
+    const p = provider('gpt-6-sol');
+    reject({ code: 'unsupported_value', param: 'temperature', message: "Unsupported value: 'temperature' does not support 0.2 with this model. Only the default (1) value is supported." });
+    fetchMock.mockImplementationOnce(async (_url: unknown, init: RequestInit) => {
+      sent.push(JSON.parse(String(init.body)) as Sent);
+      return { ok: true, status: 200, json: async () => ({ ...OK_BODY, choices: [{ index: 0, message: { role: 'assistant', content: 'done' }, finish_reason: 'stop' }] }) } as unknown as Response;
+    });
+    const res = await p.generateWithTools([{ role: 'user', content: 'hi' }], 's', []);
+    expect(res.content).toBe('done');
+    expect(sent[1]!.temperature).toBeUndefined();
   });
 });
 
@@ -109,24 +178,17 @@ describe('the token-limit parameter', () => {
  *   none   -> 2.3s, 35 completion tokens, 0 reasoning
  *   low    -> 2.8s, 130 completion tokens, 91 reasoning
  *   medium -> 42.8s, 412 completion tokens, 377 reasoning
- *   minimal -> 400 "does not support 'minimal' with this model"
- * crochet's assembly pipeline asked for 256 tokens per connection call and got
- * an empty answer 11 times out of 11. Hidden reasoning is billed against
- * max_completion_tokens, so a caller's answer budget must get headroom.
+ * Hidden reasoning is billed against max_completion_tokens, so a caller's
+ * answer budget gets headroom.
  */
-describe('reasoning (gpt-5 family)', () => {
-  it('sends reasoning_effort when one is given, to gpt-5 models only', async () => {
+describe('reasoning effort and headroom', () => {
+  it('sends reasoning_effort when one is given, and omits it otherwise', async () => {
     await provider('gpt-5.5').generate('u', 's', { reasoningEffort: 'low' });
-    await provider('gpt-4o').generate('u', 's', { reasoningEffort: 'low' });
+    await provider('gpt-5.5').generate('u', 's');
     expect(sent[0]!.reasoning_effort).toBe('low');
     expect(sent[1]!.reasoning_effort).toBeUndefined();
   });
 
-  it('omits reasoning_effort when none is configured (the API default applies)', async () => {
-    await provider('gpt-5.5').generate('u', 's');
-    expect(sent[0]!.reasoning_effort).toBeUndefined();
-  });
-
   it('takes the default effort from the provider config', async () => {
     await new OpenAIProvider({ apiKey: 'k', defaultModel: 'gpt-5.5', defaultReasoningEffort: 'low' }).generate('u', 's');
     expect(sent[0]!.reasoning_effort).toBe('low');
@@ -139,43 +201,7 @@ describe('reasoning (gpt-5 family)', () => {
     const [none, low, unset] = sent.map((b) => b.max_completion_tokens!);
     expect(none).toBe(256);
     expect(low).toBeGreaterThanOrEqual(256 + 1000);
-    // unset means the API's default effort (medium), which reasons the most of these
-    expect(unset).toBeGreaterThan(low);
-  });
-
-  it('applies to the tool-calling path too', async () => {
-    fetchMock.mockImplementationOnce(async (_url: unknown, init: RequestInit) => {
-      sent.push(JSON.parse(String(init.body)) as Sent);
-      return { ok: true, status: 200, json: async () => ({ ...OK_BODY, choices: [{ index: 0, message: { role: 'assistant', content: 'done' }, finish_reason: 'stop' }] }) } as unknown as Response;
-    });
-    await provider('gpt-5.5').generateWithTools([{ role: 'user', content: 'hi' }], 's', [], { maxTokens: 100, reasoningEffort: 'low' });
-    expect(sent[0]!.reasoning_effort).toBe('low');
-    expect(sent[0]!.max_completion_tokens).toBeGreaterThan(100);
-  });
-});
-
-describe('temperature', () => {
-  it.each(['gpt-5', 'gpt-5.1', 'gpt-5.2', 'gpt-5.3'])(
-    '%s is sent temperature 1.0, whatever the deployment configured',
-    async (model) => {
-      // Base gpt-5 models reject any other value.
-      await provider(model).generate('u', 's', { temperature: 0.2 });
-
-      expect(sent[0]!.temperature).toBe(1.0);
-    },
-  );
-
-  it('a FINE-TUNED gpt-5 keeps the configured temperature', async () => {
-    // The existing carve-out, preserved: ft: models do accept it.
-    await provider('ft:gpt-5.2:acme::abc123').generate('u', 's', { temperature: 0.2 });
-
-    expect(sent[0]!.temperature).toBe(0.2);
-  });
-
-  it('gpt-4o keeps the configured temperature', async () => {
-    await provider('gpt-4o').generate('u', 's', { temperature: 0.2 });
-
-    expect(sent[0]!.temperature).toBe(0.2);
+    expect(unset).toBeGreaterThan(low); // unset = the API default (medium)
   });
 });
 

package/src/providers/openai.ts

@@ -32,43 +32,97 @@ interface OpenAIRequest {
   model: string;
   messages: OpenAIMessage[];
   temperature?: number;
-  /** Pre-gpt-5 models. Rejected outright by the gpt-5 family. */
-  max_tokens?: number;
-  /** The gpt-5 family's replacement for `max_tokens`. */
+  /** Accepted by every current chat model; `max_tokens` is rejected by reasoning models. */
   max_completion_tokens?: number;
-  /** gpt-5 family only. */
+  /** Reasoning models only; dropped automatically for models that reject it. */
   reasoning_effort?: ReasoningEffort;
   response_format?: { type: 'json_object' | 'text' };
 }
 
 /**
- * Is this the gpt-5 FAMILY? Matched by prefix, deliberately, not by a list of
- * ids (bd startsim-768w.38.26 filed the literal-id deny-list as a bug: it is
- * "correct only until OpenAI ships gpt-5.3", and the failure is a silent 400).
- * `ft:gpt-5…` fine-tunes are still gpt-5 models on the wire.
+ * WHAT A MODEL ACCEPTS IS LEARNED FROM THE API, NOT GUESSED FROM ITS NAME.
+ *
+ * The provider used to pick parameters by matching the model id (`gpt-5…` got
+ * max_completion_tokens and temperature 1.0). Every new family broke that:
+ * gpt-6* were treated as legacy and 400'd on every call. Any model the account
+ * can call must work, so requests are built in the modern shape and adapted
+ * when the API says why it refused (measured 2026-10-02):
+ *
+ *   max_completion_tokens  accepted by every chat model tried (gpt-4o,
+ *                          gpt-4o-mini, a gpt-4.1 fine-tune, gpt-5.x, gpt-6.x);
+ *                          `max_tokens` is rejected by all reasoning models.
+ *   temperature            400 unsupported_value param=temperature on reasoning
+ *                          models ("Only the default (1) value is supported")
+ *                          -> drop it.
+ *   reasoning_effort       non-reasoning models: "Unrecognized request argument
+ *                          supplied: reasoning_effort" -> drop it. Unsupported
+ *                          level: "Supported values are: 'low', 'medium', ..."
+ *                          -> nearest supported at or above the one asked for.
+ *   token cap              400 invalid_value "This model supports at most N
+ *                          completion tokens" -> clamp to N.
+ *
+ * Each lesson is remembered per model for the life of the provider, so only the
+ * first call to a model pays for the retry.
  */
-function isGpt5Family(model: string): boolean {
-  return /^gpt-5/.test(model.startsWith('ft:') ? model.slice(3) : model);
+interface ModelQuirks {
+  noTemperature?: boolean;
+  noReasoningEffort?: boolean;
+  /** Reasoning efforts this model accepts, when the API has told us. */
+  efforts?: ReasoningEffort[];
+  /** Largest completion-token cap this model accepts. */
+  maxOutput?: number;
+}
+
+const EFFORT_ORDER: ReasoningEffort[] = ['none', 'minimal', 'low', 'medium', 'high', 'xhigh'];
+
+/** The supported effort closest to the one asked for, preferring more reasoning over less. */
+function nearestEffort(want: ReasoningEffort, supported: ReasoningEffort[]): ReasoningEffort | undefined {
+  const rank = EFFORT_ORDER.indexOf(want);
+  const sorted = [...supported].sort((a, b) => EFFORT_ORDER.indexOf(a) - EFFORT_ORDER.indexOf(b));
+  return sorted.find((e) => EFFORT_ORDER.indexOf(e) >= rank) ?? sorted[sorted.length - 1];
 }
 
 /**
- * The token-limit parameter this model accepts. MEASURED against api.openai.com
- * on 2026-08-19: gpt-5.2 rejects `max_tokens` with "Unsupported parameter ...
- * Use 'max_completion_tokens' instead", while gpt-4o accepts `max_tokens`.
- * Sending the wrong one is a total outage of that model, not a degraded call.
+ * Update `q` from a 400. Returns true when the request can be retried with
+ * different parameters, false when the error is not about parameters.
  */
-function tokenLimitParam(model: string, maxTokens: number, effort?: ReasoningEffort): Partial<OpenAIRequest> {
-  return isGpt5Family(model)
-    ? { max_completion_tokens: maxTokens + reasoningHeadroom(effort) }
-    : { max_tokens: maxTokens };
+function learnFromError(q: ModelQuirks, err: OpenAIErrorResponse['error'] | undefined, sent: { effort?: ReasoningEffort; maxTokens: number }): boolean {
+  if (!err?.message) return false;
+  const msg = err.message;
+  if (err.param === 'temperature' || /'temperature'/.test(msg)) {
+    if (q.noTemperature) return false;
+    q.noTemperature = true;
+    return true;
+  }
+  if (err.param === 'reasoning_effort' || /reasoning_effort/.test(msg)) {
+    const listed = [...msg.matchAll(/'([a-z]+)'/g)].map((m) => m[1]).filter((v): v is ReasoningEffort => (EFFORT_ORDER as string[]).includes(v));
+    const supported = listed.filter((v) => v !== sent.effort);
+    if (/Supported values/i.test(msg) && supported.length) {
+      if (q.efforts && q.efforts.join() === supported.join()) return false;
+      q.efforts = supported;
+      return true;
+    }
+    if (q.noReasoningEffort) return false;
+    q.noReasoningEffort = true;
+    return true;
+  }
+  const most = /at most (\d+) completion tokens/i.exec(msg);
+  if (most) {
+    const max = Number(most[1]);
+    if (!(max > 0) || (q.maxOutput !== undefined && q.maxOutput <= max)) return false;
+    q.maxOutput = max;
+    return true;
+  }
+  return false;
 }
 
 /**
- * Tokens to allow for hidden reasoning, which the gpt-5 family bills against
+ * Tokens to allow for hidden reasoning, which reasoning models bill against
  * max_completion_tokens: a caller's maxTokens is the size of the ANSWER. Unset
- * means the API's default effort (medium). Measured on gpt-5.5: low reasoned
- * ~90 tokens and medium ~380 on a small structured call; large outputs reason
- * far more, so these are generous ceilings, not estimates.
+ * means the API's default effort (medium on gpt-5.5). Measured on gpt-5.5: low
+ * reasoned ~90 tokens and medium ~380 on a small structured call; large outputs
+ * reason far more, so these are generous ceilings, not estimates. A cap is not
+ * a charge, and a model that rejects a cap this large gets it clamped.
  */
 function reasoningHeadroom(effort?: ReasoningEffort): number {
   switch (effort) {
@@ -82,11 +136,25 @@ function reasoningHeadroom(effort?: ReasoningEffort): number {
   }
 }
 
-/** reasoning_effort for a gpt-5 model, when one is configured. */
-function reasoningParam(model: string, effort?: ReasoningEffort): Partial<OpenAIRequest> {
-  return isGpt5Family(model) && effort ? { reasoning_effort: effort } : {};
+/** The sampling half of a request, shaped by what this model has told us it accepts. */
+function samplingParams(
+  q: ModelQuirks,
+  temperature: number,
+  maxTokens: number,
+  effort?: ReasoningEffort,
+): Pick<OpenAIRequest, 'temperature' | 'max_completion_tokens' | 'reasoning_effort'> {
+  const sentEffort = q.noReasoningEffort || !effort ? undefined : (q.efforts ? nearestEffort(effort, q.efforts) : effort);
+  const headroom = q.noReasoningEffort ? 0 : reasoningHeadroom(sentEffort);
+  const cap = maxTokens + headroom;
+  return {
+    ...(q.noTemperature ? {} : { temperature }),
+    max_completion_tokens: q.maxOutput !== undefined ? Math.min(cap, q.maxOutput) : cap,
+    ...(sentEffort ? { reasoning_effort: sentEffort } : {}),
+  };
 }
 
+const MAX_ADAPTIVE_RETRIES = 3;
+
 interface OpenAIResponse {
   id: string;
   object: string;
@@ -167,6 +235,14 @@ export class OpenAIProvider implements ILLMProvider {
   readonly defaultModel: string;
 
   private readonly config: Required<Omit<ProviderConfig, 'defaultReasoningEffort'>> & Pick<ProviderConfig, 'defaultReasoningEffort'>;
+  /** What each model has told us it accepts (see learnFromError). */
+  private readonly quirks = new Map<string, ModelQuirks>();
+
+  private quirksFor(model: string): ModelQuirks {
+    let q = this.quirks.get(model);
+    if (!q) { q = {}; this.quirks.set(model, q); }
+    return q;
+  }
 
   constructor(config: ProviderConfig) {
     this.config = {
@@ -181,6 +257,44 @@ export class OpenAIProvider implements ILLMProvider {
     this.defaultModel = this.config.defaultModel;
   }
 
+  /**
+   * POST a chat completion, adapting the request when the API rejects a
+   * parameter this model doesn't take (see learnFromError). Non-parameter
+   * errors, and a parameter error we can't act on, throw as before.
+   */
+  private async postAdaptively<T>(
+    model: string,
+    build: (q: ModelQuirks) => object,
+    sent: { effort?: ReasoningEffort; maxTokens: number },
+    signal: AbortSignal,
+  ): Promise<T> {
+    const q = this.quirksFor(model);
+    for (let attempt = 0; ; attempt++) {
+      const body = JSON.stringify(build(q));
+      const response = await fetch(`${this.config.baseUrl}/chat/completions`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          Authorization: `Bearer ${this.config.apiKey}`,
+        },
+        body,
+        signal,
+      });
+      if (response.ok) return (await response.json()) as T;
+      const errorData = (await response.json().catch(() => ({
+        error: { message: 'Unknown error' },
+      }))) as OpenAIErrorResponse;
+      if (response.status === 400 && attempt < MAX_ADAPTIVE_RETRIES) {
+        const learned = learnFromError(q, errorData.error, sent);
+        // Calls to a new model often go out in parallel: by the time this one
+        // fails, another may already have learned the lesson, so retry whenever
+        // the request would now be built differently from the one just sent.
+        if (learned || JSON.stringify(build(q)) !== body) continue;
+      }
+      throw this.handleApiError(response.status, errorData);
+    }
+  }
+
   isAvailable(): boolean {
     return Boolean(this.config.apiKey);
   }
@@ -201,53 +315,31 @@ export class OpenAIProvider implements ILLMProvider {
     }
 
     const model = options?.model ?? this.config.defaultModel;
-    // Base gpt-5 models require temperature=1.0, but fine-tuned models use configured temperature
-    const isFineTuned = model.startsWith('ft:');
-    const isBaseGpt5 = isGpt5Family(model) && !isFineTuned;
-    const temperature = isBaseGpt5
-      ? 1.0
-      : (options?.temperature ?? this.config.defaultTemperature);
+    const temperature = options?.temperature ?? this.config.defaultTemperature;
     const maxTokens = options?.maxTokens ?? this.config.defaultMaxTokens;
     const effort = options?.reasoningEffort ?? this.config.defaultReasoningEffort;
     const timeout = options?.timeout ?? this.config.timeoutMs;
 
-    const requestBody: OpenAIRequest = {
+    const base = {
       model,
       messages: [
-        { role: 'system', content: systemPrompt },
-        { role: 'user', content: userPrompt },
+        { role: 'system' as const, content: systemPrompt },
+        { role: 'user' as const, content: userPrompt },
       ],
-      temperature,
-      ...tokenLimitParam(model, maxTokens, effort),
-      ...reasoningParam(model, effort),
-      response_format: { type: 'json_object' },
+      response_format: { type: 'json_object' as const },
     };
 
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), timeout);
 
     try {
-      const response = await fetch(`${this.config.baseUrl}/chat/completions`, {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-          Authorization: `Bearer ${this.config.apiKey}`,
-        },
-        body: JSON.stringify(requestBody),
-        signal: controller.signal,
-      });
+      const data = await this.postAdaptively<OpenAIResponse>(model, (q) => ({
+        ...base,
+        ...samplingParams(q, temperature, maxTokens, effort),
+      }), { effort, maxTokens }, controller.signal);
 
       clearTimeout(timeoutId);
 
-      if (!response.ok) {
-        const errorData = (await response.json().catch(() => ({
-          error: { message: 'Unknown error' },
-        }))) as OpenAIErrorResponse;
-        throw this.handleApiError(response.status, errorData);
-      }
-
-      const data = (await response.json()) as OpenAIResponse;
-
       if (!data.choices?.[0]?.message?.content) {
         throw new LLMProviderError(
           'Empty response from OpenAI',
@@ -320,11 +412,7 @@ export class OpenAIProvider implements ILLMProvider {
     }
 
     const model = options?.model ?? this.config.defaultModel;
-    const isFineTuned = model.startsWith('ft:');
-    const isBaseGpt5 = isGpt5Family(model) && !isFineTuned;
-    const temperature = isBaseGpt5
-      ? 1.0
-      : (options?.temperature ?? this.config.defaultTemperature);
+    const temperature = options?.temperature ?? this.config.defaultTemperature;
     const maxTokens = options?.maxTokens ?? this.config.defaultMaxTokens;
     const effort = options?.reasoningEffort ?? this.config.defaultReasoningEffort;
     const timeout = options?.timeout ?? this.config.timeoutMs;
@@ -350,12 +438,9 @@ export class OpenAIProvider implements ILLMProvider {
       }),
     ];
 
-    const requestBody = {
+    const base = {
       model,
       messages: oaiMessages,
-      temperature,
-      ...tokenLimitParam(model, maxTokens, effort),
-      ...reasoningParam(model, effort),
       tools: tools.map((t) => ({
         type: 'function' as const,
         function: { name: t.name, description: t.description, parameters: t.parameters },
@@ -366,25 +451,11 @@ export class OpenAIProvider implements ILLMProvider {
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), timeout);
     try {
-      const response = await fetch(`${this.config.baseUrl}/chat/completions`, {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-          Authorization: `Bearer ${this.config.apiKey}`,
-        },
-        body: JSON.stringify(requestBody),
-        signal: controller.signal,
-      });
+      const data = await this.postAdaptively<OpenAIToolsResponse>(model, (q) => ({
+        ...base,
+        ...samplingParams(q, temperature, maxTokens, effort),
+      }), { effort, maxTokens }, controller.signal);
       clearTimeout(timeoutId);
-
-      if (!response.ok) {
-        const errorData = (await response.json().catch(() => ({
-          error: { message: 'Unknown error' },
-        }))) as OpenAIErrorResponse;
-        throw this.handleApiError(response.status, errorData);
-      }
-
-      const data = (await response.json()) as OpenAIToolsResponse;
       const choice = data.choices?.[0];
       const msg = choice?.message;
       const toolCalls = (msg?.tool_calls ?? []).map((tc) => {