@startsimpli/llm 0.4.20 → 0.4.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@startsimpli/llm",
-  "version": "0.4.20",
+  "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

@@ -144,6 +144,21 @@ describe('adapting to what a model refuses', () => {
     expect(sent).toHaveLength(3);
   });
 
+  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." });

package/src/providers/openai.ts

@@ -270,20 +270,27 @@ export class OpenAIProvider implements ILLMProvider {
   ): 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: JSON.stringify(build(q)),
+        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 && learnFromError(q, errorData.error, sent)) continue;
+      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);
     }
   }