ashlr-plugin 1.36.4

package/bench/refs/node-sdk/src/generate-text/tool-call.ts

@@ -0,0 +1,59 @@
+import { InferToolInput } from '@ai-sdk/provider-utils';
+import { ProviderMetadata } from '../types';
+import { ValueOf } from '../util/value-of';
+import type { ToolSet } from '@ai-sdk/provider-utils';
+
+type BaseToolCall = {
+  type: 'tool-call';
+  toolCallId: string;
+  providerExecuted?: boolean;
+  providerMetadata?: ProviderMetadata;
+};
+
+/**
+ * A tool call whose `toolName` maps to a tool in the declared tool set,
+ * with an `input` type inferred from that tool's input schema.
+ */
+export type StaticToolCall<TOOLS extends ToolSet> = ValueOf<{
+  [NAME in keyof TOOLS]: BaseToolCall & {
+    toolName: NAME & string;
+    input: InferToolInput<TOOLS[NAME]>;
+    dynamic?: false | undefined;
+    invalid?: false | undefined;
+    error?: never;
+    title?: string;
+  };
+}>;
+
+/**
+ * A tool call whose `toolName` is only known at runtime, such as an invalid
+ * or otherwise untyped call that cannot be matched to the declared tool set.
+ */
+export type DynamicToolCall = BaseToolCall & {
+  toolName: string;
+  input: unknown;
+  dynamic: true;
+  title?: string;
+
+  /**
+   * True if this is caused by an unparsable tool call or
+   * a tool that does not exist.
+   */
+  // Added into DynamicToolCall to avoid breaking changes.
+  // TODO AI SDK 6: separate into a new InvalidToolCall type
+  invalid?: boolean;
+
+  /**
+   * The error that caused the tool call to be invalid.
+   */
+  // TODO AI SDK 6: separate into a new InvalidToolCall type
+  error?: unknown;
+};
+
+/**
+ * A tool call returned by text generation, either statically typed from the
+ * declared tool set or dynamically typed when the tool cannot be inferred.
+ */
+export type TypedToolCall<TOOLS extends ToolSet> =
+  | StaticToolCall<TOOLS>
+  | DynamicToolCall;

package/bench/refs/node-sdk/src/generate-text/tool-result.ts

@@ -0,0 +1,36 @@
+import { InferToolInput, InferToolOutput } from '@ai-sdk/provider-utils';
+import { ProviderMetadata } from '../types';
+import { ValueOf } from '../../src/util/value-of';
+import type { ToolSet } from '@ai-sdk/provider-utils';
+
+export type StaticToolResult<TOOLS extends ToolSet> = ValueOf<{
+  [NAME in keyof TOOLS]: {
+    type: 'tool-result';
+    toolCallId: string;
+    toolName: NAME & string;
+    input: InferToolInput<TOOLS[NAME]>;
+    output: InferToolOutput<TOOLS[NAME]>;
+    providerExecuted?: boolean;
+    providerMetadata?: ProviderMetadata;
+    dynamic?: false | undefined;
+    preliminary?: boolean;
+    title?: string;
+  };
+}>;
+
+export type DynamicToolResult = {
+  type: 'tool-result';
+  toolCallId: string;
+  toolName: string;
+  input: unknown;
+  output: unknown;
+  providerExecuted?: boolean;
+  providerMetadata?: ProviderMetadata;
+  dynamic: true;
+  preliminary?: boolean;
+  title?: string;
+};
+
+export type TypedToolResult<TOOLS extends ToolSet> =
+  | StaticToolResult<TOOLS>
+  | DynamicToolResult;

package/bench/refs/node-sdk/src/telemetry/create-telemetry-dispatcher.ts

@@ -0,0 +1,146 @@
+import { asArray } from '@ai-sdk/provider-utils';
+import { Callback } from '../util/callback';
+import { mergeCallbacks } from '../util/merge-callbacks';
+import type {
+  InferTelemetryEvent,
+  Telemetry,
+  TelemetryDispatcher,
+} from './telemetry';
+import { getGlobalTelemetryIntegrations } from './telemetry-registry';
+import type { TelemetryOptions } from './telemetry-options';
+
+/**
+ * The subset of `TelemetryDispatcher` keys whose values are Callback callbacks.
+ * This excludes non-Callback properties such as `executeTool`.
+ */
+type TelemetryCallbackKey = keyof {
+  [K in keyof TelemetryDispatcher as TelemetryDispatcher[K] extends
+    | Callback<any>
+    | undefined
+    ? K
+    : never]: true;
+};
+
+/**
+ * Resolves the public event type accepted by a telemetry callback key.
+ */
+type TelemetryEvent<K extends TelemetryCallbackKey> =
+  TelemetryDispatcher[K] extends Callback<infer EVENT> | undefined
+    ? EVENT
+    : never;
+
+function augmentEvent<EVENT>(
+  event: EVENT,
+  telemetry: Pick<
+    TelemetryOptions,
+    'recordInputs' | 'recordOutputs' | 'functionId'
+  >,
+): InferTelemetryEvent<EVENT> {
+  return Object.assign(
+    Object.create(Object.getPrototypeOf(event)),
+    event,
+    telemetry,
+  );
+}
+
+/**
+ * Creates a telemetry dispatcher that sends telemetry events
+ * to the resolved set of integrations.
+ *
+ * When per-call integrations are provided, they take precedence over the globally
+ * registered integrations for that call. When no per-call integrations are
+ * provided, the globally registered integrations are used.
+ *
+ * @param args.telemetry - Optional per-call telemetry settings and integrations.
+ *
+ * @returns A telemetry dispatcher that fans out lifecycle events to the
+ * resolved set of integrations.
+ */
+export function createTelemetryDispatcher({
+  telemetry,
+}: {
+  telemetry?: TelemetryOptions;
+  // operationId: string;
+}): TelemetryDispatcher {
+  // When telemetry is explicitly disabled, return a dispatcher
+  // that performs no work and lets tool execution pass through unwrapped.
+  if (telemetry?.isEnabled === false) {
+    return {};
+  }
+
+  const localIntegrations = telemetry?.integrations;
+  const integrations: Array<Telemetry> =
+    localIntegrations != null
+      ? asArray(localIntegrations)
+      : getGlobalTelemetryIntegrations();
+
+  const telemetryMetadata = {
+    recordInputs: telemetry?.recordInputs,
+    recordOutputs: telemetry?.recordOutputs,
+    functionId: telemetry?.functionId,
+  };
+
+  const mergeTelemetryCallback = <KEY extends TelemetryCallbackKey>(
+    key: KEY,
+  ): Callback<TelemetryEvent<KEY>> => {
+    return mergeCallbacks(
+      ...(
+        integrations
+          .map(integration => integration[key]?.bind(integration))
+          .filter(Boolean) as Array<
+          Callback<InferTelemetryEvent<TelemetryEvent<KEY>>>
+        >
+      ).map(
+        callback =>
+          ((event: TelemetryEvent<KEY>) =>
+            callback(augmentEvent(event, telemetryMetadata))) as Callback<
+            TelemetryEvent<KEY>
+          >,
+      ),
+    );
+  };
+
+  const executeWrappers = integrations
+    .map(integration => integration.executeTool?.bind(integration))
+    .filter(Boolean) as Array<NonNullable<Telemetry['executeTool']>>;
+
+  return {
+    onStart: mergeTelemetryCallback('onStart'),
+    onStepStart: mergeTelemetryCallback('onStepStart'),
+    onLanguageModelCallStart: mergeTelemetryCallback(
+      'onLanguageModelCallStart',
+    ),
+    onLanguageModelCallEnd: mergeTelemetryCallback('onLanguageModelCallEnd'),
+    onToolExecutionStart: mergeTelemetryCallback('onToolExecutionStart'),
+    onToolExecutionEnd: mergeTelemetryCallback('onToolExecutionEnd'),
+    onChunk: mergeTelemetryCallback('onChunk'),
+    onStepFinish: mergeTelemetryCallback('onStepFinish'),
+    onObjectStepStart: mergeTelemetryCallback('onObjectStepStart'),
+    onObjectStepFinish: mergeTelemetryCallback('onObjectStepFinish'),
+    onEmbedStart: mergeTelemetryCallback('onEmbedStart'),
+    onEmbedFinish: mergeTelemetryCallback('onEmbedFinish'),
+    onRerankStart: mergeTelemetryCallback('onRerankStart'),
+    onRerankFinish: mergeTelemetryCallback('onRerankFinish'),
+    onFinish: mergeTelemetryCallback('onFinish'),
+    onError: mergeTelemetryCallback('onError'),
+
+    /**
+     * Composes all `executeTool` wrappers around the original tool execution.
+     * Each wrapper receives an `execute` function that calls the next wrapper in
+     * the chain, so integrations can establish nested telemetry context before
+     * delegating to the underlying tool.
+     */
+    executeTool:
+      executeWrappers.length > 0
+        ? async args => {
+            let execute = args.execute;
+            for (const executeWrapper of executeWrappers) {
+              const innerExecute = execute;
+              execute = () =>
+                executeWrapper({ ...args, execute: innerExecute });
+            }
+            return await execute();
+          }
+        : undefined,
+  };
+}

package/bench/refs/node-sdk/src/telemetry/telemetry-registry.ts

@@ -0,0 +1,15 @@
+import type { Telemetry } from './telemetry';
+
+/**
+ * Registers one or more telemetry integrations globally.
+ */
+export function registerTelemetry(...integrations: Telemetry[]): void {
+  if (!globalThis.AI_SDK_TELEMETRY_INTEGRATIONS) {
+    globalThis.AI_SDK_TELEMETRY_INTEGRATIONS = [];
+  }
+  globalThis.AI_SDK_TELEMETRY_INTEGRATIONS.push(...integrations);
+}
+
+export function getGlobalTelemetryIntegrations(): Telemetry[] {
+  return globalThis.AI_SDK_TELEMETRY_INTEGRATIONS ?? [];
+}

package/bench/refs/node-sdk/src/telemetry/telemetry.ts

@@ -0,0 +1,223 @@
+import type { ToolSet } from '@ai-sdk/provider-utils';
+import type {
+  EmbedEndEvent,
+  EmbedStartEvent,
+  EmbeddingModelCallEndEvent,
+  EmbeddingModelCallStartEvent,
+} from '../embed/embed-events';
+import type {
+  GenerateObjectEndEvent,
+  GenerateObjectStartEvent,
+  GenerateObjectStepEndEvent,
+  GenerateObjectStepStartEvent,
+} from '../generate-object/structured-output-events';
+import type {
+  StreamTextChunkEvent,
+  GenerateTextEndEvent,
+  GenerateTextStartEvent,
+  GenerateTextStepEndEvent,
+  GenerateTextStepStartEvent,
+} from '../generate-text/core-events';
+import type {
+  LanguageModelCallEndEvent,
+  LanguageModelCallStartEvent,
+  OnLanguageModelCallEndCallback,
+  OnLanguageModelCallStartCallback,
+} from '../generate-text/language-model-events';
+import type {
+  ToolExecutionEndEvent,
+  ToolExecutionStartEvent,
+} from '../generate-text/tool-execution-events';
+import type {
+  RerankEndEvent,
+  RerankStartEvent,
+  RerankingModelCallEndEvent,
+  RerankingModelCallStartEvent,
+} from '../rerank/rerank-events';
+import type { Callback } from '../util/callback';
+import { TelemetryOptions } from '../telemetry/telemetry-options';
+
+export type InferTelemetryEvent<EVENT> = EVENT &
+  Omit<TelemetryOptions, 'integrations' | 'isEnabled'>;
+
+type OperationStartEvent =
+  | GenerateTextStartEvent
+  | GenerateObjectStartEvent
+  | EmbedStartEvent
+  | RerankStartEvent;
+
+type OperationFinishEvent =
+  | GenerateTextEndEvent<ToolSet>
+  | GenerateObjectEndEvent<unknown>
+  | EmbedEndEvent
+  | RerankEndEvent;
+
+export interface TelemetryDispatcher {
+  onStart?: Callback<OperationStartEvent>;
+  onStepStart?: Callback<GenerateTextStepStartEvent>;
+  onLanguageModelCallStart?: OnLanguageModelCallStartCallback;
+  onLanguageModelCallEnd?: OnLanguageModelCallEndCallback;
+  onToolExecutionStart?: Callback<ToolExecutionStartEvent>;
+  onToolExecutionEnd?: Callback<ToolExecutionEndEvent>;
+  onChunk?: Callback<StreamTextChunkEvent>;
+  onStepFinish?: Callback<GenerateTextStepEndEvent>;
+  onObjectStepStart?: Callback<GenerateObjectStepStartEvent>;
+  onObjectStepFinish?: Callback<GenerateObjectStepEndEvent>;
+  onEmbedStart?: Callback<EmbeddingModelCallStartEvent>;
+  onEmbedFinish?: Callback<EmbeddingModelCallEndEvent>;
+  onRerankStart?: Callback<RerankingModelCallStartEvent>;
+  onRerankFinish?: Callback<RerankingModelCallEndEvent>;
+  onFinish?: Callback<OperationFinishEvent>;
+  onError?: Callback<unknown>;
+  executeTool?: Telemetry['executeTool'];
+}
+
+/**
+ * Implement this interface to create custom telemetry integrations.
+ * Methods can be sync or return a PromiseLike.
+ */
+export interface Telemetry {
+  /**
+   * Called when an operation begins. Fired for text generation
+   * (generateText/streamText), object generation (generateObject/streamObject),
+   * embedding (embed/embedMany), and reranking operations.
+   *
+   * Use the `operationId` field to distinguish between operation types.
+   */
+  onStart?: Callback<InferTelemetryEvent<OperationStartEvent>>;
+
+  /**
+   * 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?: Callback<InferTelemetryEvent<GenerateTextStepStartEvent>>;
+
+  /**
+   * Called immediately before the provider model call begins.
+   * Unlike `onStepStart`, this callback is scoped to model work only and
+   * excludes any later client-side tool execution.
+   */
+  onLanguageModelCallStart?: Callback<
+    InferTelemetryEvent<LanguageModelCallStartEvent>
+  >;
+
+  /**
+   * Called after the model response has been normalized and parsed, but before
+   * any client-side tool execution begins.
+   */
+  onLanguageModelCallEnd?: Callback<
+    InferTelemetryEvent<LanguageModelCallEndEvent>
+  >;
+
+  /**
+   * 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.
+   */
+  onToolExecutionStart?: Callback<InferTelemetryEvent<ToolExecutionStartEvent>>;
+
+  /**
+   * 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.
+   */
+  onToolExecutionEnd?: Callback<InferTelemetryEvent<ToolExecutionEndEvent>>;
+
+  /**
+   * Called for each chunk received during streaming.
+   * Only relevant for `streamText` — not called during `generateText`.
+   */
+  onChunk?: Callback<StreamTextChunkEvent>;
+
+  /**
+   * 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?: Callback<InferTelemetryEvent<GenerateTextStepEndEvent>>;
+
+  /**
+   * Called when an object generation step (single LLM invocation) begins.
+   * For generateObject/streamObject there is always exactly one step.
+   *
+   * @deprecated
+   */
+  onObjectStepStart?: Callback<
+    InferTelemetryEvent<GenerateObjectStepStartEvent>
+  >;
+
+  /**
+   * Called when an object generation step (single LLM invocation) completes,
+   * with the raw result before JSON parsing and schema validation.
+   *
+   * @deprecated
+   */
+  onObjectStepFinish?: Callback<
+    InferTelemetryEvent<GenerateObjectStepEndEvent>
+  >;
+
+  /**
+   * Called when an individual embedding model call (doEmbed) begins.
+   * For `embed`, there is one call. For `embedMany`, there may be multiple
+   * calls when values are chunked.
+   */
+  onEmbedStart?: Callback<InferTelemetryEvent<EmbeddingModelCallStartEvent>>;
+
+  /**
+   * Called when an individual embedding model call (doEmbed) completes.
+   * Contains the embeddings, usage, and any warnings from the model response.
+   */
+  onEmbedFinish?: Callback<InferTelemetryEvent<EmbeddingModelCallEndEvent>>;
+
+  /**
+   * Called when an individual reranking model call (doRerank) begins.
+   * There is one call per `rerank` invocation.
+   */
+  onRerankStart?: Callback<InferTelemetryEvent<RerankingModelCallStartEvent>>;
+
+  /**
+   * Called when an individual reranking model call (doRerank) completes.
+   * Contains the ranking results from the model response.
+   */
+  onRerankFinish?: Callback<InferTelemetryEvent<RerankingModelCallEndEvent>>;
+
+  /**
+   * Called when an operation completes. Fired for text generation
+   * (generateText/streamText), object generation (generateObject/streamObject),
+   * embedding (embed/embedMany), and reranking operations.
+   *
+   * Use the event shape or `operationId` to distinguish between operation types.
+   */
+  onFinish?: Callback<InferTelemetryEvent<OperationFinishEvent>>;
+
+  /**
+   * 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?: Callback<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 options.callId - The call ID of the tool call.
+   * @param options.toolCallId - The tool call ID.
+   * @param options.execute - The function to execute.
+   */
+  executeTool?: <T>(options: {
+    callId: string;
+    toolCallId: string;
+    execute: () => PromiseLike<T>;
+  }) => PromiseLike<T>;
+}

package/bench/refs/node-sdk/src/util/async-iterable-stream.ts

@@ -0,0 +1,94 @@
+/**
+ * A type that combines AsyncIterable and ReadableStream.
+ * This allows a ReadableStream to be consumed using for-await-of syntax.
+ */
+export type AsyncIterableStream<T> = AsyncIterable<T> & ReadableStream<T>;
+
+/**
+ * Wraps a ReadableStream and returns an object that is both a ReadableStream and an AsyncIterable.
+ * This enables consumption of the stream using for-await-of, with proper resource cleanup on early exit or error.
+ *
+ * @template T The type of the stream's chunks.
+ * @param source The source ReadableStream to wrap.
+ * @returns An AsyncIterableStream that can be used as both a ReadableStream and an AsyncIterable.
+ */
+export function createAsyncIterableStream<T>(
+  source: ReadableStream<T>,
+): AsyncIterableStream<T> {
+  // Pipe through a TransformStream to ensure a fresh, unlocked stream.
+  const stream = source.pipeThrough(new TransformStream<T, T>());
+
+  /**
+   * Implements the async iterator protocol for the stream.
+   * Ensures proper cleanup (cancelling and releasing the reader) on completion, early exit, or error.
+   */
+  (stream as AsyncIterableStream<T>)[Symbol.asyncIterator] = function (
+    this: ReadableStream<T>,
+  ): AsyncIterator<T> {
+    const reader = this.getReader();
+
+    let finished = false;
+
+    /**
+     * Cleans up the reader by cancelling and releasing the lock.
+     */
+    async function cleanup(cancelStream: boolean) {
+      if (finished) return;
+
+      finished = true;
+      try {
+        if (cancelStream) {
+          await reader.cancel?.();
+        }
+      } finally {
+        try {
+          reader.releaseLock();
+        } catch {}
+      }
+    }
+
+    return {
+      /**
+       * Reads the next chunk from the stream.
+       * @returns A promise resolving to the next IteratorResult.
+       */
+      async next(): Promise<IteratorResult<T>> {
+        if (finished) {
+          return { done: true, value: undefined };
+        }
+
+        const { done, value } = await reader.read();
+
+        if (done) {
+          await cleanup(true);
+          return { done: true, value: undefined };
+        }
+
+        return { done: false, value };
+      },
+
+      /**
+       * May be called on early exit (e.g., break from for-await) or after completion.
+       * Ensures the stream is cancelled and resources are released.
+       * @returns A promise resolving to a completed IteratorResult.
+       */
+      async return(): Promise<IteratorResult<T>> {
+        await cleanup(true);
+        return { done: true, value: undefined };
+      },
+
+      /**
+       * Called on early exit with error.
+       * Ensures the stream is cancelled and resources are released, then rethrows the error.
+       * @param err The error to throw.
+       * @returns A promise that rejects with the provided error.
+       */
+      async throw(err: unknown): Promise<IteratorResult<T>> {
+        await cleanup(true);
+        throw err;
+      },
+    };
+  };
+
+  return stream as AsyncIterableStream<T>;
+}

package/bench/refs/node-sdk/src/util/consume-stream.ts

@@ -0,0 +1,31 @@
+/**
+ * Consumes a ReadableStream until it's fully read.
+ *
+ * This function reads the stream chunk by chunk until the stream is exhausted.
+ * It doesn't process or return the data from the stream; it simply ensures
+ * that the entire stream is read.
+ *
+ * @param options - The options for consuming the stream.
+ * @param options.stream - The ReadableStream to be consumed.
+ * @param options.onError - Optional callback to handle errors that occur during consumption.
+ * @returns A promise that resolves when the stream is fully consumed.
+ */
+export async function consumeStream({
+  stream,
+  onError,
+}: {
+  stream: ReadableStream;
+  onError?: (error: unknown) => void;
+}): Promise<void> {
+  const reader = stream.getReader();
+  try {
+    while (true) {
+      const { done } = await reader.read();
+      if (done) break;
+    }
+  } catch (error) {
+    onError?.(error);
+  } finally {
+    reader.releaseLock();
+  }
+}