Merge pull request #89 from ndycode/fix/max-output-tokens

fix: preserve max_output_tokens in transformed requests

Author: ndycode

lib/request/request-transformer.ts

@@ -1118,8 +1118,12 @@ export async function transformRequestBody(
 	// This allows reasoning context to persist across turns without server-side storage
 	body.include = resolveInclude(modelConfig, body);
 
-	// Remove unsupported parameters
-	body.max_output_tokens = undefined;
+	// Preserve caller-supplied max_output_tokens from the in-memory request body.
+	// max_output_tokens is a numeric budget, not a credential, so no redaction is required.
+	// Windows filesystem: no file I/O occurs here; no concurrency risk is introduced.
+	// Regression: "should preserve max_output_tokens while removing max_completion_tokens"
+	// in test/request-transformer.test.ts.
+	// Remove unsupported parameters.
 	body.max_completion_tokens = undefined;
 
 	return body;

test/property/transformer.property.test.ts

@@ -4,8 +4,9 @@ import {
   normalizeModel,
   filterInput,
   getReasoningConfig,
+  transformRequestBody,
 } from "../../lib/request/request-transformer.js";
-import type { InputItem } from "../../lib/types.js";
+import type { InputItem, RequestBody } from "../../lib/types.js";
 import { arbModel, arbMessageRole } from "./helpers.js";
 
 describe("normalizeModel property tests", () => {
@@ -216,44 +217,43 @@ describe("getReasoningConfig property tests", () => {
     );
   });
 
-	  it("codex models upgrade none to low", () => {
-	    fc.assert(
-	      fc.property(
-	        fc.constantFrom(
-	          "gpt-5.1-codex",
-	          "gpt-5.2-codex",
-	          "gpt-5.3-codex",
-	          "gpt-5.1-codex-max",
-	        ),
-	        (model) => {
-	          const result = getReasoningConfig(model, { reasoningEffort: "none" });
-	          expect(result.effort).toBe("low");
+  it("codex models upgrade none to low", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(
+          "gpt-5.1-codex",
+          "gpt-5.2-codex",
+          "gpt-5.3-codex",
+          "gpt-5.1-codex-max",
+        ),
+        (model) => {
+          const result = getReasoningConfig(model, { reasoningEffort: "none" });
+          expect(result.effort).toBe("low");
           return true;
         }
       )
     );
   });
 
-	  it("gpt-5.4-pro upgrades none to medium (none→low→medium chain)", () => {
-	    fc.assert(
-	      fc.property(fc.constant("gpt-5.4-pro"), (model) => {
-	        const result = getReasoningConfig(model, { reasoningEffort: "none" });
-	        expect(result.effort).toBe("medium");
-	        return true;
-	      })
-	    );
+  it("gpt-5.4-pro upgrades none to medium (none→low→medium chain)", () => {
+    fc.assert(
+      fc.property(fc.constant("gpt-5.4-pro"), (model) => {
+        const result = getReasoningConfig(model, { reasoningEffort: "none" });
+        expect(result.effort).toBe("medium");
+        return true;
+      })
+    );
   });
 
-	  it("gpt-5.4-pro upgrades minimal to medium", () => {
-	    fc.assert(
-	      fc.property(fc.constant("gpt-5.4-pro"), (model) => {
-	        const result = getReasoningConfig(model, { reasoningEffort: "minimal" });
-	        expect(result.effort).toBe("medium");
-	        return true;
-	      })
-	    );
-	  });
-
+  it("gpt-5.4-pro upgrades minimal to medium", () => {
+    fc.assert(
+      fc.property(fc.constant("gpt-5.4-pro"), (model) => {
+        const result = getReasoningConfig(model, { reasoningEffort: "minimal" });
+        expect(result.effort).toBe("medium");
+        return true;
+      })
+    );
+  });
   it("gpt-5.1, gpt-5.2, and gpt-5.4 general support none effort", () => {
     fc.assert(
       fc.property(
@@ -273,3 +273,25 @@ describe("getReasoningConfig property tests", () => {
     expect(result.summary).toBeDefined();
   });
 });
+
+describe("transformRequestBody property tests", () => {
+  it("preserves max_output_tokens across arbitrary positive integers", async () => {
+    await fc.assert(
+      fc.asyncProperty(
+        fc.constantFrom("gpt-5", "gpt-5.4-pro", "gpt-5.1-codex"),
+        fc.integer({ min: 1, max: 1_000_000 }),
+        async (model, maxOutputTokens) => {
+          const body: RequestBody = {
+            model,
+            input: [],
+            max_output_tokens: maxOutputTokens,
+          };
+
+          const result = await transformRequestBody(body, "Test Codex Instructions");
+          expect(result.max_output_tokens).toBe(maxOutputTokens);
+          expect(result.max_completion_tokens).toBeUndefined();
+          return true;
+        })
+    );
+  });
+});

test/request-transformer.test.ts

@@ -1483,14 +1483,24 @@ describe('Request Transformer Module', () => {
 			expect(result.input![0].role).toBe('user');
 		});
 
-		it('should remove unsupported parameters', async () => {
+		it('should preserve max_output_tokens while removing max_completion_tokens', async () => {
 			const body: RequestBody = {
 				model: 'gpt-5',
 				input: [],
 				max_output_tokens: 1000,
 				max_completion_tokens: 2000,
 			};
 			const result = await transformRequestBody(body, codexInstructions);
+			expect(result.max_output_tokens).toBe(1000);
+			expect(result.max_completion_tokens).toBeUndefined();
+		});
+
+		it('should leave max_output_tokens unset when not provided', async () => {
+			const body: RequestBody = {
+				model: 'gpt-5',
+				input: [],
+			};
+			const result = await transformRequestBody(body, codexInstructions);
 			expect(result.max_output_tokens).toBeUndefined();
 			expect(result.max_completion_tokens).toBeUndefined();
 		});