feat (providers/gateway): include deployment and request id (#6591)

## Background

For o11y it is useful to have a developer's deployment and request id.
The deployment id variable name was incorrect, and we don't yet include
logic to look up the request id.

## Summary

Corrected the environment variable name to look up the deployment id,
and added logic to look for the request id in the headers as
`x-vercel-id`.

## Verification

Added verbose logging and deployed to a preview deployment to observe
correct data being logged.

## Tasks

- [x] Tests have been added / updated (for bug fixes / features)
- [ ] Documentation has been added / updated (for bug fixes / features)
- [x] A _patch_ changeset for relevant packages has been added (for bug
fixes / features - run `pnpm changeset` in the project root)
- [x] Formatting issues have been fixed (run `pnpm prettier-fix` in the
project root)

Author: shaper

.changeset/chilly-chairs-press.md

@@ -0,0 +1,5 @@
+---
+'@ai-sdk/gateway': patch
+---
+
+feat (providers/gateway): include deployment and request id

packages/gateway/src/gateway-language-model.ts

@@ -12,6 +12,7 @@ import {
   postJsonToApi,
   resolve,
   type ParseResult,
+  type Resolvable,
 } from '@ai-sdk/provider-utils';
 import { z } from 'zod';
 import type { GatewayConfig } from './gateway-config';
@@ -20,7 +21,7 @@ import { asGatewayError } from './errors';
 
 type GatewayChatConfig = GatewayConfig & {
   provider: string;
-  o11yHeaders: Record<string, string>;
+  o11yHeaders: Resolvable<Record<string, string>>;
 };
 
 export class GatewayLanguageModel implements LanguageModelV2 {
@@ -51,7 +52,7 @@ export class GatewayLanguageModel implements LanguageModelV2 {
           await resolve(this.config.headers()),
           options.headers,
           this.getModelConfigHeaders(this.modelId, false),
-          this.config.o11yHeaders,
+          await resolve(this.config.o11yHeaders),
         ),
         body: this.maybeEncodeFileParts(body),
         successfulResponseHandler: createJsonResponseHandler(z.any()),
@@ -86,7 +87,7 @@ export class GatewayLanguageModel implements LanguageModelV2 {
           await resolve(this.config.headers()),
           options.headers,
           this.getModelConfigHeaders(this.modelId, true),
-          this.config.o11yHeaders,
+          await resolve(this.config.o11yHeaders),
         ),
         body: this.maybeEncodeFileParts(body),
         successfulResponseHandler: createEventSourceResponseHandler(z.any()),

packages/gateway/src/gateway-provider.test.ts

@@ -6,7 +6,7 @@ import {
 } from './gateway-provider';
 import { GatewayFetchMetadata } from './gateway-fetch-metadata';
 import { NoSuchModelError } from '@ai-sdk/provider';
-import { getVercelOidcToken } from './get-vercel-oidc-token';
+import { getVercelOidcToken, getVercelRequestId } from './vercel-environment';
 import { resolve } from '@ai-sdk/provider-utils';
 import { GatewayLanguageModel } from './gateway-language-model';
 import {
@@ -23,14 +23,16 @@ vi.mock('./gateway-fetch-metadata', () => ({
   GatewayFetchMetadata: vi.fn(),
 }));
 
-vi.mock('./get-vercel-oidc-token', () => ({
+vi.mock('./vercel-environment', () => ({
   getVercelOidcToken: vi.fn(),
+  getVercelRequestId: vi.fn(),
 }));
 
 describe('GatewayProvider', () => {
   beforeEach(() => {
     vi.clearAllMocks();
     vi.mocked(getVercelOidcToken).mockResolvedValue('mock-oidc-token');
+    vi.mocked(getVercelRequestId).mockResolvedValue('mock-request-id');
     if ('AI_GATEWAY_API_KEY' in process.env) {
       Reflect.deleteProperty(process.env, 'AI_GATEWAY_API_KEY');
     }
@@ -76,7 +78,7 @@ describe('GatewayProvider', () => {
       };
 
       const provider = createGatewayProvider(options);
-      await provider('test-model');
+      provider('test-model');
 
       const constructorCall = vi.mocked(GatewayLanguageModel).mock.calls[0];
       const config = constructorCall[1];
@@ -218,10 +220,11 @@ describe('GatewayProvider', () => {
       const originalEnv = process.env;
       process.env = {
         ...originalEnv,
-        DEPLOYMENT_ID: 'test-deployment',
+        VERCEL_DEPLOYMENT_ID: 'test-deployment',
         VERCEL_ENV: 'test',
         VERCEL_REGION: 'iad1',
       };
+      vi.mocked(getVercelRequestId).mockResolvedValue('test-request-id');
 
       try {
         const provider = createGatewayProvider({
@@ -230,18 +233,25 @@ describe('GatewayProvider', () => {
         });
         provider('test-model');
 
-        expect(GatewayLanguageModel).toHaveBeenCalledWith(
-          'test-model',
+        const constructorCall = vi.mocked(GatewayLanguageModel).mock.calls[0];
+        const config = constructorCall[1];
+
+        expect(config).toEqual(
           expect.objectContaining({
             provider: 'gateway',
             baseURL: 'https://api.example.com',
-            o11yHeaders: {
-              'ai-o11y-deployment-id': 'test-deployment',
-              'ai-o11y-environment': 'test',
-              'ai-o11y-region': 'iad1',
-            },
+            o11yHeaders: expect.any(Function),
           }),
         );
+
+        // Test that the o11yHeaders function returns the expected result
+        const o11yHeaders = await resolve(config.o11yHeaders);
+        expect(o11yHeaders).toEqual({
+          'ai-o11y-deployment-id': 'test-deployment',
+          'ai-o11y-environment': 'test',
+          'ai-o11y-region': 'iad1',
+          'ai-o11y-request-id': 'test-request-id',
+        });
       } finally {
         process.env = originalEnv;
       }
@@ -254,21 +264,30 @@ describe('GatewayProvider', () => {
       process.env.VERCEL_ENV = undefined;
       process.env.VERCEL_REGION = undefined;
 
+      vi.mocked(getVercelRequestId).mockResolvedValue(undefined);
+
       try {
         const provider = createGatewayProvider({
           baseURL: 'https://api.example.com',
           apiKey: 'test-api-key',
         });
         provider('test-model');
 
-        expect(GatewayLanguageModel).toHaveBeenCalledWith(
-          'test-model',
+        // Get the constructor call to check o11yHeaders
+        const constructorCall = vi.mocked(GatewayLanguageModel).mock.calls[0];
+        const config = constructorCall[1];
+
+        expect(config).toEqual(
           expect.objectContaining({
             provider: 'gateway',
             baseURL: 'https://api.example.com',
-            o11yHeaders: {},
+            o11yHeaders: expect.any(Function),
           }),
         );
+
+        // Test that the o11yHeaders function returns empty object
+        const o11yHeaders = await resolve(config.o11yHeaders);
+        expect(o11yHeaders).toEqual({});
       } finally {
         process.env = originalEnv;
       }
@@ -650,7 +669,7 @@ describe('GatewayProvider', () => {
           baseURL: 'https://api.example.com',
           headers: expect.any(Function),
           fetch: undefined,
-          o11yHeaders: expect.any(Object),
+          o11yHeaders: expect.any(Function),
         }),
       );
     });
@@ -701,7 +720,7 @@ describe('GatewayProvider', () => {
           baseURL: 'https://api.example.com',
           headers: expect.any(Function),
           fetch: undefined,
-          o11yHeaders: expect.any(Object),
+          o11yHeaders: expect.any(Function),
         }),
       );
 
@@ -725,7 +744,7 @@ describe('GatewayProvider', () => {
           baseURL: 'https://api.example.com',
           headers: expect.any(Function),
           fetch: undefined,
-          o11yHeaders: expect.any(Object),
+          o11yHeaders: expect.any(Function),
         }),
       );
 

packages/gateway/src/gateway-provider.ts

@@ -12,7 +12,7 @@ import {
 } from './gateway-fetch-metadata';
 import { GatewayLanguageModel } from './gateway-language-model';
 import type { GatewayModelId } from './gateway-language-model-settings';
-import { getVercelOidcToken } from './get-vercel-oidc-token';
+import { getVercelOidcToken, getVercelRequestId } from './vercel-environment';
 
 export interface GatewayProvider extends ProviderV2 {
   (modelId: GatewayModelId): LanguageModelV2;
@@ -101,7 +101,7 @@ export function createGatewayProvider(
   const createLanguageModel = (modelId: GatewayModelId) => {
     const deploymentId = loadOptionalSetting({
       settingValue: undefined,
-      environmentVariableName: 'DEPLOYMENT_ID',
+      environmentVariableName: 'VERCEL_DEPLOYMENT_ID',
     });
     const environment = loadOptionalSetting({
       settingValue: undefined,
@@ -116,10 +116,14 @@ export function createGatewayProvider(
       baseURL,
       headers: getHeaders,
       fetch: options.fetch,
-      o11yHeaders: {
-        ...(deploymentId && { 'ai-o11y-deployment-id': deploymentId }),
-        ...(environment && { 'ai-o11y-environment': environment }),
-        ...(region && { 'ai-o11y-region': region }),
+      o11yHeaders: async () => {
+        const requestId = await getVercelRequestId();
+        return {
+          ...(deploymentId && { 'ai-o11y-deployment-id': deploymentId }),
+          ...(environment && { 'ai-o11y-environment': environment }),
+          ...(region && { 'ai-o11y-region': region }),
+          ...(requestId && { 'ai-o11y-request-id': requestId }),
+        };
       },
     });
   };

packages/gateway/src/get-vercel-oidc-token.test.ts renamed to packages/gateway/src/vercel-environment.test.ts

@@ -1,6 +1,5 @@
 import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { getVercelOidcToken } from './get-vercel-oidc-token';
-import { GatewayAuthenticationError } from './errors';
+import { getVercelOidcToken, getVercelRequestId } from './vercel-environment';
 
 const SYMBOL_FOR_REQ_CONTEXT = Symbol.for('@vercel/request-context');
 
@@ -91,3 +90,64 @@ describe('getVercelOidcToken', () => {
     expect(token).toBe('env-token-value');
   });
 });
+
+describe('getVercelRequestId', () => {
+  const originalSymbolValue = (globalThis as any)[SYMBOL_FOR_REQ_CONTEXT];
+
+  beforeEach(() => {
+    (globalThis as any)[SYMBOL_FOR_REQ_CONTEXT] = undefined;
+  });
+
+  afterEach(() => {
+    if (originalSymbolValue) {
+      (globalThis as any)[SYMBOL_FOR_REQ_CONTEXT] = originalSymbolValue;
+    } else {
+      (globalThis as any)[SYMBOL_FOR_REQ_CONTEXT] = undefined;
+    }
+  });
+
+  it('should get request ID from request headers when available', async () => {
+    (globalThis as any)[SYMBOL_FOR_REQ_CONTEXT] = {
+      get: () => ({
+        headers: {
+          'x-vercel-id': 'req_1234567890abcdef',
+        },
+      }),
+    };
+
+    const requestId = await getVercelRequestId();
+    expect(requestId).toBe('req_1234567890abcdef');
+  });
+
+  it('should return undefined when request ID header is not available', async () => {
+    (globalThis as any)[SYMBOL_FOR_REQ_CONTEXT] = {
+      get: () => ({ headers: {} }),
+    };
+
+    const requestId = await getVercelRequestId();
+    expect(requestId).toBeUndefined();
+  });
+
+  it('should return undefined when no headers are available', async () => {
+    (globalThis as any)[SYMBOL_FOR_REQ_CONTEXT] = {
+      get: () => ({}),
+    };
+
+    const requestId = await getVercelRequestId();
+    expect(requestId).toBeUndefined();
+  });
+
+  it('should handle missing request context gracefully', async () => {
+    (globalThis as any)[SYMBOL_FOR_REQ_CONTEXT] = undefined;
+
+    const requestId = await getVercelRequestId();
+    expect(requestId).toBeUndefined();
+  });
+
+  it('should handle missing get method in request context', async () => {
+    (globalThis as any)[SYMBOL_FOR_REQ_CONTEXT] = {};
+
+    const requestId = await getVercelRequestId();
+    expect(requestId).toBeUndefined();
+  });
+});

packages/gateway/src/get-vercel-oidc-token.ts renamed to packages/gateway/src/vercel-environment.ts

@@ -20,6 +20,10 @@ The token is expected to be provided via the 'VERCEL_OIDC_TOKEN' environment var
   return token;
 }
 
+export async function getVercelRequestId(): Promise<string | undefined> {
+  return getContext().headers?.['x-vercel-id'];
+}
+
 type Context = {
   headers?: Record<string, string>;
 };