Centralize provider adapter assembly with buildProviderAdapter and enforce isEnabled contract (#5205)

* Initial plan

* Add buildProviderAdapter helper; refactor all four provider adapters to use it

* Potential fix for pull request finding 'CodeQL / Unused variable, import, function or class'

Co-authored-by: Copilot Autofix powered by AI <62310815+github-advanced-security[bot]@users.noreply.github.com>

* fix(api-proxy): enforce isEnabled in provider adapter builder

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: Landon Cox <landon.cox@microsoft.com>
Co-authored-by: Copilot Autofix powered by AI <62310815+github-advanced-security[bot]@users.noreply.github.com>

Author: 3 people

containers/api-proxy/adapter-factory.js

@@ -151,7 +151,71 @@ function createAdapterMethods(opts) {
   };
 }
 
+/**
+ * Assemble a provider adapter object from its constituent parts.
+ *
+ * Every provider adapter returns the same outer object shape:
+ *   { name, port, isManagementPort, alwaysBind, getAuthHeaders, getBodyTransform,
+ *     ...adapterMethods, getUnconfiguredResponse?, getUnconfiguredHealthResponse? }
+ *
+ * This helper centralises that boilerplate so each adapter only needs to supply
+ * its provider-specific values and callbacks.  Provider-specific logic (auth
+ * header construction, OIDC plumbing, body transforms, introspection fields, etc.)
+ * is passed in via the `getAuthHeaders`, `bodyTransform`, and `extra` parameters.
+ *
+ * @param {object} opts
+ * @param {string}  opts.name              - Unique provider slug (e.g. 'openai')
+ * @param {number}  opts.port              - Port the adapter listens on
+ * @param {boolean} [opts.isManagementPort=false] - True only for port 10000 (OpenAI)
+ * @param {boolean} [opts.alwaysBind=true] - Start a stub server even when isEnabled() is false
+ * @param {object}  opts.adapterMethods    - Result of createAdapterMethods()
+ * @param {(req?: import('http').IncomingMessage) => Record<string,string>} opts.getAuthHeaders - Auth header factory
+ * @param {((body: Buffer) => Buffer|null)|null} [opts.bodyTransform=null] - Body transform wrapped into getBodyTransform()
+ * @param {(() => boolean)} [opts.isEnabled]                   - Optional isEnabled override (must be provided either here or via `extra`)
+ * @param {((url: string) => string)} [opts.transformRequestUrl] - Optional URL transformer
+ * @param {(() => import('./providers/index').UnconfiguredResponse)} [opts.getUnconfiguredResponse]       - Optional not-configured response
+ * @param {(() => import('./providers/index').UnconfiguredResponse)} [opts.getUnconfiguredHealthResponse] - Optional not-configured /health response
+ * @param {object} [opts.extra={}]         - Extra fields spread into the returned object last (e.g. OIDC runtime methods, introspection fields, overrides)
+ * @returns {import('./providers/index').ProviderAdapter}
+ */
+function buildProviderAdapter({
+  name,
+  port,
+  isManagementPort = false,
+  alwaysBind = true,
+  adapterMethods,
+  getAuthHeaders,
+  bodyTransform = null,
+  isEnabled,
+  transformRequestUrl,
+  getUnconfiguredResponse,
+  getUnconfiguredHealthResponse,
+  extra = {},
+}) {
+  const adapter = {
+    name,
+    port,
+    isManagementPort,
+    alwaysBind,
+    ...(isEnabled !== undefined ? { isEnabled } : {}),
+    getAuthHeaders,
+    ...(transformRequestUrl !== undefined ? { transformRequestUrl } : {}),
+    getBodyTransform() { return bodyTransform; },
+    ...adapterMethods,
+    ...(getUnconfiguredResponse !== undefined ? { getUnconfiguredResponse } : {}),
+    ...(getUnconfiguredHealthResponse !== undefined ? { getUnconfiguredHealthResponse } : {}),
+    ...extra,
+  };
+
+  if (typeof adapter.isEnabled !== 'function') {
+    throw new TypeError(`Provider adapter "${name}" must define an isEnabled() function`);
+  }
+
+  return adapter;
+}
+
 module.exports = {
   createBaseAdapterConfig,
   createAdapterMethods,
+  buildProviderAdapter,
 };

containers/api-proxy/adapter-factory.test.js

@@ -0,0 +1,287 @@
+'use strict';
+
+const { buildProviderAdapter } = require('./adapter-factory');
+
+describe('buildProviderAdapter', () => {
+  function makeAdapterMethods(overrides = {}) {
+    return {
+      getTargetHost() { return 'api.example.com'; },
+      getBasePath() { return ''; },
+      participatesInValidation: true,
+      getValidationProbe() { return null; },
+      getModelsFetchConfig() { return null; },
+      getReflectionInfo() { return { provider: 'test', port: 10099 }; },
+      ...overrides,
+    };
+  }
+
+  describe('required fields', () => {
+    it('sets name, port, isManagementPort, alwaysBind from opts', () => {
+      const adapter = buildProviderAdapter({
+        name: 'test',
+        port: 10099,
+        isManagementPort: true,
+        alwaysBind: false,
+        adapterMethods: makeAdapterMethods(),
+        getAuthHeaders() { return {}; },
+        isEnabled() { return true; },
+      });
+      expect(adapter.name).toBe('test');
+      expect(adapter.port).toBe(10099);
+      expect(adapter.isManagementPort).toBe(true);
+      expect(adapter.alwaysBind).toBe(false);
+    });
+
+    it('defaults isManagementPort to false and alwaysBind to true', () => {
+      const adapter = buildProviderAdapter({
+        name: 'test',
+        port: 10099,
+        adapterMethods: makeAdapterMethods(),
+        getAuthHeaders() { return {}; },
+        isEnabled() { return true; },
+      });
+      expect(adapter.isManagementPort).toBe(false);
+      expect(adapter.alwaysBind).toBe(true);
+    });
+
+    it('includes getAuthHeaders from opts', () => {
+      const getAuthHeaders = () => ({ 'x-test-key': 'val' });
+      const adapter = buildProviderAdapter({
+        name: 'test',
+        port: 10099,
+        adapterMethods: makeAdapterMethods(),
+        getAuthHeaders,
+        isEnabled() { return true; },
+      });
+      expect(adapter.getAuthHeaders).toBe(getAuthHeaders);
+      expect(adapter.getAuthHeaders()).toEqual({ 'x-test-key': 'val' });
+    });
+
+    it('spreads all adapterMethods into the returned object', () => {
+      const adapterMethods = makeAdapterMethods({ participatesInValidation: false });
+      const adapter = buildProviderAdapter({
+        name: 'test',
+        port: 10099,
+        adapterMethods,
+        getAuthHeaders() { return {}; },
+        isEnabled() { return true; },
+      });
+      expect(adapter.getTargetHost).toBe(adapterMethods.getTargetHost);
+      expect(adapter.getBasePath).toBe(adapterMethods.getBasePath);
+      expect(adapter.participatesInValidation).toBe(false);
+      expect(adapter.getValidationProbe).toBe(adapterMethods.getValidationProbe);
+      expect(adapter.getModelsFetchConfig).toBe(adapterMethods.getModelsFetchConfig);
+      expect(adapter.getReflectionInfo).toBe(adapterMethods.getReflectionInfo);
+    });
+  });
+
+  describe('getBodyTransform', () => {
+    it('wraps bodyTransform in getBodyTransform()', () => {
+      const transform = (body) => body;
+      const adapter = buildProviderAdapter({
+        name: 'test',
+        port: 10099,
+        adapterMethods: makeAdapterMethods(),
+        getAuthHeaders() { return {}; },
+        isEnabled() { return true; },
+        bodyTransform: transform,
+      });
+      expect(adapter.getBodyTransform()).toBe(transform);
+    });
+
+    it('defaults bodyTransform to null', () => {
+      const adapter = buildProviderAdapter({
+        name: 'test',
+        port: 10099,
+        adapterMethods: makeAdapterMethods(),
+        getAuthHeaders() { return {}; },
+        isEnabled() { return true; },
+      });
+      expect(adapter.getBodyTransform()).toBeNull();
+    });
+  });
+
+  describe('optional methods', () => {
+    it('throws when isEnabled is not provided', () => {
+      expect(() => buildProviderAdapter({
+        name: 'test',
+        port: 10099,
+        adapterMethods: makeAdapterMethods(),
+        getAuthHeaders() { return {}; },
+      })).toThrow('must define an isEnabled() function');
+    });
+
+    it('includes isEnabled when provided', () => {
+      const isEnabled = () => true;
+      const adapter = buildProviderAdapter({
+        name: 'test',
+        port: 10099,
+        adapterMethods: makeAdapterMethods(),
+        getAuthHeaders() { return {}; },
+        isEnabled,
+      });
+      expect(adapter.isEnabled).toBe(isEnabled);
+      expect(adapter.isEnabled()).toBe(true);
+    });
+
+    it('accepts isEnabled provided via extra', () => {
+      const adapter = buildProviderAdapter({
+        name: 'test',
+        port: 10099,
+        adapterMethods: makeAdapterMethods(),
+        getAuthHeaders() { return {}; },
+        extra: {
+          isEnabled() { return true; },
+        },
+      });
+      expect(adapter.isEnabled()).toBe(true);
+    });
+
+    it('omits transformRequestUrl when not provided', () => {
+      const adapter = buildProviderAdapter({
+        name: 'test',
+        port: 10099,
+        adapterMethods: makeAdapterMethods(),
+        getAuthHeaders() { return {}; },
+        isEnabled() { return true; },
+      });
+      expect('transformRequestUrl' in adapter).toBe(false);
+    });
+
+    it('includes transformRequestUrl when provided', () => {
+      const transformRequestUrl = (url) => url + '?transformed=1';
+      const adapter = buildProviderAdapter({
+        name: 'test',
+        port: 10099,
+        adapterMethods: makeAdapterMethods(),
+        getAuthHeaders() { return {}; },
+        isEnabled() { return true; },
+        transformRequestUrl,
+      });
+      expect(adapter.transformRequestUrl).toBe(transformRequestUrl);
+    });
+
+    it('omits getUnconfiguredResponse when not provided', () => {
+      const adapter = buildProviderAdapter({
+        name: 'test',
+        port: 10099,
+        adapterMethods: makeAdapterMethods(),
+        getAuthHeaders() { return {}; },
+        isEnabled() { return true; },
+      });
+      expect('getUnconfiguredResponse' in adapter).toBe(false);
+    });
+
+    it('includes getUnconfiguredResponse when provided', () => {
+      const getUnconfiguredResponse = () => ({ statusCode: 503, body: { error: 'not configured' } });
+      const adapter = buildProviderAdapter({
+        name: 'test',
+        port: 10099,
+        adapterMethods: makeAdapterMethods(),
+        getAuthHeaders() { return {}; },
+        isEnabled() { return true; },
+        getUnconfiguredResponse,
+      });
+      expect(adapter.getUnconfiguredResponse).toBe(getUnconfiguredResponse);
+    });
+
+    it('omits getUnconfiguredHealthResponse when not provided', () => {
+      const adapter = buildProviderAdapter({
+        name: 'test',
+        port: 10099,
+        adapterMethods: makeAdapterMethods(),
+        getAuthHeaders() { return {}; },
+        isEnabled() { return true; },
+      });
+      expect('getUnconfiguredHealthResponse' in adapter).toBe(false);
+    });
+
+    it('includes getUnconfiguredHealthResponse when provided', () => {
+      const getUnconfiguredHealthResponse = () => ({ statusCode: 503, body: { status: 'down' } });
+      const adapter = buildProviderAdapter({
+        name: 'test',
+        port: 10099,
+        adapterMethods: makeAdapterMethods(),
+        getAuthHeaders() { return {}; },
+        isEnabled() { return true; },
+        getUnconfiguredHealthResponse,
+      });
+      expect(adapter.getUnconfiguredHealthResponse).toBe(getUnconfiguredHealthResponse);
+    });
+  });
+
+  describe('extra fields', () => {
+    it('spreads extra fields into the returned object after adapterMethods', () => {
+      const adapter = buildProviderAdapter({
+        name: 'test',
+        port: 10099,
+        adapterMethods: makeAdapterMethods({ participatesInValidation: false }),
+        getAuthHeaders() { return {}; },
+        isEnabled() { return true; },
+        extra: {
+          participatesInValidation: true,  // override from adapterMethods
+          _customField: 'hello',
+          getOidcProvider() { return null; },
+        },
+      });
+      expect(adapter.participatesInValidation).toBe(true);
+      expect(adapter._customField).toBe('hello');
+      expect(adapter.getOidcProvider()).toBeNull();
+    });
+
+    it('defaults extra to empty object when not provided', () => {
+      expect(() => buildProviderAdapter({
+        name: 'test',
+        port: 10099,
+        adapterMethods: makeAdapterMethods(),
+        getAuthHeaders() { return {}; },
+        isEnabled() { return true; },
+      })).not.toThrow();
+    });
+  });
+
+  describe('integration with createAdapterMethods', () => {
+    it('correctly wires up a complete minimal adapter', () => {
+      const { createBaseAdapterConfig, createAdapterMethods } = require('./adapter-factory');
+      const env = { MY_API_KEY: 'test-key' };
+      const { apiKey, rawTarget, basePath } = createBaseAdapterConfig(env, {
+        keyEnvVar: 'MY_API_KEY',
+        targetEnvVar: 'MY_API_TARGET',
+        basePathEnvVar: 'MY_API_BASE_PATH',
+        defaultTarget: 'api.example.com',
+      });
+      const adapterMethods = createAdapterMethods({
+        apiKey,
+        rawTarget,
+        basePath,
+        provider: 'test',
+        port: 10099,
+        modelsPath: '/v1/models',
+        validationPath: '/v1/models',
+        validationHeaders: () => ({ 'Authorization': '******' }),
+      });
+
+      const adapter = buildProviderAdapter({
+        name: 'test',
+        port: 10099,
+        adapterMethods,
+        getAuthHeaders() { return { 'Authorization': '******' }; },
+        isEnabled() { return !!apiKey; },
+        getUnconfiguredResponse() {
+          return { statusCode: 503, body: { error: 'not configured' } };
+        },
+      });
+
+      expect(adapter.name).toBe('test');
+      expect(adapter.port).toBe(10099);
+      expect(adapter.isManagementPort).toBe(false);
+      expect(adapter.alwaysBind).toBe(true);
+      expect(adapter.isEnabled()).toBe(true);
+      expect(adapter.getAuthHeaders()).toEqual({ 'Authorization': '******' });
+      expect(adapter.getBodyTransform()).toBeNull();
+      expect(adapter.getTargetHost()).toBe('api.example.com');
+      expect(adapter.getBasePath()).toBe('');
+      expect(adapter.getUnconfiguredResponse()).toEqual({ statusCode: 503, body: { error: 'not configured' } });
+    });
+  });
+});