@fairyhunter13/ai-sdk 6.0.116-fork.1

package/src/telemetry/stringify-for-telemetry.ts

@@ -0,0 +1,33 @@
+import {
+  LanguageModelV4Message,
+  LanguageModelV4Prompt,
+} from '@ai-sdk/provider';
+import { convertDataContentToBase64String } from '../prompt/data-content';
+
+/**
+ * Helper utility to serialize prompt content for OpenTelemetry tracing.
+ * It is initially created because normalized LanguageModelV4Prompt carries
+ * images as Uint8Arrays, on which JSON.stringify acts weirdly, converting
+ * them to objects with stringified indices as keys, e.g. {"0": 42, "1": 69 }.
+ */
+export function stringifyForTelemetry(prompt: LanguageModelV4Prompt): string {
+  return JSON.stringify(
+    prompt.map((message: LanguageModelV4Message) => ({
+      ...message,
+      content:
+        typeof message.content === 'string'
+          ? message.content
+          : message.content.map(part =>
+              part.type === 'file'
+                ? {
+                    ...part,
+                    data:
+                      part.data instanceof Uint8Array
+                        ? convertDataContentToBase64String(part.data)
+                        : part.data,
+                  }
+                : part,
+            ),
+    })),
+  );
+}

package/src/telemetry/telemetry-integration-registry.ts

@@ -0,0 +1,22 @@
+import type { TelemetryIntegration } from './telemetry-integration';
+
+/**
+ * Registers a telemetry integration globally.
+ */
+export function registerTelemetryIntegration(
+  integration: TelemetryIntegration,
+): void {
+  if (!globalThis.AI_SDK_TELEMETRY_INTEGRATIONS) {
+    globalThis.AI_SDK_TELEMETRY_INTEGRATIONS = [];
+  }
+  globalThis.AI_SDK_TELEMETRY_INTEGRATIONS.push(integration);
+}
+
+export function getGlobalTelemetryIntegrations(): TelemetryIntegration[] {
+  return globalThis.AI_SDK_TELEMETRY_INTEGRATIONS ?? [];
+}
+
+// TODO remove when OTel is moved to a separate package
+export function hasIntegration(integration: TelemetryIntegration): boolean {
+  return (globalThis.AI_SDK_TELEMETRY_INTEGRATIONS ?? []).includes(integration);
+}

package/src/telemetry/telemetry-integration.ts

@@ -0,0 +1,100 @@
+import type {
+  OnChunkEvent,
+  OnFinishEvent,
+  OnStartEvent,
+  OnStepFinishEvent,
+  OnStepStartEvent,
+  OnToolCallFinishEvent,
+  OnToolCallStartEvent,
+} from '../generate-text/core-events';
+import type { Output } from '../generate-text/output';
+import type { ToolSet } from '../generate-text/tool-set';
+import { Listener } from '../util/notify';
+
+/**
+ * Implement this interface to create custom telemetry integrations.
+ * Methods can be sync or return a PromiseLike.
+ */
+export interface TelemetryIntegration {
+  /**
+   * Called when the generation operation begins, before any LLM calls are made.
+   * Use this to initialize telemetry spans, record input parameters, or set up
+   * tracking state for the entire generation lifecycle.
+   *
+   * The event includes the full configuration: model, messages, tools, sampling
+   * parameters, and telemetry settings.
+   */
+  onStart?: Listener<OnStartEvent<ToolSet, Output>>;
+
+  /**
+   * Called when an individual step (single LLM invocation) begins.
+   * A generation may consist of multiple steps (e.g. when tool calls trigger
+   * follow-up LLM calls). Use this to create per-step spans or record
+   * step-level inputs.
+   *
+   * The event includes the step number, accumulated previous step results,
+   * and the messages that will be sent to the model.
+   */
+  onStepStart?: Listener<OnStepStartEvent<ToolSet, Output>>;
+
+  /**
+   * Called when a tool execution begins, before the tool's `execute` function
+   * is invoked. Use this to create tool-level spans or log tool invocations.
+   */
+  onToolCallStart?: Listener<OnToolCallStartEvent<ToolSet>>;
+
+  /**
+   * Called when a tool execution completes, either successfully or with an error.
+   * The event uses a discriminated union on the `success` field — check
+   * `event.success` to determine whether `output` or `error` is available.
+   *
+   * The event includes execution duration (`durationMs`) for performance tracking.
+   */
+  onToolCallFinish?: Listener<OnToolCallFinishEvent<ToolSet>>;
+
+  /**
+   * Called for each chunk received during streaming.
+   * Only relevant for `streamText` — not called during `generateText`.
+   */
+  onChunk?: Listener<OnChunkEvent>;
+
+  /**
+   * Called when an individual step (single LLM invocation) completes.
+   * The event is a `StepResult` containing the model's response, tool calls
+   * and results, usage statistics, finish reason, and optional request/response
+   * bodies.
+   */
+  onStepFinish?: Listener<OnStepFinishEvent<ToolSet>>;
+
+  /**
+   * Called when the entire generation completes (all steps finished).
+   * The event extends the final step's result with aggregated data: an array
+   * of all step results (`steps`) and total token usage across all steps
+   * (`totalUsage`).
+   */
+  onFinish?: Listener<OnFinishEvent<ToolSet>>;
+
+  /**
+   * Called when an unrecoverable error occurs during the generation lifecycle.
+   * The error value is untyped — it may be an `Error` instance, an `AISDKError`,
+   * or any thrown value.
+   *
+   * Use this to record error details on telemetry spans and set error status.
+   */
+  onError?: Listener<unknown>;
+
+  /**
+   * Optionally runs the tool execute function in a telemetry-integration-specific context. This enables
+   * nested traces — e.g. when a tool's `execute` function calls `generateText`,
+   * the inner call's spans become children of the tool span.
+   *
+   * @param params.callId - The call ID of the tool call.
+   * @param params.toolCallId - The tool call ID.
+   * @param params.execute - The function to execute.
+   */
+  executeTool?: <T>(params: {
+    callId: string;
+    toolCallId: string;
+    execute: () => PromiseLike<T>;
+  }) => PromiseLike<T>;
+}

package/src/telemetry/telemetry-settings.ts

@@ -0,0 +1,55 @@
+import type { JSONValue } from '@ai-sdk/provider';
+import type { Tracer } from '@opentelemetry/api';
+import type { TelemetryIntegration } from './telemetry-integration';
+
+/**
+ * Telemetry configuration.
+ */
+// This is meant to be both flexible for custom app requirements (metadata)
+// and extensible for standardization (example: functionId, more to come).
+export type TelemetrySettings = {
+  /**
+   * Enable or disable telemetry. Disabled by default while experimental.
+   */
+  isEnabled?: boolean;
+
+  /**
+   * Enable or disable input recording. Enabled by default.
+   *
+   * You might want to disable input recording to avoid recording sensitive
+   * information, to reduce data transfers, or to increase performance.
+   */
+  recordInputs?: boolean;
+
+  /**
+   * Enable or disable output recording. Enabled by default.
+   *
+   * You might want to disable output recording to avoid recording sensitive
+   * information, to reduce data transfers, or to increase performance.
+   */
+  recordOutputs?: boolean;
+
+  /**
+   * Identifier for this function. Used to group telemetry data by function.
+   */
+  functionId?: string;
+
+  /**
+   * Additional information to include in the telemetry data.
+   */
+  metadata?: Record<string, JSONValue>;
+
+  /**
+   * A custom tracer to use for the telemetry data.
+   */
+  // TODO remove tracer (all ai functions need to be updated)
+  tracer?: Tracer;
+
+  /**
+   * Per-call telemetry integrations that receive lifecycle events during generation.
+   *
+   * These integrations run after any globally registered integrations
+   * (see `registerTelemetryIntegration`).
+   */
+  integrations?: TelemetryIntegration | TelemetryIntegration[];
+};

package/src/test/mock-embedding-model-v2.ts

@@ -0,0 +1,35 @@
+import { EmbeddingModelV2 } from '@ai-sdk/provider';
+import { notImplemented } from './not-implemented';
+
+export class MockEmbeddingModelV2<VALUE> implements EmbeddingModelV2<VALUE> {
+  readonly specificationVersion = 'v2';
+
+  readonly provider: EmbeddingModelV2<VALUE>['provider'];
+  readonly modelId: EmbeddingModelV2<VALUE>['modelId'];
+  readonly maxEmbeddingsPerCall: EmbeddingModelV2<VALUE>['maxEmbeddingsPerCall'];
+  readonly supportsParallelCalls: EmbeddingModelV2<VALUE>['supportsParallelCalls'];
+
+  doEmbed: EmbeddingModelV2<VALUE>['doEmbed'];
+
+  constructor({
+    provider = 'mock-provider',
+    modelId = 'mock-model-id',
+    maxEmbeddingsPerCall = 1,
+    supportsParallelCalls = false,
+    doEmbed = notImplemented,
+  }: {
+    provider?: EmbeddingModelV2<VALUE>['provider'];
+    modelId?: EmbeddingModelV2<VALUE>['modelId'];
+    maxEmbeddingsPerCall?:
+      | EmbeddingModelV2<VALUE>['maxEmbeddingsPerCall']
+      | null;
+    supportsParallelCalls?: EmbeddingModelV2<VALUE>['supportsParallelCalls'];
+    doEmbed?: EmbeddingModelV2<VALUE>['doEmbed'];
+  } = {}) {
+    this.provider = provider;
+    this.modelId = modelId;
+    this.maxEmbeddingsPerCall = maxEmbeddingsPerCall ?? undefined;
+    this.supportsParallelCalls = supportsParallelCalls;
+    this.doEmbed = doEmbed;
+  }
+}

package/src/test/mock-embedding-model-v3.ts

@@ -0,0 +1,48 @@
+import { EmbeddingModelV3 } from '@ai-sdk/provider';
+import { notImplemented } from './not-implemented';
+
+export class MockEmbeddingModelV3 implements EmbeddingModelV3 {
+  readonly specificationVersion = 'v3';
+
+  readonly provider: EmbeddingModelV3['provider'];
+  readonly modelId: EmbeddingModelV3['modelId'];
+  readonly maxEmbeddingsPerCall: EmbeddingModelV3['maxEmbeddingsPerCall'];
+  readonly supportsParallelCalls: EmbeddingModelV3['supportsParallelCalls'];
+
+  doEmbed: EmbeddingModelV3['doEmbed'];
+
+  doEmbedCalls: Parameters<EmbeddingModelV3['doEmbed']>[0][] = [];
+
+  constructor({
+    provider = 'mock-provider',
+    modelId = 'mock-model-id',
+    maxEmbeddingsPerCall = 1,
+    supportsParallelCalls = false,
+    doEmbed = notImplemented,
+  }: {
+    provider?: EmbeddingModelV3['provider'];
+    modelId?: EmbeddingModelV3['modelId'];
+    maxEmbeddingsPerCall?: EmbeddingModelV3['maxEmbeddingsPerCall'] | null;
+    supportsParallelCalls?: EmbeddingModelV3['supportsParallelCalls'];
+    doEmbed?:
+      | EmbeddingModelV3['doEmbed']
+      | Awaited<ReturnType<EmbeddingModelV3['doEmbed']>>
+      | Awaited<ReturnType<EmbeddingModelV3['doEmbed']>>[];
+  } = {}) {
+    this.provider = provider;
+    this.modelId = modelId;
+    this.maxEmbeddingsPerCall = maxEmbeddingsPerCall ?? undefined;
+    this.supportsParallelCalls = supportsParallelCalls;
+    this.doEmbed = async options => {
+      this.doEmbedCalls.push(options);
+
+      if (typeof doEmbed === 'function') {
+        return doEmbed(options);
+      } else if (Array.isArray(doEmbed)) {
+        return doEmbed[this.doEmbedCalls.length];
+      } else {
+        return doEmbed;
+      }
+    };
+  }
+}

package/src/test/mock-embedding-model-v4.ts

@@ -0,0 +1,48 @@
+import { EmbeddingModelV4 } from '@ai-sdk/provider';
+import { notImplemented } from './not-implemented';
+
+export class MockEmbeddingModelV4 implements EmbeddingModelV4 {
+  readonly specificationVersion = 'v4';
+
+  readonly provider: EmbeddingModelV4['provider'];
+  readonly modelId: EmbeddingModelV4['modelId'];
+  readonly maxEmbeddingsPerCall: EmbeddingModelV4['maxEmbeddingsPerCall'];
+  readonly supportsParallelCalls: EmbeddingModelV4['supportsParallelCalls'];
+
+  doEmbed: EmbeddingModelV4['doEmbed'];
+
+  doEmbedCalls: Parameters<EmbeddingModelV4['doEmbed']>[0][] = [];
+
+  constructor({
+    provider = 'mock-provider',
+    modelId = 'mock-model-id',
+    maxEmbeddingsPerCall = 1,
+    supportsParallelCalls = false,
+    doEmbed = notImplemented,
+  }: {
+    provider?: EmbeddingModelV4['provider'];
+    modelId?: EmbeddingModelV4['modelId'];
+    maxEmbeddingsPerCall?: EmbeddingModelV4['maxEmbeddingsPerCall'] | null;
+    supportsParallelCalls?: EmbeddingModelV4['supportsParallelCalls'];
+    doEmbed?:
+      | EmbeddingModelV4['doEmbed']
+      | Awaited<ReturnType<EmbeddingModelV4['doEmbed']>>
+      | Awaited<ReturnType<EmbeddingModelV4['doEmbed']>>[];
+  } = {}) {
+    this.provider = provider;
+    this.modelId = modelId;
+    this.maxEmbeddingsPerCall = maxEmbeddingsPerCall ?? undefined;
+    this.supportsParallelCalls = supportsParallelCalls;
+    this.doEmbed = async options => {
+      this.doEmbedCalls.push(options);
+
+      if (typeof doEmbed === 'function') {
+        return doEmbed(options);
+      } else if (Array.isArray(doEmbed)) {
+        return doEmbed[this.doEmbedCalls.length];
+      } else {
+        return doEmbed;
+      }
+    };
+  }
+}

package/src/test/mock-image-model-v2.ts

@@ -0,0 +1,28 @@
+import { ImageModelV2 } from '@ai-sdk/provider';
+import { notImplemented } from './not-implemented';
+
+export class MockImageModelV2 implements ImageModelV2 {
+  readonly specificationVersion = 'v2';
+  readonly provider: ImageModelV2['provider'];
+  readonly modelId: ImageModelV2['modelId'];
+  readonly maxImagesPerCall: ImageModelV2['maxImagesPerCall'];
+
+  doGenerate: ImageModelV2['doGenerate'];
+
+  constructor({
+    provider = 'mock-provider',
+    modelId = 'mock-model-id',
+    maxImagesPerCall = 1,
+    doGenerate = notImplemented,
+  }: {
+    provider?: ImageModelV2['provider'];
+    modelId?: ImageModelV2['modelId'];
+    maxImagesPerCall?: ImageModelV2['maxImagesPerCall'];
+    doGenerate?: ImageModelV2['doGenerate'];
+  } = {}) {
+    this.provider = provider;
+    this.modelId = modelId;
+    this.maxImagesPerCall = maxImagesPerCall;
+    this.doGenerate = doGenerate;
+  }
+}

package/src/test/mock-image-model-v3.ts

@@ -0,0 +1,28 @@
+import { ImageModelV3 } from '@ai-sdk/provider';
+import { notImplemented } from './not-implemented';
+
+export class MockImageModelV3 implements ImageModelV3 {
+  readonly specificationVersion = 'v3';
+  readonly provider: ImageModelV3['provider'];
+  readonly modelId: ImageModelV3['modelId'];
+  readonly maxImagesPerCall: ImageModelV3['maxImagesPerCall'];
+
+  doGenerate: ImageModelV3['doGenerate'];
+
+  constructor({
+    provider = 'mock-provider',
+    modelId = 'mock-model-id',
+    maxImagesPerCall = 1,
+    doGenerate = notImplemented,
+  }: {
+    provider?: ImageModelV3['provider'];
+    modelId?: ImageModelV3['modelId'];
+    maxImagesPerCall?: ImageModelV3['maxImagesPerCall'];
+    doGenerate?: ImageModelV3['doGenerate'];
+  } = {}) {
+    this.provider = provider;
+    this.modelId = modelId;
+    this.maxImagesPerCall = maxImagesPerCall;
+    this.doGenerate = doGenerate;
+  }
+}

package/src/test/mock-image-model-v4.ts

@@ -0,0 +1,28 @@
+import { ImageModelV4 } from '@ai-sdk/provider';
+import { notImplemented } from './not-implemented';
+
+export class MockImageModelV4 implements ImageModelV4 {
+  readonly specificationVersion = 'v4';
+  readonly provider: ImageModelV4['provider'];
+  readonly modelId: ImageModelV4['modelId'];
+  readonly maxImagesPerCall: ImageModelV4['maxImagesPerCall'];
+
+  doGenerate: ImageModelV4['doGenerate'];
+
+  constructor({
+    provider = 'mock-provider',
+    modelId = 'mock-model-id',
+    maxImagesPerCall = 1,
+    doGenerate = notImplemented,
+  }: {
+    provider?: ImageModelV4['provider'];
+    modelId?: ImageModelV4['modelId'];
+    maxImagesPerCall?: ImageModelV4['maxImagesPerCall'];
+    doGenerate?: ImageModelV4['doGenerate'];
+  } = {}) {
+    this.provider = provider;
+    this.modelId = modelId;
+    this.maxImagesPerCall = maxImagesPerCall;
+    this.doGenerate = doGenerate;
+  }
+}

package/src/test/mock-language-model-v2.ts

@@ -0,0 +1,72 @@
+import { LanguageModelV2 } from '@ai-sdk/provider';
+import { notImplemented } from './not-implemented';
+
+export class MockLanguageModelV2 implements LanguageModelV2 {
+  readonly specificationVersion = 'v2';
+
+  private _supportedUrls: () => LanguageModelV2['supportedUrls'];
+
+  readonly provider: LanguageModelV2['provider'];
+  readonly modelId: LanguageModelV2['modelId'];
+
+  doGenerate: LanguageModelV2['doGenerate'];
+  doStream: LanguageModelV2['doStream'];
+
+  doGenerateCalls: Parameters<LanguageModelV2['doGenerate']>[0][] = [];
+  doStreamCalls: Parameters<LanguageModelV2['doStream']>[0][] = [];
+
+  constructor({
+    provider = 'mock-provider',
+    modelId = 'mock-model-id',
+    supportedUrls = {},
+    doGenerate = notImplemented,
+    doStream = notImplemented,
+  }: {
+    provider?: LanguageModelV2['provider'];
+    modelId?: LanguageModelV2['modelId'];
+    supportedUrls?:
+      | LanguageModelV2['supportedUrls']
+      | (() => LanguageModelV2['supportedUrls']);
+    doGenerate?:
+      | LanguageModelV2['doGenerate']
+      | Awaited<ReturnType<LanguageModelV2['doGenerate']>>
+      | Awaited<ReturnType<LanguageModelV2['doGenerate']>>[];
+    doStream?:
+      | LanguageModelV2['doStream']
+      | Awaited<ReturnType<LanguageModelV2['doStream']>>
+      | Awaited<ReturnType<LanguageModelV2['doStream']>>[];
+  } = {}) {
+    this.provider = provider;
+    this.modelId = modelId;
+    this.doGenerate = async options => {
+      this.doGenerateCalls.push(options);
+
+      if (typeof doGenerate === 'function') {
+        return doGenerate(options);
+      } else if (Array.isArray(doGenerate)) {
+        return doGenerate[this.doGenerateCalls.length];
+      } else {
+        return doGenerate;
+      }
+    };
+    this.doStream = async options => {
+      this.doStreamCalls.push(options);
+
+      if (typeof doStream === 'function') {
+        return doStream(options);
+      } else if (Array.isArray(doStream)) {
+        return doStream[this.doStreamCalls.length];
+      } else {
+        return doStream;
+      }
+    };
+    this._supportedUrls =
+      typeof supportedUrls === 'function'
+        ? supportedUrls
+        : async () => supportedUrls;
+  }
+
+  get supportedUrls() {
+    return this._supportedUrls();
+  }
+}

package/src/test/mock-language-model-v3.ts

@@ -0,0 +1,77 @@
+import {
+  LanguageModelV3,
+  LanguageModelV3CallOptions,
+  LanguageModelV3GenerateResult,
+  LanguageModelV3StreamResult,
+} from '@ai-sdk/provider';
+import { notImplemented } from './not-implemented';
+
+export class MockLanguageModelV3 implements LanguageModelV3 {
+  readonly specificationVersion = 'v3';
+
+  private _supportedUrls: () => LanguageModelV3['supportedUrls'];
+
+  readonly provider: LanguageModelV3['provider'];
+  readonly modelId: LanguageModelV3['modelId'];
+
+  doGenerate: LanguageModelV3['doGenerate'];
+  doStream: LanguageModelV3['doStream'];
+
+  doGenerateCalls: LanguageModelV3CallOptions[] = [];
+  doStreamCalls: LanguageModelV3CallOptions[] = [];
+
+  constructor({
+    provider = 'mock-provider',
+    modelId = 'mock-model-id',
+    supportedUrls = {},
+    doGenerate = notImplemented,
+    doStream = notImplemented,
+  }: {
+    provider?: LanguageModelV3['provider'];
+    modelId?: LanguageModelV3['modelId'];
+    supportedUrls?:
+      | LanguageModelV3['supportedUrls']
+      | (() => LanguageModelV3['supportedUrls']);
+    doGenerate?:
+      | LanguageModelV3['doGenerate']
+      | LanguageModelV3GenerateResult
+      | LanguageModelV3GenerateResult[];
+    doStream?:
+      | LanguageModelV3['doStream']
+      | LanguageModelV3StreamResult
+      | LanguageModelV3StreamResult[];
+  } = {}) {
+    this.provider = provider;
+    this.modelId = modelId;
+    this.doGenerate = async options => {
+      this.doGenerateCalls.push(options);
+
+      if (typeof doGenerate === 'function') {
+        return doGenerate(options);
+      } else if (Array.isArray(doGenerate)) {
+        return doGenerate[this.doGenerateCalls.length];
+      } else {
+        return doGenerate;
+      }
+    };
+    this.doStream = async options => {
+      this.doStreamCalls.push(options);
+
+      if (typeof doStream === 'function') {
+        return doStream(options);
+      } else if (Array.isArray(doStream)) {
+        return doStream[this.doStreamCalls.length];
+      } else {
+        return doStream;
+      }
+    };
+    this._supportedUrls =
+      typeof supportedUrls === 'function'
+        ? supportedUrls
+        : async () => supportedUrls;
+  }
+
+  get supportedUrls() {
+    return this._supportedUrls();
+  }
+}

package/src/test/mock-language-model-v4.ts

@@ -0,0 +1,77 @@
+import {
+  LanguageModelV4,
+  LanguageModelV4CallOptions,
+  LanguageModelV4GenerateResult,
+  LanguageModelV4StreamResult,
+} from '@ai-sdk/provider';
+import { notImplemented } from './not-implemented';
+
+export class MockLanguageModelV4 implements LanguageModelV4 {
+  readonly specificationVersion = 'v4';
+
+  private _supportedUrls: () => LanguageModelV4['supportedUrls'];
+
+  readonly provider: LanguageModelV4['provider'];
+  readonly modelId: LanguageModelV4['modelId'];
+
+  doGenerate: LanguageModelV4['doGenerate'];
+  doStream: LanguageModelV4['doStream'];
+
+  doGenerateCalls: LanguageModelV4CallOptions[] = [];
+  doStreamCalls: LanguageModelV4CallOptions[] = [];
+
+  constructor({
+    provider = 'mock-provider',
+    modelId = 'mock-model-id',
+    supportedUrls = {},
+    doGenerate = notImplemented,
+    doStream = notImplemented,
+  }: {
+    provider?: LanguageModelV4['provider'];
+    modelId?: LanguageModelV4['modelId'];
+    supportedUrls?:
+      | LanguageModelV4['supportedUrls']
+      | (() => LanguageModelV4['supportedUrls']);
+    doGenerate?:
+      | LanguageModelV4['doGenerate']
+      | LanguageModelV4GenerateResult
+      | LanguageModelV4GenerateResult[];
+    doStream?:
+      | LanguageModelV4['doStream']
+      | LanguageModelV4StreamResult
+      | LanguageModelV4StreamResult[];
+  } = {}) {
+    this.provider = provider;
+    this.modelId = modelId;
+    this.doGenerate = async options => {
+      this.doGenerateCalls.push(options);
+
+      if (typeof doGenerate === 'function') {
+        return doGenerate(options);
+      } else if (Array.isArray(doGenerate)) {
+        return doGenerate[this.doGenerateCalls.length];
+      } else {
+        return doGenerate;
+      }
+    };
+    this.doStream = async options => {
+      this.doStreamCalls.push(options);
+
+      if (typeof doStream === 'function') {
+        return doStream(options);
+      } else if (Array.isArray(doStream)) {
+        return doStream[this.doStreamCalls.length];
+      } else {
+        return doStream;
+      }
+    };
+    this._supportedUrls =
+      typeof supportedUrls === 'function'
+        ? supportedUrls
+        : async () => supportedUrls;
+  }
+
+  get supportedUrls() {
+    return this._supportedUrls();
+  }
+}