ima2-gen 3.20.0 → 3.21.0

package/node_modules/ai/src/util/fix-json.ts

@@ -1,401 +0,0 @@
-type State =
-  | 'ROOT'
-  | 'FINISH'
-  | 'INSIDE_STRING'
-  | 'INSIDE_STRING_ESCAPE'
-  | 'INSIDE_LITERAL'
-  | 'INSIDE_NUMBER'
-  | 'INSIDE_OBJECT_START'
-  | 'INSIDE_OBJECT_KEY'
-  | 'INSIDE_OBJECT_AFTER_KEY'
-  | 'INSIDE_OBJECT_BEFORE_VALUE'
-  | 'INSIDE_OBJECT_AFTER_VALUE'
-  | 'INSIDE_OBJECT_AFTER_COMMA'
-  | 'INSIDE_ARRAY_START'
-  | 'INSIDE_ARRAY_AFTER_VALUE'
-  | 'INSIDE_ARRAY_AFTER_COMMA';
-
-// Implemented as a scanner with additional fixing
-// that performs a single linear time scan pass over the partial JSON.
-//
-// The states should ideally match relevant states from the JSON spec:
-// https://www.json.org/json-en.html
-//
-// Please note that invalid JSON is not considered/covered, because it
-// is assumed that the resulting JSON will be processed by a standard
-// JSON parser that will detect any invalid JSON.
-export function fixJson(input: string): string {
-  const stack: State[] = ['ROOT'];
-  let lastValidIndex = -1;
-  let literalStart: number | null = null;
-
-  function processValueStart(char: string, i: number, swapState: State) {
-    {
-      switch (char) {
-        case '"': {
-          lastValidIndex = i;
-          stack.pop();
-          stack.push(swapState);
-          stack.push('INSIDE_STRING');
-          break;
-        }
-
-        case 'f':
-        case 't':
-        case 'n': {
-          lastValidIndex = i;
-          literalStart = i;
-          stack.pop();
-          stack.push(swapState);
-          stack.push('INSIDE_LITERAL');
-          break;
-        }
-
-        case '-': {
-          stack.pop();
-          stack.push(swapState);
-          stack.push('INSIDE_NUMBER');
-          break;
-        }
-        case '0':
-        case '1':
-        case '2':
-        case '3':
-        case '4':
-        case '5':
-        case '6':
-        case '7':
-        case '8':
-        case '9': {
-          lastValidIndex = i;
-          stack.pop();
-          stack.push(swapState);
-          stack.push('INSIDE_NUMBER');
-          break;
-        }
-
-        case '{': {
-          lastValidIndex = i;
-          stack.pop();
-          stack.push(swapState);
-          stack.push('INSIDE_OBJECT_START');
-          break;
-        }
-
-        case '[': {
-          lastValidIndex = i;
-          stack.pop();
-          stack.push(swapState);
-          stack.push('INSIDE_ARRAY_START');
-          break;
-        }
-      }
-    }
-  }
-
-  function processAfterObjectValue(char: string, i: number) {
-    switch (char) {
-      case ',': {
-        stack.pop();
-        stack.push('INSIDE_OBJECT_AFTER_COMMA');
-        break;
-      }
-      case '}': {
-        lastValidIndex = i;
-        stack.pop();
-        break;
-      }
-    }
-  }
-
-  function processAfterArrayValue(char: string, i: number) {
-    switch (char) {
-      case ',': {
-        stack.pop();
-        stack.push('INSIDE_ARRAY_AFTER_COMMA');
-        break;
-      }
-      case ']': {
-        lastValidIndex = i;
-        stack.pop();
-        break;
-      }
-    }
-  }
-
-  for (let i = 0; i < input.length; i++) {
-    const char = input[i];
-    const currentState = stack[stack.length - 1];
-
-    switch (currentState) {
-      case 'ROOT':
-        processValueStart(char, i, 'FINISH');
-        break;
-
-      case 'INSIDE_OBJECT_START': {
-        switch (char) {
-          case '"': {
-            stack.pop();
-            stack.push('INSIDE_OBJECT_KEY');
-            break;
-          }
-          case '}': {
-            lastValidIndex = i;
-            stack.pop();
-            break;
-          }
-        }
-        break;
-      }
-
-      case 'INSIDE_OBJECT_AFTER_COMMA': {
-        switch (char) {
-          case '"': {
-            stack.pop();
-            stack.push('INSIDE_OBJECT_KEY');
-            break;
-          }
-        }
-        break;
-      }
-
-      case 'INSIDE_OBJECT_KEY': {
-        switch (char) {
-          case '"': {
-            stack.pop();
-            stack.push('INSIDE_OBJECT_AFTER_KEY');
-            break;
-          }
-        }
-        break;
-      }
-
-      case 'INSIDE_OBJECT_AFTER_KEY': {
-        switch (char) {
-          case ':': {
-            stack.pop();
-            stack.push('INSIDE_OBJECT_BEFORE_VALUE');
-
-            break;
-          }
-        }
-        break;
-      }
-
-      case 'INSIDE_OBJECT_BEFORE_VALUE': {
-        processValueStart(char, i, 'INSIDE_OBJECT_AFTER_VALUE');
-        break;
-      }
-
-      case 'INSIDE_OBJECT_AFTER_VALUE': {
-        processAfterObjectValue(char, i);
-        break;
-      }
-
-      case 'INSIDE_STRING': {
-        switch (char) {
-          case '"': {
-            stack.pop();
-            lastValidIndex = i;
-            break;
-          }
-
-          case '\\': {
-            stack.push('INSIDE_STRING_ESCAPE');
-            break;
-          }
-
-          default: {
-            lastValidIndex = i;
-          }
-        }
-
-        break;
-      }
-
-      case 'INSIDE_ARRAY_START': {
-        switch (char) {
-          case ']': {
-            lastValidIndex = i;
-            stack.pop();
-            break;
-          }
-
-          default: {
-            lastValidIndex = i;
-            processValueStart(char, i, 'INSIDE_ARRAY_AFTER_VALUE');
-            break;
-          }
-        }
-        break;
-      }
-
-      case 'INSIDE_ARRAY_AFTER_VALUE': {
-        switch (char) {
-          case ',': {
-            stack.pop();
-            stack.push('INSIDE_ARRAY_AFTER_COMMA');
-            break;
-          }
-
-          case ']': {
-            lastValidIndex = i;
-            stack.pop();
-            break;
-          }
-
-          default: {
-            lastValidIndex = i;
-            break;
-          }
-        }
-
-        break;
-      }
-
-      case 'INSIDE_ARRAY_AFTER_COMMA': {
-        processValueStart(char, i, 'INSIDE_ARRAY_AFTER_VALUE');
-        break;
-      }
-
-      case 'INSIDE_STRING_ESCAPE': {
-        stack.pop();
-        lastValidIndex = i;
-
-        break;
-      }
-
-      case 'INSIDE_NUMBER': {
-        switch (char) {
-          case '0':
-          case '1':
-          case '2':
-          case '3':
-          case '4':
-          case '5':
-          case '6':
-          case '7':
-          case '8':
-          case '9': {
-            lastValidIndex = i;
-            break;
-          }
-
-          case 'e':
-          case 'E':
-          case '-':
-          case '.': {
-            break;
-          }
-
-          case ',': {
-            stack.pop();
-
-            if (stack[stack.length - 1] === 'INSIDE_ARRAY_AFTER_VALUE') {
-              processAfterArrayValue(char, i);
-            }
-
-            if (stack[stack.length - 1] === 'INSIDE_OBJECT_AFTER_VALUE') {
-              processAfterObjectValue(char, i);
-            }
-
-            break;
-          }
-
-          case '}': {
-            stack.pop();
-
-            if (stack[stack.length - 1] === 'INSIDE_OBJECT_AFTER_VALUE') {
-              processAfterObjectValue(char, i);
-            }
-
-            break;
-          }
-
-          case ']': {
-            stack.pop();
-
-            if (stack[stack.length - 1] === 'INSIDE_ARRAY_AFTER_VALUE') {
-              processAfterArrayValue(char, i);
-            }
-
-            break;
-          }
-
-          default: {
-            stack.pop();
-            break;
-          }
-        }
-
-        break;
-      }
-
-      case 'INSIDE_LITERAL': {
-        const partialLiteral = input.substring(literalStart!, i + 1);
-
-        if (
-          !'false'.startsWith(partialLiteral) &&
-          !'true'.startsWith(partialLiteral) &&
-          !'null'.startsWith(partialLiteral)
-        ) {
-          stack.pop();
-
-          if (stack[stack.length - 1] === 'INSIDE_OBJECT_AFTER_VALUE') {
-            processAfterObjectValue(char, i);
-          } else if (stack[stack.length - 1] === 'INSIDE_ARRAY_AFTER_VALUE') {
-            processAfterArrayValue(char, i);
-          }
-        } else {
-          lastValidIndex = i;
-        }
-
-        break;
-      }
-    }
-  }
-
-  let result = input.slice(0, lastValidIndex + 1);
-
-  for (let i = stack.length - 1; i >= 0; i--) {
-    const state = stack[i];
-
-    switch (state) {
-      case 'INSIDE_STRING': {
-        result += '"';
-        break;
-      }
-
-      case 'INSIDE_OBJECT_KEY':
-      case 'INSIDE_OBJECT_AFTER_KEY':
-      case 'INSIDE_OBJECT_AFTER_COMMA':
-      case 'INSIDE_OBJECT_START':
-      case 'INSIDE_OBJECT_BEFORE_VALUE':
-      case 'INSIDE_OBJECT_AFTER_VALUE': {
-        result += '}';
-        break;
-      }
-
-      case 'INSIDE_ARRAY_START':
-      case 'INSIDE_ARRAY_AFTER_COMMA':
-      case 'INSIDE_ARRAY_AFTER_VALUE': {
-        result += ']';
-        break;
-      }
-
-      case 'INSIDE_LITERAL': {
-        const partialLiteral = input.substring(literalStart!, input.length);
-
-        if ('true'.startsWith(partialLiteral)) {
-          result += 'true'.slice(partialLiteral.length);
-        } else if ('false'.startsWith(partialLiteral)) {
-          result += 'false'.slice(partialLiteral.length);
-        } else if ('null'.startsWith(partialLiteral)) {
-          result += 'null'.slice(partialLiteral.length);
-        }
-      }
-    }
-  }
-
-  return result;
-}

package/node_modules/ai/src/util/get-potential-start-index.ts

@@ -1,39 +0,0 @@
-/**
- * Finds the potential starting index where searchedText could begin in text.
- *
- * This function checks for both complete and partial matches:
- * - If searchedText is found as a complete substring, returns the index of the first occurrence.
- * - If the end of text matches the beginning of searchedText (partial match),
- *   returns the index where that partial match starts.
- *
- * @param text - The text to search within.
- * @param searchedText - The text to search for.
- * @returns The starting index of the match (complete or partial), or null if
- *          searchedText is empty or no match is found.
- */
-export function getPotentialStartIndex(
-  text: string,
-  searchedText: string,
-): number | null {
-  // Return null immediately if searchedText is empty.
-  if (searchedText.length === 0) {
-    return null;
-  }
-
-  // Check if the searchedText exists as a direct substring of text.
-  const directIndex = text.indexOf(searchedText);
-  if (directIndex !== -1) {
-    return directIndex;
-  }
-
-  // Otherwise, look for the largest suffix of "text" that matches
-  // a prefix of "searchedText". We go from the end of text inward.
-  for (let i = text.length - 1; i >= 0; i--) {
-    const suffix = text.substring(i);
-    if (searchedText.startsWith(suffix)) {
-      return i;
-    }
-  }
-
-  return null;
-}

package/node_modules/ai/src/util/index.ts

@@ -1,12 +0,0 @@
-export type { AsyncIterableStream } from './async-iterable-stream';
-export { consumeStream } from './consume-stream';
-export { cosineSimilarity } from './cosine-similarity';
-export { createDownload } from './download/create-download';
-export { getTextFromDataUrl } from './data-url';
-export type { DeepPartial } from './deep-partial';
-export type { DownloadFunction as Experimental_DownloadFunction } from './download/download-function';
-export { type ErrorHandler } from './error-handler';
-export { isDeepEqualData } from './is-deep-equal-data';
-export { parsePartialJson } from './parse-partial-json';
-export { SerialJobExecutor } from './serial-job-executor';
-export { simulateReadableStream } from './simulate-readable-stream';

package/node_modules/ai/src/util/is-deep-equal-data.ts

@@ -1,48 +0,0 @@
-/**
- * Performs a deep-equal comparison of two parsed JSON objects.
- *
- * @param {any} obj1 - The first object to compare.
- * @param {any} obj2 - The second object to compare.
- * @returns {boolean} - Returns true if the two objects are deeply equal, false otherwise.
- */
-export function isDeepEqualData(obj1: any, obj2: any): boolean {
-  // Check for strict equality first
-  if (obj1 === obj2) return true;
-
-  // Check if either is null or undefined
-  if (obj1 == null || obj2 == null) return false;
-
-  // Check if both are objects
-  if (typeof obj1 !== 'object' && typeof obj2 !== 'object')
-    return obj1 === obj2;
-
-  // If they are not strictly equal, they both need to be Objects
-  if (obj1.constructor !== obj2.constructor) return false;
-
-  // Special handling for Date objects
-  if (obj1 instanceof Date && obj2 instanceof Date) {
-    return obj1.getTime() === obj2.getTime();
-  }
-
-  // Handle arrays: compare length and then perform a recursive deep comparison on each item
-  if (Array.isArray(obj1)) {
-    if (obj1.length !== obj2.length) return false;
-    for (let i = 0; i < obj1.length; i++) {
-      if (!isDeepEqualData(obj1[i], obj2[i])) return false;
-    }
-    return true; // All array elements matched
-  }
-
-  // Compare the set of keys in each object
-  const keys1 = Object.keys(obj1);
-  const keys2 = Object.keys(obj2);
-  if (keys1.length !== keys2.length) return false;
-
-  // Check each key-value pair recursively
-  for (const key of keys1) {
-    if (!keys2.includes(key)) return false;
-    if (!isDeepEqualData(obj1[key], obj2[key])) return false;
-  }
-
-  return true; // All keys and values matched
-}

package/node_modules/ai/src/util/is-non-empty-object.ts

@@ -1,5 +0,0 @@
-export function isNonEmptyObject(
-  object: Record<string, unknown> | undefined | null,
-): object is Record<string, unknown> {
-  return object != null && Object.keys(object).length > 0;
-}

package/node_modules/ai/src/util/job.ts

@@ -1 +0,0 @@
-export type Job = () => Promise<void>;

package/node_modules/ai/src/util/log-v2-compatibility-warning.ts

@@ -1,21 +0,0 @@
-import { logWarnings } from '../logger/log-warnings';
-
-export function logV2CompatibilityWarning({
-  provider,
-  modelId,
-}: {
-  provider: string;
-  modelId: string;
-}): void {
-  logWarnings({
-    warnings: [
-      {
-        type: 'compatibility',
-        feature: 'specificationVersion',
-        details: `Using v2 specification compatibility mode. Some features may not be available.`,
-      },
-    ],
-    provider,
-    model: modelId,
-  });
-}

package/node_modules/ai/src/util/merge-abort-signals.ts

@@ -1,43 +0,0 @@
-/**
- * Merges multiple AbortSignals into a single AbortSignal.
- * The returned signal will abort when any of the input signals abort,
- * with the same reason as the first signal to abort.
- *
- * @param signals - The AbortSignals to merge. Null and undefined values are filtered out.
- * @returns An AbortSignal that aborts when any of the input signals abort,
- *          or undefined if no valid signals are provided.
- */
-export function mergeAbortSignals(
-  ...signals: (AbortSignal | null | undefined)[]
-): AbortSignal | undefined {
-  const validSignals = signals.filter(
-    (signal): signal is AbortSignal => signal != null,
-  );
-
-  if (validSignals.length === 0) {
-    return undefined;
-  }
-
-  if (validSignals.length === 1) {
-    return validSignals[0];
-  }
-
-  const controller = new AbortController();
-
-  for (const signal of validSignals) {
-    if (signal.aborted) {
-      controller.abort(signal.reason);
-      return controller.signal;
-    }
-
-    signal.addEventListener(
-      'abort',
-      () => {
-        controller.abort(signal.reason);
-      },
-      { once: true },
-    );
-  }
-
-  return controller.signal;
-}

package/node_modules/ai/src/util/merge-objects.ts

@@ -1,79 +0,0 @@
-/**
- * Deeply merges two objects together.
- * - Properties from the `overrides` object override those in the `base` object with the same key.
- * - For nested objects, the merge is performed recursively (deep merge).
- * - Arrays are replaced, not merged.
- * - Primitive values are replaced.
- * - If both `base` and `overrides` are undefined, returns undefined.
- * - If one of `base` or `overrides` is undefined, returns the other.
- *
- * @param base The target object to merge into
- * @param overrides The source object to merge from
- * @returns A new object with the merged properties, or undefined if both inputs are undefined
- */
-export function mergeObjects<T extends object, U extends object>(
-  base: T | undefined,
-  overrides: U | undefined,
-): (T & U) | T | U | undefined {
-  // If both inputs are undefined, return undefined
-  if (base === undefined && overrides === undefined) {
-    return undefined;
-  }
-
-  // If target is undefined, return source
-  if (base === undefined) {
-    return overrides;
-  }
-
-  // If source is undefined, return target
-  if (overrides === undefined) {
-    return base;
-  }
-
-  // Create a new object to avoid mutating the inputs
-  const result = { ...base } as T & U;
-
-  // Iterate through all keys in the source object
-  for (const key in overrides) {
-    if (Object.prototype.hasOwnProperty.call(overrides, key)) {
-      const overridesValue = overrides[key];
-
-      // Skip if the overrides value is undefined
-      if (overridesValue === undefined) continue;
-
-      // Get the base value if it exists
-      const baseValue =
-        key in base ? base[key as unknown as keyof T] : undefined;
-
-      // Check if both values are objects that can be deeply merged
-      const isSourceObject =
-        overridesValue !== null &&
-        typeof overridesValue === 'object' &&
-        !Array.isArray(overridesValue) &&
-        !(overridesValue instanceof Date) &&
-        !(overridesValue instanceof RegExp);
-
-      const isTargetObject =
-        baseValue !== null &&
-        baseValue !== undefined &&
-        typeof baseValue === 'object' &&
-        !Array.isArray(baseValue) &&
-        !(baseValue instanceof Date) &&
-        !(baseValue instanceof RegExp);
-
-      // If both values are mergeable objects, merge them recursively
-      if (isSourceObject && isTargetObject) {
-        result[key as keyof (T & U)] = mergeObjects(
-          baseValue as object,
-          overridesValue as object,
-        ) as any;
-      } else {
-        // For primitives, arrays, or when one value is not a mergeable object,
-        // simply override with the source value
-        result[key as keyof (T & U)] = overridesValue as any;
-      }
-    }
-  }
-
-  return result;
-}

package/node_modules/ai/src/util/notify.ts

@@ -1,22 +0,0 @@
-import { asArray } from './as-array';
-
-/**
- * A callback function that can be used to notify listeners.
- */
-export type Listener<EVENT> = (event: EVENT) => PromiseLike<void> | void;
-
-/**
- * Notifies all provided callbacks with the given event.
- * Errors in callbacks do not break the generation flow.
- */
-export async function notify<EVENT>(options: {
-  event: EVENT;
-  callbacks?: Listener<EVENT> | Array<Listener<EVENT> | undefined | null>;
-}): Promise<void> {
-  for (const callback of asArray(options.callbacks)) {
-    if (callback == null) continue;
-    try {
-      await callback(options.event);
-    } catch (_ignored) {}
-  }
-}

package/node_modules/ai/src/util/now.ts

@@ -1,4 +0,0 @@
-// Shim for performance.now() to support environments that don't have it:
-export function now(): number {
-  return globalThis?.performance?.now() ?? Date.now();
-}