fix: honor defaultHeaders null for helper method header

src/client.ts

@@ -1032,6 +1032,9 @@ export class OpenAI {
         'X-Stainless-Retry-Count': String(retryCount),
         ...(options.timeout ? { 'X-Stainless-Timeout': String(Math.trunc(options.timeout / 1000)) } : {}),
         ...getPlatformHeaders(),
+        ...(typeof options.__metadata?.helperMethod === 'string' ?
+          { 'X-Stainless-Helper-Method': options.__metadata.helperMethod }
+        : {}),
         'OpenAI-Organization': this.organization,
         'OpenAI-Project': this.project,
       },

src/lib/AssistantStream.ts

@@ -196,7 +196,7 @@ export class AssistantStream
     runner._run(() =>
       runner._runToolAssistantStream(runId, runs, params, {
         ...options,
-        headers: { ...options?.headers, 'X-Stainless-Helper-Method': 'stream' },
+        __metadata: { ...options?.__metadata, helperMethod: 'stream' },
       }),
     );
     return runner;
@@ -241,7 +241,7 @@ export class AssistantStream
     runner._run(() =>
       runner._threadAssistantStream(params, thread, {
         ...options,
-        headers: { ...options?.headers, 'X-Stainless-Helper-Method': 'stream' },
+        __metadata: { ...options?.__metadata, helperMethod: 'stream' },
       }),
     );
     return runner;
@@ -257,7 +257,7 @@ export class AssistantStream
     runner._run(() =>
       runner._runAssistantStream(threadId, runs, params, {
         ...options,
-        headers: { ...options?.headers, 'X-Stainless-Helper-Method': 'stream' },
+        __metadata: { ...options?.__metadata, helperMethod: 'stream' },
       }),
     );
     return runner;

src/lib/ChatCompletionRunner.ts

@@ -35,7 +35,7 @@ export class ChatCompletionRunner<ParsedT = null> extends AbstractChatCompletion
     const runner = new ChatCompletionRunner<ParsedT>();
     const opts = {
       ...options,
-      headers: { ...options?.headers, 'X-Stainless-Helper-Method': 'runTools' },
+      __metadata: { ...options?.__metadata, helperMethod: 'runTools' },
     };
     runner._run(() => runner._runTools(client, params, opts));
     return runner;

src/lib/ChatCompletionStream.ts

@@ -167,7 +167,7 @@ export class ChatCompletionStream<ParsedT = null>
       runner._runChatCompletion(
         client,
         { ...params, stream: true },
-        { ...options, headers: { ...options?.headers, 'X-Stainless-Helper-Method': 'stream' } },
+        { ...options, __metadata: { ...options?.__metadata, helperMethod: 'stream' } },
       ),
     );
     return runner;

src/lib/ChatCompletionStreamingRunner.ts

@@ -42,7 +42,7 @@ export class ChatCompletionStreamingRunner<ParsedT = null>
     );
     const opts = {
       ...options,
-      headers: { ...options?.headers, 'X-Stainless-Helper-Method': 'runTools' },
+      __metadata: { ...options?.__metadata, helperMethod: 'runTools' },
     };
     runner._run(() => runner._runTools(client, params, opts));
     return runner;

src/lib/responses/ResponseStream.ts

@@ -83,7 +83,7 @@ export class ResponseStream<ParsedT = null>
     runner._run(() =>
       runner._createOrRetrieveResponse(client, params, {
         ...options,
-        headers: { ...options?.headers, 'X-Stainless-Helper-Method': 'stream' },
+        __metadata: { ...options?.__metadata, helperMethod: 'stream' },
       }),
     );
     return runner;

src/resources/chat/completions/completions.ts

@@ -153,10 +153,7 @@ export class Completions extends APIResource {
     return this._client.chat.completions
       .create(body, {
         ...options,
-        headers: {
-          ...options?.headers,
-          'X-Stainless-Helper-Method': 'chat.completions.parse',
-        },
+        __metadata: { ...options?.__metadata, helperMethod: 'chat.completions.parse' },
       })
       ._thenUnwrap((completion) => parseChatCompletion(completion, body));
   }

tests/lib/ChatCompletionRunFunctions.test.ts

@@ -18,13 +18,16 @@ function mockChatCompletionFetch() {
   const { fetch, handleRequest: handleRawRequest } = mockFetch();
 
   function handleRequest(
-    handler: (body: ChatCompletionToolRunnerParams<any[]>) => Promise<OpenAI.Chat.ChatCompletion>,
+    handler: (
+      body: ChatCompletionToolRunnerParams<any[]>,
+      init: RequestInit | undefined,
+    ) => Promise<OpenAI.Chat.ChatCompletion>,
   ): Promise<void> {
     return handleRawRequest(async (req, init) => {
       const rawBody = init?.body;
       if (typeof rawBody !== 'string') throw new Error(`expected init.body to be a string`);
       const body: ChatCompletionToolRunnerParams<any[]> = JSON.parse(rawBody);
-      return new Response(JSON.stringify(await handler(body)), {
+      return new Response(JSON.stringify(await handler(body, init)), {
         headers: { 'Content-Type': 'application/json' },
       });
     });
@@ -495,6 +498,47 @@ function _typeTests() {
 
 describe('resource completions', () => {
   describe('runTools with stream: false', () => {
+    test('defaultHeaders can suppress helper method header', async () => {
+      const { fetch, handleRequest } = mockChatCompletionFetch();
+
+      const openai = new OpenAI({
+        apiKey: 'something1234',
+        baseURL: 'http://127.0.0.1:4010',
+        defaultHeaders: { 'x-stainless-helper-method': null },
+        fetch,
+      });
+
+      const runner = openai.chat.completions.runTools({
+        messages: [{ role: 'user', content: 'say hi' }],
+        model: 'gpt-3.5-turbo',
+        tools: [],
+      });
+
+      await handleRequest(async (_request, init) => {
+        expect(new Headers(init?.headers).has('x-stainless-helper-method')).toBe(false);
+        return {
+          id: '1',
+          choices: [
+            {
+              index: 0,
+              finish_reason: 'stop',
+              logprobs: null,
+              message: {
+                role: 'assistant',
+                content: 'hi',
+                refusal: null,
+              },
+            },
+          ],
+          created: Math.floor(Date.now() / 1000),
+          model: 'gpt-3.5-turbo',
+          object: 'chat.completion',
+        };
+      });
+
+      await runner.done();
+    });
+
     test('successful flow', async () => {
       const { fetch, handleRequest } = mockChatCompletionFetch();