ashlr-plugin 1.36.4

package/bench/refs/node-sdk/src/agent/tool-loop-agent.ts

@@ -0,0 +1,238 @@
+import type { Context, ModelMessage, ToolSet } from '@ai-sdk/provider-utils';
+import { generateText } from '../generate-text/generate-text';
+import { GenerateTextResult } from '../generate-text/generate-text-result';
+import { Output } from '../generate-text/output';
+import { isStepCount } from '../generate-text/stop-condition';
+import { streamText } from '../generate-text/stream-text';
+import { StreamTextResult } from '../generate-text/stream-text-result';
+import { Prompt } from '../prompt';
+import { mergeCallbacks } from '../util/merge-callbacks';
+import { Agent, AgentCallParameters, AgentStreamParameters } from './agent';
+import {
+  ToolLoopAgentOnStartCallback,
+  ToolLoopAgentOnStepStartCallback,
+  ToolLoopAgentSettings,
+} from './tool-loop-agent-settings';
+
+/**
+ * A tool loop agent is an agent that runs tools in a loop. In each step,
+ * it calls the LLM, and if there are tool calls, it executes the tools
+ * and calls the LLM again in a new step with the tool results.
+ *
+ * The loop continues until:
+ * - A finish reasoning other than tool-calls is returned, or
+ * - A tool that is invoked does not have an execute function, or
+ * - A tool call needs approval via `toolApproval` or tool-level `needsApproval`, or
+ * - A stop condition is met (default stop condition is isStepCount(20))
+ */
+export class ToolLoopAgent<
+  CALL_OPTIONS = never,
+  TOOLS extends ToolSet = {},
+  RUNTIME_CONTEXT extends Context = Context,
+  OUTPUT extends Output = never,
+> implements Agent<CALL_OPTIONS, TOOLS, RUNTIME_CONTEXT, OUTPUT> {
+  readonly version = 'agent-v1';
+
+  private readonly settings: ToolLoopAgentSettings<
+    CALL_OPTIONS,
+    TOOLS,
+    RUNTIME_CONTEXT,
+    OUTPUT
+  >;
+
+  constructor(
+    settings: ToolLoopAgentSettings<
+      CALL_OPTIONS,
+      TOOLS,
+      RUNTIME_CONTEXT,
+      OUTPUT
+    >,
+  ) {
+    this.settings = settings;
+  }
+
+  /**
+   * The id of the agent.
+   */
+  get id(): string | undefined {
+    return this.settings.id;
+  }
+
+  /**
+   * The tools that the agent can use.
+   */
+  get tools(): TOOLS {
+    return this.settings.tools as TOOLS;
+  }
+
+  private async prepareCall(options: {
+    prompt?: string | Array<ModelMessage>;
+    messages?: Array<ModelMessage>;
+    options?: CALL_OPTIONS;
+  }): Promise<
+    Omit<
+      ToolLoopAgentSettings<CALL_OPTIONS, TOOLS, RUNTIME_CONTEXT, OUTPUT>,
+      | 'prepareCall'
+      | 'instructions'
+      | 'experimental_onStart'
+      | 'experimental_onStepStart'
+      | 'experimental_onToolExecutionStart'
+      | 'experimental_onToolExecutionEnd'
+      | 'onStepFinish'
+      | 'onFinish'
+    > &
+      Prompt
+  > {
+    const {
+      experimental_onStart: _settingsOnStart,
+      experimental_onStepStart: _settingsOnStepStart,
+      experimental_onToolExecutionStart: _settingsOnToolExecutionStart,
+      experimental_onToolExecutionEnd: _settingsOnToolExecutionEnd,
+      onStepFinish: _settingsOnStepFinish,
+      onFinish: _settingsOnFinish,
+      ...settingsWithoutCallbacks
+    } = this.settings;
+
+    const baseCallArgs = {
+      ...settingsWithoutCallbacks,
+      stopWhen: this.settings.stopWhen ?? isStepCount(20),
+      ...options,
+    };
+
+    const preparedCallArgs =
+      (await this.settings.prepareCall?.(
+        baseCallArgs as Parameters<
+          NonNullable<
+            ToolLoopAgentSettings<
+              CALL_OPTIONS,
+              TOOLS,
+              RUNTIME_CONTEXT,
+              OUTPUT
+            >['prepareCall']
+          >
+        >[0],
+      )) ?? baseCallArgs;
+
+    const { instructions, messages, prompt, runtimeContext, ...callArgs } =
+      preparedCallArgs;
+
+    const promptArgs = { system: instructions, messages, prompt } as Prompt;
+
+    if (runtimeContext === undefined) {
+      return {
+        ...callArgs,
+        ...promptArgs,
+      };
+    }
+
+    return {
+      ...callArgs,
+      runtimeContext,
+      ...promptArgs,
+    };
+  }
+
+  /**
+   * Generates an output from the agent (non-streaming).
+   */
+  async generate({
+    abortSignal,
+    timeout,
+    experimental_onStart,
+    experimental_onStepStart,
+    experimental_onToolExecutionStart,
+    experimental_onToolExecutionEnd,
+    onStepFinish,
+    onFinish,
+    ...options
+  }: AgentCallParameters<CALL_OPTIONS, TOOLS, RUNTIME_CONTEXT>): Promise<
+    GenerateTextResult<TOOLS, RUNTIME_CONTEXT, OUTPUT>
+  > {
+    const generate = generateText<TOOLS, RUNTIME_CONTEXT, OUTPUT>;
+    const preparedCall = await this.prepareCall(options);
+    const callbackArgs = {
+      abortSignal,
+      timeout,
+      experimental_onStart: mergeCallbacks(
+        this.settings.experimental_onStart,
+        experimental_onStart as
+          | ToolLoopAgentOnStartCallback<TOOLS, RUNTIME_CONTEXT, OUTPUT>
+          | undefined,
+      ),
+      experimental_onStepStart: mergeCallbacks(
+        this.settings.experimental_onStepStart,
+        experimental_onStepStart as
+          | ToolLoopAgentOnStepStartCallback<TOOLS, RUNTIME_CONTEXT, OUTPUT>
+          | undefined,
+      ),
+      experimental_onToolExecutionStart: mergeCallbacks(
+        this.settings.experimental_onToolExecutionStart,
+        experimental_onToolExecutionStart,
+      ),
+      experimental_onToolExecutionEnd: mergeCallbacks(
+        this.settings.experimental_onToolExecutionEnd,
+        experimental_onToolExecutionEnd,
+      ),
+      onStepFinish: mergeCallbacks(this.settings.onStepFinish, onStepFinish),
+      onFinish: mergeCallbacks(this.settings.onFinish, onFinish),
+    };
+
+    return await generate({
+      ...preparedCall,
+      ...callbackArgs,
+    } as unknown as Parameters<typeof generate>[0]);
+  }
+
+  /**
+   * Streams an output from the agent (streaming).
+   */
+  async stream({
+    abortSignal,
+    timeout,
+    experimental_transform,
+    experimental_onStart,
+    experimental_onStepStart,
+    experimental_onToolExecutionStart,
+    experimental_onToolExecutionEnd,
+    onStepFinish,
+    onFinish,
+    ...options
+  }: AgentStreamParameters<CALL_OPTIONS, TOOLS, RUNTIME_CONTEXT>): Promise<
+    StreamTextResult<TOOLS, RUNTIME_CONTEXT, OUTPUT>
+  > {
+    const stream = streamText<TOOLS, RUNTIME_CONTEXT, OUTPUT>;
+    const preparedCall = await this.prepareCall(options);
+    const callbackArgs = {
+      abortSignal,
+      timeout,
+      experimental_transform,
+      experimental_onStart: mergeCallbacks(
+        this.settings.experimental_onStart,
+        experimental_onStart as
+          | ToolLoopAgentOnStartCallback<TOOLS, RUNTIME_CONTEXT, OUTPUT>
+          | undefined,
+      ),
+      experimental_onStepStart: mergeCallbacks(
+        this.settings.experimental_onStepStart,
+        experimental_onStepStart as
+          | ToolLoopAgentOnStepStartCallback<TOOLS, RUNTIME_CONTEXT, OUTPUT>
+          | undefined,
+      ),
+      experimental_onToolExecutionStart: mergeCallbacks(
+        this.settings.experimental_onToolExecutionStart,
+        experimental_onToolExecutionStart,
+      ),
+      experimental_onToolExecutionEnd: mergeCallbacks(
+        this.settings.experimental_onToolExecutionEnd,
+        experimental_onToolExecutionEnd,
+      ),
+      onStepFinish: mergeCallbacks(this.settings.onStepFinish, onStepFinish),
+      onFinish: mergeCallbacks(this.settings.onFinish, onFinish),
+    };
+
+    return await stream({
+      ...preparedCall,
+      ...callbackArgs,
+    } as unknown as Parameters<typeof stream>[0]);
+  }
+}

package/bench/refs/node-sdk/src/embed/embed-many.ts

@@ -0,0 +1,409 @@
+import {
+  createIdGenerator,
+  ProviderOptions,
+  withUserAgentSuffix,
+} from '@ai-sdk/provider-utils';
+import { logWarnings } from '../logger/log-warnings';
+import { resolveEmbeddingModel } from '../model/resolve-model';
+import { createTelemetryDispatcher } from '../telemetry/create-telemetry-dispatcher';
+import { TelemetryOptions } from '../telemetry/telemetry-options';
+import { Embedding, EmbeddingModel, ProviderMetadata } from '../types';
+import { Warning } from '../types/warning';
+import type { Callback } from '../util/callback';
+import { notify } from '../util/notify';
+import { prepareRetries } from '../util/prepare-retries';
+import { splitArray } from '../util/split-array';
+import type { EmbedEndEvent, EmbedStartEvent } from './embed-events';
+import { EmbedManyResult } from './embed-many-result';
+import { VERSION } from '../version';
+
+const originalGenerateCallId = createIdGenerator({
+  prefix: 'call',
+  size: 24,
+});
+
+/**
+ * Embed several values using an embedding model. The type of the value is defined
+ * by the embedding model.
+ *
+ * `embedMany` automatically splits large requests into smaller chunks if the model
+ * has a limit on how many embeddings can be generated in a single call.
+ *
+ * @param model - The embedding model to use.
+ * @param values - The values that should be embedded.
+ *
+ * @param maxRetries - Maximum number of retries. Set to 0 to disable retries. Default: 2.
+ * @param abortSignal - An optional abort signal that can be used to cancel the call.
+ * @param headers - Additional HTTP headers to be sent with the request. Only applicable for HTTP-based providers.
+ *
+ * @param maxParallelCalls - Maximum number of concurrent requests. Default: Infinity.
+ *
+ * @param telemetry - Optional telemetry configuration.
+ *
+ * @param providerOptions - Additional provider-specific options. They are passed through
+ * to the provider from the AI SDK and enable provider-specific
+ * functionality that can be fully encapsulated in the provider.
+ *
+ * @returns A result object that contains the embeddings, the value, and additional information.
+ */
+export async function embedMany({
+  model: modelArg,
+  values,
+  maxParallelCalls = Infinity,
+  maxRetries: maxRetriesArg,
+  abortSignal,
+  headers,
+  providerOptions,
+  experimental_telemetry,
+  telemetry = experimental_telemetry,
+  experimental_onStart: onStart,
+  experimental_onFinish: onFinish,
+  _internal: { generateCallId = originalGenerateCallId } = {},
+}: {
+  /**
+   * The embedding model to use.
+   */
+  model: EmbeddingModel;
+
+  /**
+   * The values that should be embedded.
+   */
+  values: Array<string>;
+
+  /**
+   * Maximum number of retries per embedding model call. Set to 0 to disable retries.
+   *
+   * @default 2
+   */
+  maxRetries?: number;
+
+  /**
+   * Abort signal.
+   */
+  abortSignal?: AbortSignal;
+
+  /**
+   * Additional headers to include in the request.
+   * Only applicable for HTTP-based providers.
+   */
+  headers?: Record<string, string>;
+
+  /**
+   * Optional telemetry configuration.
+   */
+  telemetry?: TelemetryOptions;
+
+  /**
+   * Optional telemetry configuration.
+   *
+   * @deprecated Use `telemetry` instead. This alias will be removed in a future major release.
+   */
+  experimental_telemetry?: TelemetryOptions;
+
+  /**
+   * Additional provider-specific options. They are passed through
+   * to the provider from the AI SDK and enable provider-specific
+   * functionality that can be fully encapsulated in the provider.
+   */
+  providerOptions?: ProviderOptions;
+
+  /**
+   * Maximum number of concurrent requests.
+   *
+   * @default Infinity
+   */
+  maxParallelCalls?: number;
+
+  /**
+   * Callback that is called when the embedMany operation begins,
+   * before the embedding model is called.
+   */
+  experimental_onStart?: Callback<EmbedStartEvent>;
+
+  /**
+   * Callback that is called when the embedMany operation completes,
+   * after all embedding model calls return.
+   */
+  experimental_onFinish?: Callback<EmbedEndEvent>;
+
+  /**
+   * Internal. For test use only. May change without notice.
+   */
+  _internal?: {
+    generateCallId?: () => string;
+  };
+}): Promise<EmbedManyResult> {
+  const model = resolveEmbeddingModel(modelArg);
+
+  const { maxRetries, retry } = prepareRetries({
+    maxRetries: maxRetriesArg,
+    abortSignal,
+  });
+
+  const headersWithUserAgent = withUserAgentSuffix(
+    headers ?? {},
+    `ai/${VERSION}`,
+  );
+
+  const callId = generateCallId();
+
+  const telemetryDispatcher = createTelemetryDispatcher({
+    telemetry,
+  });
+
+  await notify({
+    event: {
+      callId,
+      operationId: 'ai.embedMany',
+      provider: model.provider,
+      modelId: model.modelId,
+      value: values,
+      maxRetries,
+      headers: headersWithUserAgent,
+      providerOptions,
+    },
+    callbacks: [onStart, telemetryDispatcher.onStart],
+  });
+
+  try {
+    const [maxEmbeddingsPerCall, supportsParallelCalls] = await Promise.all([
+      model.maxEmbeddingsPerCall,
+      model.supportsParallelCalls,
+    ]);
+
+    if (maxEmbeddingsPerCall == null || maxEmbeddingsPerCall === Infinity) {
+      const { embeddings, usage, warnings, response, providerMetadata } =
+        await retry(async () => {
+          const embedCallId = generateCallId();
+
+          await notify({
+            event: {
+              callId,
+              embedCallId,
+              operationId: 'ai.embedMany.doEmbed',
+              provider: model.provider,
+              modelId: model.modelId,
+              values,
+            },
+            callbacks: [telemetryDispatcher.onEmbedStart],
+          });
+
+          const modelResponse = await model.doEmbed({
+            values,
+            abortSignal,
+            headers: headersWithUserAgent,
+            providerOptions,
+          });
+
+          const embeddings = modelResponse.embeddings;
+          const usage = modelResponse.usage ?? { tokens: NaN };
+
+          await notify({
+            event: {
+              callId,
+              embedCallId,
+              operationId: 'ai.embedMany.doEmbed',
+              provider: model.provider,
+              modelId: model.modelId,
+              values,
+              embeddings,
+              usage,
+            },
+            callbacks: [telemetryDispatcher.onEmbedFinish],
+          });
+
+          return {
+            embeddings,
+            usage,
+            warnings: modelResponse.warnings,
+            providerMetadata: modelResponse.providerMetadata,
+            response: modelResponse.response,
+          };
+        });
+
+      logWarnings({
+        warnings,
+        provider: model.provider,
+        model: model.modelId,
+      });
+
+      await notify({
+        event: {
+          callId,
+          operationId: 'ai.embedMany',
+          provider: model.provider,
+          modelId: model.modelId,
+          value: values,
+          embedding: embeddings,
+          usage,
+          warnings,
+          providerMetadata,
+          response: [response],
+        },
+        callbacks: [onFinish, telemetryDispatcher.onFinish],
+      });
+
+      return new DefaultEmbedManyResult({
+        values,
+        embeddings,
+        usage,
+        warnings,
+        providerMetadata,
+        responses: [response],
+      });
+    }
+
+    const valueChunks = splitArray(values, maxEmbeddingsPerCall);
+
+    const embeddings: Array<Embedding> = [];
+    const warnings: Array<Warning> = [];
+    const responses: Array<
+      | {
+          headers?: Record<string, string>;
+          body?: unknown;
+        }
+      | undefined
+    > = [];
+    let tokens = 0;
+    let providerMetadata: ProviderMetadata | undefined;
+
+    const parallelChunks = splitArray(
+      valueChunks,
+      supportsParallelCalls ? maxParallelCalls : 1,
+    );
+
+    for (const parallelChunk of parallelChunks) {
+      const results = await Promise.all(
+        parallelChunk.map(chunk => {
+          return retry(async () => {
+            const embedCallId = generateCallId();
+
+            await notify({
+              event: {
+                callId,
+                embedCallId,
+                operationId: 'ai.embedMany.doEmbed',
+                provider: model.provider,
+                modelId: model.modelId,
+                values: chunk,
+              },
+              callbacks: [telemetryDispatcher.onEmbedStart],
+            });
+
+            const modelResponse = await model.doEmbed({
+              values: chunk,
+              abortSignal,
+              headers: headersWithUserAgent,
+              providerOptions,
+            });
+
+            const chunkEmbeddings = modelResponse.embeddings;
+            const usage = modelResponse.usage ?? { tokens: NaN };
+
+            await notify({
+              event: {
+                callId,
+                embedCallId,
+                operationId: 'ai.embedMany.doEmbed',
+                provider: model.provider,
+                modelId: model.modelId,
+                values: chunk,
+                embeddings: chunkEmbeddings,
+                usage,
+              },
+              callbacks: [telemetryDispatcher.onEmbedFinish],
+            });
+
+            return {
+              embeddings: chunkEmbeddings,
+              usage,
+              warnings: modelResponse.warnings,
+              providerMetadata: modelResponse.providerMetadata,
+              response: modelResponse.response,
+            };
+          });
+        }),
+      );
+
+      for (const result of results) {
+        embeddings.push(...result.embeddings);
+        warnings.push(...result.warnings);
+        responses.push(result.response);
+        tokens += result.usage.tokens;
+        if (result.providerMetadata) {
+          if (!providerMetadata) {
+            providerMetadata = { ...result.providerMetadata };
+          } else {
+            for (const [providerName, metadata] of Object.entries(
+              result.providerMetadata,
+            )) {
+              providerMetadata[providerName] = {
+                ...(providerMetadata[providerName] ?? {}),
+                ...metadata,
+              };
+            }
+          }
+        }
+      }
+    }
+
+    logWarnings({
+      warnings,
+      provider: model.provider,
+      model: model.modelId,
+    });
+
+    await notify({
+      event: {
+        callId,
+        operationId: 'ai.embedMany',
+        provider: model.provider,
+        modelId: model.modelId,
+        value: values,
+        embedding: embeddings,
+        usage: { tokens },
+        warnings,
+        providerMetadata,
+        response: responses,
+      },
+      callbacks: [onFinish, telemetryDispatcher.onFinish],
+    });
+
+    return new DefaultEmbedManyResult({
+      values,
+      embeddings,
+      usage: { tokens },
+      warnings,
+      providerMetadata: providerMetadata,
+      responses,
+    });
+  } catch (error) {
+    await telemetryDispatcher.onError?.({ callId, error });
+    throw error;
+  }
+}
+
+class DefaultEmbedManyResult implements EmbedManyResult {
+  readonly values: EmbedManyResult['values'];
+  readonly embeddings: EmbedManyResult['embeddings'];
+  readonly usage: EmbedManyResult['usage'];
+  readonly warnings: EmbedManyResult['warnings'];
+  readonly providerMetadata: EmbedManyResult['providerMetadata'];
+  readonly responses: EmbedManyResult['responses'];
+
+  constructor(options: {
+    values: EmbedManyResult['values'];
+    embeddings: EmbedManyResult['embeddings'];
+    usage: EmbedManyResult['usage'];
+    warnings: EmbedManyResult['warnings'];
+    providerMetadata?: EmbedManyResult['providerMetadata'];
+    responses?: EmbedManyResult['responses'];
+  }) {
+    this.values = options.values;
+    this.embeddings = options.embeddings;
+    this.usage = options.usage;
+    this.warnings = options.warnings;
+    this.providerMetadata = options.providerMetadata;
+    this.responses = options.responses;
+  }
+}

package/bench/refs/node-sdk/src/embed/embed-result.ts

@@ -0,0 +1,50 @@
+import { Embedding } from '../types';
+import { EmbeddingModelUsage } from '../types/usage';
+import { ProviderMetadata } from '../types';
+import { Warning } from '../types/warning';
+
+/**
+ * The result of an `embed` call.
+ * It contains the embedding, the value, and additional information.
+ */
+export interface EmbedResult {
+  /**
+   * The value that was embedded.
+   */
+  readonly value: string;
+
+  /**
+   * The embedding of the value.
+   */
+  readonly embedding: Embedding;
+
+  /**
+   * The embedding token usage.
+   */
+  readonly usage: EmbeddingModelUsage;
+
+  /**
+   * Warnings for the call, e.g. unsupported settings.
+   */
+  readonly warnings: Array<Warning>;
+
+  /**
+   * Optional provider-specific metadata.
+   */
+  readonly providerMetadata?: ProviderMetadata;
+
+  /**
+   * Optional response data.
+   */
+  readonly response?: {
+    /**
+     * Response headers.
+     */
+    headers?: Record<string, string>;
+
+    /**
+     * The response body.
+     */
+    body?: unknown;
+  };
+}