ai 6.0.33 → 6.0.34

package/src/logger/log-warnings.test.ts

@@ -0,0 +1,351 @@
+import type { SharedV3Warning } from '@ai-sdk/provider';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { Warning } from '../types/warning';
+import {
+  FIRST_WARNING_INFO_MESSAGE,
+  logWarnings,
+  resetLogWarningsState,
+} from './log-warnings';
+
+// Mock console.warn and console.info
+const mockConsoleWarn = vi.fn();
+const mockConsoleInfo = vi.fn();
+vi.stubGlobal('console', { warn: mockConsoleWarn, info: mockConsoleInfo });
+
+describe('logWarnings', () => {
+  beforeEach(() => {
+    mockConsoleWarn.mockClear();
+    mockConsoleInfo.mockClear();
+    resetLogWarningsState();
+    delete globalThis.AI_SDK_LOG_WARNINGS;
+  });
+
+  afterEach(() => {
+    delete globalThis.AI_SDK_LOG_WARNINGS;
+  });
+
+  describe('when AI_SDK_LOG_WARNINGS is false', () => {
+    beforeEach(() => {
+      globalThis.AI_SDK_LOG_WARNINGS = false;
+    });
+
+    it('should not log any warnings (single)', () => {
+      const warnings: Warning[] = [
+        {
+          type: 'other',
+          message: 'Test warning',
+        } as SharedV3Warning,
+      ];
+
+      logWarnings({ warnings, provider: 'providerX', model: 'modelY' });
+
+      expect(mockConsoleWarn).not.toHaveBeenCalled();
+      expect(mockConsoleInfo).not.toHaveBeenCalled();
+    });
+
+    it('should not log any warnings (multiple)', () => {
+      const warnings: Warning[] = [
+        {
+          type: 'other',
+          message: 'Test warning 1',
+        },
+        {
+          type: 'other',
+          message: 'Test warning 2',
+        },
+      ];
+
+      logWarnings({ warnings, provider: 'provider', model: 'model' });
+
+      expect(mockConsoleWarn).not.toHaveBeenCalled();
+      expect(mockConsoleInfo).not.toHaveBeenCalled();
+    });
+
+    it('should not count empty arrays as first call', () => {
+      logWarnings({ warnings: [], provider: 'prov', model: 'mod' });
+
+      expect(mockConsoleWarn).not.toHaveBeenCalled();
+      expect(mockConsoleInfo).not.toHaveBeenCalled();
+
+      logWarnings({
+        warnings: [{ type: 'other', message: 'foo' } as SharedV3Warning],
+        provider: 'p1',
+        model: 'm1',
+      });
+
+      expect(mockConsoleWarn).not.toHaveBeenCalled();
+      expect(mockConsoleInfo).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('when AI_SDK_LOG_WARNINGS is a custom function', () => {
+    it('should call the custom function with warning options', () => {
+      const customLogger = vi.fn();
+      globalThis.AI_SDK_LOG_WARNINGS = customLogger;
+
+      const warnings: Warning[] = [
+        {
+          type: 'other',
+          message: 'Test warning',
+        } as SharedV3Warning,
+      ];
+
+      const options = { warnings, provider: 'pp', model: 'mm' };
+      logWarnings(options);
+
+      expect(customLogger).toHaveBeenCalledOnce();
+      expect(customLogger).toHaveBeenCalledWith(options);
+      expect(mockConsoleWarn).not.toHaveBeenCalled();
+      expect(mockConsoleInfo).not.toHaveBeenCalled();
+    });
+
+    it('should call the custom function with multiple warnings', () => {
+      const customLogger = vi.fn();
+      globalThis.AI_SDK_LOG_WARNINGS = customLogger;
+
+      const warnings: Warning[] = [
+        {
+          type: 'unsupported',
+          feature: 'temperature',
+          details: 'Temperature not supported',
+        },
+        {
+          type: 'other',
+          message: 'Another warning',
+        },
+      ];
+
+      const opts = { warnings, provider: 'provider', model: 'model' };
+      logWarnings(opts);
+
+      expect(customLogger).toHaveBeenCalledOnce();
+      expect(customLogger).toHaveBeenCalledWith(opts);
+      expect(mockConsoleWarn).not.toHaveBeenCalled();
+      expect(mockConsoleInfo).not.toHaveBeenCalled();
+    });
+
+    it('should not call the custom function with empty warnings array', () => {
+      const customLogger = vi.fn();
+      globalThis.AI_SDK_LOG_WARNINGS = customLogger;
+
+      const warnings: Warning[] = [];
+
+      logWarnings({ warnings, provider: 'x', model: 'y' });
+
+      expect(customLogger).not.toHaveBeenCalled();
+      expect(mockConsoleWarn).not.toHaveBeenCalled();
+      expect(mockConsoleInfo).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('when AI_SDK_LOG_WARNINGS is unset/undefined (default behavior)', () => {
+    it('should show console.info once for first warning(s), then log to console.warn for each warning', () => {
+      const warning: SharedV3Warning = {
+        type: 'other',
+        message: 'Test warning message',
+      };
+      const warnings: Warning[] = [warning];
+
+      logWarnings({ warnings, provider: 'myProvider', model: 'myModel' });
+
+      expect(mockConsoleInfo).toHaveBeenCalledTimes(1);
+      expect(mockConsoleInfo).toHaveBeenCalledWith(FIRST_WARNING_INFO_MESSAGE);
+      expect(mockConsoleWarn).toHaveBeenCalledTimes(1);
+      expect(mockConsoleWarn).toHaveBeenCalledWith(
+        'AI SDK Warning (myProvider / myModel): Test warning message',
+      );
+    });
+
+    it('should only show console.info on the first non-empty call', () => {
+      const first: Warning[] = [
+        { type: 'other', message: '1' } as SharedV3Warning,
+      ];
+      const second: Warning[] = [
+        { type: 'other', message: '2' } as SharedV3Warning,
+      ];
+
+      logWarnings({ warnings: first, provider: 'a', model: 'b' });
+      logWarnings({ warnings: second, provider: 'a', model: 'b' });
+
+      // Info on first call only
+      expect(mockConsoleInfo).toHaveBeenCalledTimes(1);
+      expect(mockConsoleInfo).toHaveBeenCalledWith(FIRST_WARNING_INFO_MESSAGE);
+      expect(mockConsoleWarn).toHaveBeenCalledTimes(2);
+      expect(mockConsoleWarn).toHaveBeenNthCalledWith(
+        1,
+        'AI SDK Warning (a / b): 1',
+      );
+      expect(mockConsoleWarn).toHaveBeenNthCalledWith(
+        2,
+        'AI SDK Warning (a / b): 2',
+      );
+    });
+
+    it('should only log for non-empty warnings', () => {
+      logWarnings({ warnings: [], provider: 'err', model: 'm' });
+
+      expect(mockConsoleWarn).not.toHaveBeenCalled();
+      expect(mockConsoleInfo).not.toHaveBeenCalled();
+
+      logWarnings({
+        warnings: [{ type: 'other', message: 't1' } as SharedV3Warning],
+        provider: 'prov',
+        model: 'mod',
+      });
+      expect(mockConsoleInfo).toHaveBeenCalledOnce();
+      expect(mockConsoleWarn).toHaveBeenCalledOnce();
+
+      logWarnings({ warnings: [], provider: 'prov', model: 'mod' });
+      expect(mockConsoleInfo).toHaveBeenCalledOnce();
+      expect(mockConsoleWarn).toHaveBeenCalledOnce();
+
+      logWarnings({
+        warnings: [{ type: 'other', message: 't2' } as SharedV3Warning],
+        provider: 'prov',
+        model: 'mod',
+      });
+      expect(mockConsoleInfo).toHaveBeenCalledOnce(); // only once
+      expect(mockConsoleWarn).toHaveBeenCalledTimes(2);
+    });
+
+    it('should handle various warning types per formatWarning', () => {
+      const warnings: Warning[] = [
+        {
+          type: 'unsupported',
+          feature: 'mediaType',
+          details: 'detail',
+        },
+        {
+          type: 'unsupported',
+          feature: 'voice',
+          details: 'detail2',
+        },
+        {
+          type: 'other',
+          message: 'other msg',
+        },
+      ];
+
+      logWarnings({ warnings, provider: 'zzz', model: 'MMM' });
+
+      expect(mockConsoleInfo).toHaveBeenCalledTimes(1);
+      expect(mockConsoleWarn).toHaveBeenCalledTimes(3);
+      expect(mockConsoleWarn).toHaveBeenNthCalledWith(
+        1,
+        'AI SDK Warning (zzz / MMM): ' +
+          'The feature "mediaType" is not supported. detail',
+      );
+      expect(mockConsoleWarn).toHaveBeenNthCalledWith(
+        2,
+        'AI SDK Warning (zzz / MMM): ' +
+          'The feature "voice" is not supported. detail2',
+      );
+      expect(mockConsoleWarn).toHaveBeenNthCalledWith(
+        3,
+        'AI SDK Warning (zzz / MMM): other msg',
+      );
+    });
+
+    it('should include warning even with "unknown provider" and "unknown model"', () => {
+      logWarnings({
+        warnings: [{ type: 'other', message: 'messx' } as SharedV3Warning],
+        provider: 'unknown provider',
+        model: 'unknown model',
+      });
+
+      expect(mockConsoleInfo).toHaveBeenCalledTimes(1);
+      expect(mockConsoleWarn).toHaveBeenCalledWith(
+        'AI SDK Warning (unknown provider / unknown model): messx',
+      );
+    });
+  });
+
+  describe('when AI_SDK_LOG_WARNINGS is undefined (explicitly set)', () => {
+    beforeEach(() => {
+      globalThis.AI_SDK_LOG_WARNINGS = undefined;
+    });
+
+    it('should use default behavior and log to console.warn', () => {
+      const warning: SharedV3Warning = {
+        type: 'other',
+        message: 'Test warning with undefined logger',
+      };
+      const warnings: Warning[] = [warning];
+
+      logWarnings({ warnings, provider: 'p1', model: 'm1' });
+
+      expect(mockConsoleInfo).toHaveBeenCalledOnce();
+      expect(mockConsoleInfo).toHaveBeenCalledWith(FIRST_WARNING_INFO_MESSAGE);
+      expect(mockConsoleWarn).toHaveBeenCalledOnce();
+      expect(mockConsoleWarn).toHaveBeenCalledWith(
+        'AI SDK Warning (p1 / m1): Test warning with undefined logger',
+      );
+    });
+  });
+
+  describe('first-time information note', () => {
+    it('should not display the info message for empty warnings', () => {
+      logWarnings({ warnings: [], provider: 'a', model: 'b' });
+      expect(mockConsoleInfo).not.toHaveBeenCalled();
+      expect(mockConsoleWarn).not.toHaveBeenCalled();
+    });
+
+    it('should display informational note only on first real call', () => {
+      logWarnings({ warnings: [], provider: 'a', model: 'b' });
+      expect(mockConsoleInfo).not.toHaveBeenCalled();
+      expect(mockConsoleWarn).not.toHaveBeenCalled();
+
+      logWarnings({ warnings: [], provider: 'a', model: 'b' });
+      expect(mockConsoleInfo).not.toHaveBeenCalled();
+      expect(mockConsoleWarn).not.toHaveBeenCalled();
+
+      logWarnings({
+        warnings: [{ type: 'other', message: 'foo' } as SharedV3Warning],
+        provider: 'abc',
+        model: 'bbb',
+      });
+      expect(mockConsoleInfo).toHaveBeenCalledTimes(1);
+      expect(mockConsoleWarn).toHaveBeenCalledTimes(1);
+
+      logWarnings({
+        warnings: [{ type: 'other', message: 'bar' } as SharedV3Warning],
+        provider: 'abc',
+        model: 'bbb',
+      });
+      expect(mockConsoleInfo).toHaveBeenCalledTimes(1);
+      expect(mockConsoleWarn).toHaveBeenCalledTimes(2);
+    });
+
+    it('should not display information note when using custom logger', () => {
+      const customLogger = vi.fn();
+      globalThis.AI_SDK_LOG_WARNINGS = customLogger;
+
+      logWarnings({
+        warnings: [{ type: 'other', message: 'Message' } as SharedV3Warning],
+        provider: 'provV',
+        model: 'modZ',
+      });
+
+      expect(mockConsoleInfo).not.toHaveBeenCalled();
+      expect(customLogger).toHaveBeenCalledOnce();
+    });
+
+    it('should not display information note when AI_SDK_LOG_WARNINGS is false', () => {
+      globalThis.AI_SDK_LOG_WARNINGS = false;
+
+      logWarnings({
+        warnings: [
+          {
+            type: 'other',
+            message: 'Suppressed',
+          } as SharedV3Warning,
+        ],
+        provider: 'notProv',
+        model: 'notModel',
+      });
+
+      expect(mockConsoleInfo).not.toHaveBeenCalled();
+      expect(mockConsoleWarn).not.toHaveBeenCalled();
+    });
+  });
+});

package/src/logger/log-warnings.ts

@@ -0,0 +1,119 @@
+import { Warning } from '../types';
+
+/**
+ * A function for logging warnings.
+ *
+ * You can assign it to the `AI_SDK_LOG_WARNINGS` global variable to use it as the default warning logger.
+ *
+ * @example
+ * ```ts
+ * globalThis.AI_SDK_LOG_WARNINGS = (options) => {
+ *   console.log('WARNINGS:', options.warnings, options.provider, options.model);
+ * };
+ * ```
+ */
+export type LogWarningsFunction = (options: {
+  /**
+   * The warnings returned by the model provider.
+   */
+  warnings: Warning[];
+
+  /**
+   * The provider id used for the call.
+   */
+  provider: string;
+
+  /**
+   * The model id used for the call.
+   */
+  model: string;
+}) => void;
+
+/**
+ * Formats a warning object into a human-readable string with clear AI SDK branding
+ */
+function formatWarning({
+  warning,
+  provider,
+  model,
+}: {
+  warning: Warning;
+  provider: string;
+  model: string;
+}): string {
+  const prefix = `AI SDK Warning (${provider} / ${model}):`;
+
+  switch (warning.type) {
+    case 'unsupported': {
+      let message = `${prefix} The feature "${warning.feature}" is not supported.`;
+      if (warning.details) {
+        message += ` ${warning.details}`;
+      }
+      return message;
+    }
+
+    case 'compatibility': {
+      let message = `${prefix} The feature "${warning.feature}" is used in a compatibility mode.`;
+      if (warning.details) {
+        message += ` ${warning.details}`;
+      }
+      return message;
+    }
+
+    case 'other': {
+      return `${prefix} ${warning.message}`;
+    }
+
+    default: {
+      // Fallback for any unknown warning types
+      return `${prefix} ${JSON.stringify(warning, null, 2)}`;
+    }
+  }
+}
+
+export const FIRST_WARNING_INFO_MESSAGE =
+  'AI SDK Warning System: To turn off warning logging, set the AI_SDK_LOG_WARNINGS global to false.';
+
+let hasLoggedBefore = false;
+
+export const logWarnings: LogWarningsFunction = options => {
+  // if the warnings array is empty, do nothing
+  if (options.warnings.length === 0) {
+    return;
+  }
+
+  const logger = globalThis.AI_SDK_LOG_WARNINGS;
+
+  // if the logger is set to false, do nothing
+  if (logger === false) {
+    return;
+  }
+
+  // use the provided logger if it is a function
+  if (typeof logger === 'function') {
+    logger(options);
+    return;
+  }
+
+  // display information note on first call
+  if (!hasLoggedBefore) {
+    hasLoggedBefore = true;
+    console.info(FIRST_WARNING_INFO_MESSAGE);
+  }
+
+  // default behavior: log warnings to the console
+  for (const warning of options.warnings) {
+    console.warn(
+      formatWarning({
+        warning,
+        provider: options.provider,
+        model: options.model,
+      }),
+    );
+  }
+};
+
+// Reset function for testing purposes
+export const resetLogWarningsState = () => {
+  hasLoggedBefore = false;
+};

package/src/middleware/__snapshots__/simulate-streaming-middleware.test.ts.snap

@@ -0,0 +1,64 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`simulateStreamingMiddleware > should handle empty text response 1`] = `
+[
+  {
+    "type": "start",
+  },
+  {
+    "request": {},
+    "type": "start-step",
+    "warnings": [],
+  },
+  {
+    "finishReason": "stop",
+    "providerMetadata": undefined,
+    "rawFinishReason": "stop",
+    "response": {
+      "headers": undefined,
+      "id": "id-6",
+      "modelId": "mock-model-id",
+      "timestamp": 2025-01-01T00:00:00.000Z,
+    },
+    "type": "finish-step",
+    "usage": {
+      "cachedInputTokens": 0,
+      "inputTokenDetails": {
+        "cacheReadTokens": 0,
+        "cacheWriteTokens": 0,
+        "noCacheTokens": 5,
+      },
+      "inputTokens": 5,
+      "outputTokenDetails": {
+        "reasoningTokens": 3,
+        "textTokens": 10,
+      },
+      "outputTokens": 10,
+      "raw": undefined,
+      "reasoningTokens": 3,
+      "totalTokens": 15,
+    },
+  },
+  {
+    "finishReason": "stop",
+    "rawFinishReason": "stop",
+    "totalUsage": {
+      "cachedInputTokens": 0,
+      "inputTokenDetails": {
+        "cacheReadTokens": 0,
+        "cacheWriteTokens": 0,
+        "noCacheTokens": 5,
+      },
+      "inputTokens": 5,
+      "outputTokenDetails": {
+        "reasoningTokens": 3,
+        "textTokens": 10,
+      },
+      "outputTokens": 10,
+      "reasoningTokens": 3,
+      "totalTokens": 15,
+    },
+    "type": "finish",
+  },
+]
+`;