@fondation-io/ai 7.0.0-beta.45

package/src/util/fix-json.ts

@@ -0,0 +1,401 @@
+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/src/util/get-potential-start-index.ts

@@ -0,0 +1,39 @@
+/**
+ * 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/src/util/index.ts

@@ -0,0 +1,12 @@
+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/src/util/is-deep-equal-data.ts

@@ -0,0 +1,48 @@
+/**
+ * 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/src/util/is-non-empty-object.ts

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

package/src/util/job.ts

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

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

@@ -0,0 +1,21 @@
+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/src/util/merge-abort-signals.ts

@@ -0,0 +1,43 @@
+/**
+ * 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/src/util/merge-objects.ts

@@ -0,0 +1,79 @@
+/**
+ * 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/src/util/notify.ts

@@ -0,0 +1,22 @@
+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/src/util/now.ts

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