fix: normalize null copilot tool call types

Author: Copilot

containers/api-proxy/providers/copilot.js

@@ -14,7 +14,7 @@
  * accepts OAuth tokens, not API keys.
  */
 
-const { normalizeApiTarget, normalizeBasePath, createAdapterMethods } = require('../proxy-utils');
+const { normalizeApiTarget, normalizeBasePath, createAdapterMethods, composeBodyTransforms } = require('../proxy-utils');
 const { URL } = require('url');
 
 /**
@@ -137,6 +137,51 @@ function deriveGitHubApiBasePath(env = process.env) {
   }
 }
 
+/**
+ * Normalize OpenAI-style tool calls that omit the required type field.
+ *
+ * Some Copilot/OpenAI-compatible responses can echo tool_calls entries with a
+ * null/undefined `type`, which later causes upstream validation failures when
+ * the same message history is sent back. This transform patches only
+ * function-style tool calls by setting `type: "function"`.
+ *
+ * @param {Buffer} body - Raw request body
+ * @returns {Buffer|null} Updated body or null when no changes are needed
+ */
+function normalizeNullTypeToolCalls(body) {
+  let parsed;
+  try {
+    parsed = JSON.parse(body.toString('utf8'));
+  } catch {
+    return null;
+  }
+
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed) || !Array.isArray(parsed.messages)) {
+    return null;
+  }
+
+  let changed = false;
+  for (const message of parsed.messages) {
+    if (!message || typeof message !== 'object' || Array.isArray(message) || !Array.isArray(message.tool_calls)) {
+      continue;
+    }
+
+    for (const toolCall of message.tool_calls) {
+      if (!toolCall || typeof toolCall !== 'object' || Array.isArray(toolCall)) continue;
+      const hasFunctionPayload =
+        toolCall.function &&
+        typeof toolCall.function === 'object' &&
+        !Array.isArray(toolCall.function);
+      if (toolCall.type == null && hasFunctionPayload) {
+        toolCall.type = 'function';
+        changed = true;
+      }
+    }
+  }
+
+  return changed ? Buffer.from(JSON.stringify(parsed)) : null;
+}
+
 /**
  * Create the GitHub Copilot provider adapter.
  *
@@ -152,7 +197,10 @@ function createCopilotAdapter(env, deps = {}) {
   const rawTarget = deriveCopilotApiTarget(env);
   const basePath = normalizeBasePath(env.COPILOT_API_BASE_PATH);
 
-  const bodyTransform = deps.bodyTransform || null;
+  const bodyTransform = composeBodyTransforms(
+    deps.bodyTransform || null,
+    normalizeNullTypeToolCalls
+  );
 
   // Pre-computed models path used by getModelsFetchConfig and getReflectionInfo.
   // For BYOK/custom providers the base path prefix is included (e.g. /api/v1/models
@@ -334,5 +382,6 @@ module.exports = {
     deriveCopilotApiTarget,
     deriveGitHubApiTarget,
     deriveGitHubApiBasePath,
+    normalizeNullTypeToolCalls,
   },
 };

containers/api-proxy/server.auth.test.js

@@ -5,7 +5,10 @@
  */
 
 const { shouldStripHeader } = require('./proxy-utils');
-const { _testing: { resolveCopilotAuthToken, stripBearerPrefix }, createCopilotAdapter } = require('./providers/copilot');
+const {
+  _testing: { resolveCopilotAuthToken, stripBearerPrefix, normalizeNullTypeToolCalls },
+  createCopilotAdapter,
+} = require('./providers/copilot');
 
 describe('shouldStripHeader', () => {
   it('should strip authorization header', () => {
@@ -135,6 +138,50 @@ describe('resolveCopilotAuthToken', () => {
   });
 });
 
+describe('normalizeNullTypeToolCalls', () => {
+  it('normalizes null tool_call type to "function" in outgoing message history', () => {
+    const input = Buffer.from(JSON.stringify({
+      model: 'gpt-5.4',
+      messages: [
+        {
+          role: 'assistant',
+          tool_calls: [
+            {
+              id: 'call_1',
+              type: null,
+              function: { name: 'edit', arguments: '{"path":"a.txt"}' },
+            },
+          ],
+        },
+      ],
+    }));
+
+    const transformed = normalizeNullTypeToolCalls(input);
+    expect(transformed).not.toBeNull();
+    const parsed = JSON.parse(transformed.toString('utf8'));
+    expect(parsed.messages[0].tool_calls[0].type).toBe('function');
+  });
+
+  it('returns null when no tool_call type normalization is needed', () => {
+    const input = Buffer.from(JSON.stringify({
+      messages: [
+        {
+          role: 'assistant',
+          tool_calls: [
+            {
+              id: 'call_1',
+              type: 'function',
+              function: { name: 'edit', arguments: '{}' },
+            },
+          ],
+        },
+      ],
+    }));
+
+    expect(normalizeNullTypeToolCalls(input)).toBeNull();
+  });
+});
+
 // ── createCopilotAdapter — BYOK auth header format ───────────────────────────
 //
 // These tests guard against the "badly formatted Authorization header" bug in

containers/api-proxy/server.lifecycle.test.js

@@ -416,6 +416,60 @@ describe('createProviderServer', () => {
     expect(authErrLog.message).toContain('400');
   });
 
+  it('normalizes null tool_call type before forwarding when upstream returns 400', async () => {
+    const { lines, spy } = collectLogOutput();
+    let writtenBody = null;
+    jest.spyOn(https, 'request').mockImplementation((options, callback) => {
+      const proxyReq = new EventEmitter();
+      proxyReq.write = jest.fn((chunk) => {
+        writtenBody = Buffer.isBuffer(chunk) ? chunk.toString('utf8') : String(chunk);
+      });
+      proxyReq.end = jest.fn(() => {
+        setImmediate(() => {
+          const proxyRes = new EventEmitter();
+          proxyRes.statusCode = 400;
+          proxyRes.headers = { 'content-type': 'application/json' };
+          proxyRes.pipe = jest.fn((destRes) => { destRes.end('{}'); });
+          callback(proxyRes);
+          setImmediate(() => proxyRes.emit('end'));
+        });
+      });
+      proxyReq.destroy = jest.fn();
+      return proxyReq;
+    });
+
+    const adapter = createCopilotAdapter({ COPILOT_API_KEY: 'sk-test' });
+    const port = await startAdapter(adapter);
+    const body = {
+      model: 'gpt-5.4',
+      messages: [
+        {
+          role: 'assistant',
+          tool_calls: [
+            {
+              id: 'call_1',
+              type: null,
+              function: { name: 'edit', arguments: '{"path":"README.md"}' },
+            },
+          ],
+        },
+      ],
+    };
+    await fetch(port, '/v1/chat/completions', {
+      method: 'POST',
+      body: JSON.stringify(body),
+      headers: { 'content-type': 'application/json' },
+    });
+
+    jest.restoreAllMocks();
+    spy.mockRestore();
+
+    const forwarded = JSON.parse(writtenBody);
+    expect(forwarded.messages[0].tool_calls[0].type).toBe('function');
+    const authErrLog = lines.find(l => l.event === 'upstream_auth_error' && l.status === 400);
+    expect(authErrLog).toBeDefined();
+  });
+
   it('emits upstream_auth_error when upstream returns 401', async () => {
     const { lines, spy } = collectLogOutput();
     mockHttpsWithStatus(401);