ai 6.0.33 → 6.0.34

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.test.ts

@@ -0,0 +1,34 @@
+import { getPotentialStartIndex } from './get-potential-start-index';
+import { describe, it, expect } from 'vitest';
+
+describe('getPotentialStartIndex', () => {
+  it('should return null when searchedText is empty', () => {
+    const result = getPotentialStartIndex('1234567890', '');
+    expect(result).toBeNull();
+  });
+
+  it('should return null when searchedText is not in text', () => {
+    const result = getPotentialStartIndex('1234567890', 'a');
+    expect(result).toBeNull();
+  });
+
+  it('should return index when searchedText is in text', () => {
+    const result = getPotentialStartIndex('1234567890', '1234567890');
+    expect(result).toBe(0);
+  });
+
+  it('should return index when searchedText might start in text', () => {
+    const result = getPotentialStartIndex('1234567890', '0123');
+    expect(result).toBe(9);
+  });
+
+  it('should return index when searchedText might start in text', () => {
+    const result = getPotentialStartIndex('1234567890', '90123');
+    expect(result).toBe(8);
+  });
+
+  it('should return index when searchedText might start in text', () => {
+    const result = getPotentialStartIndex('1234567890', '890123');
+    expect(result).toBe(7);
+  });
+});

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

@@ -0,0 +1,30 @@
+/**
+ * Returns the index of the start of the searchedText in the text, or null if it
+ * is not 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,11 @@
+export type { AsyncIterableStream } from './async-iterable-stream';
+export { consumeStream } from './consume-stream';
+export { cosineSimilarity } from './cosine-similarity';
+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.test.ts

@@ -0,0 +1,119 @@
+import assert from 'node:assert';
+import { isDeepEqualData } from './is-deep-equal-data';
+import { it } from 'vitest';
+
+it('should check if two primitives are equal', async () => {
+  let x = 1;
+  let y = 1;
+  let result = isDeepEqualData(x, y);
+  assert.equal(result, true);
+
+  x = 1;
+  y = 2;
+  result = isDeepEqualData(x, y);
+  assert.equal(result, false);
+});
+
+it('should return false for different types', async () => {
+  const obj = { a: 1 };
+  const num = 1;
+  const result = isDeepEqualData(obj, num);
+  assert.equal(result, false);
+});
+
+it('should return false for null values compared with objects', async () => {
+  const obj = { a: 1 };
+  const result = isDeepEqualData(obj, null);
+  assert.equal(result, false);
+});
+
+it('should identify two equal objects', async () => {
+  const obj1 = { a: 1, b: 2 };
+  const obj2 = { a: 1, b: 2 };
+  const result = isDeepEqualData(obj1, obj2);
+  assert.equal(result, true);
+});
+
+it('should identify two objects with different values', async () => {
+  const obj1 = { a: 1, b: 2 };
+  const obj2 = { a: 1, b: 3 };
+  const result = isDeepEqualData(obj1, obj2);
+  assert.equal(result, false);
+});
+
+it('should identify two objects with different number of keys', async () => {
+  const obj1 = { a: 1, b: 2 };
+  const obj2 = { a: 1, b: 2, c: 3 };
+  const result = isDeepEqualData(obj1, obj2);
+  assert.equal(result, false);
+});
+
+it('should handle nested objects', async () => {
+  const obj1 = { a: { c: 1 }, b: 2 };
+  const obj2 = { a: { c: 1 }, b: 2 };
+  const result = isDeepEqualData(obj1, obj2);
+  assert.equal(result, true);
+});
+
+it('should detect inequality in nested objects', async () => {
+  const obj1 = { a: { c: 1 }, b: 2 };
+  const obj2 = { a: { c: 2 }, b: 2 };
+  const result = isDeepEqualData(obj1, obj2);
+  assert.equal(result, false);
+});
+
+it('should compare arrays correctly', async () => {
+  const arr1 = [1, 2, 3];
+  const arr2 = [1, 2, 3];
+  const result = isDeepEqualData(arr1, arr2);
+  assert.equal(result, true);
+
+  const arr3 = [1, 2, 3];
+  const arr4 = [1, 2, 4];
+  const result2 = isDeepEqualData(arr3, arr4);
+  assert.equal(result2, false);
+});
+
+it('should return false for null comparison with object', () => {
+  const obj = { a: 1 };
+  const result = isDeepEqualData(obj, null);
+  assert.equal(result, false);
+});
+
+it('should distinguish between array and object with same enumerable properties', () => {
+  const obj = { 0: 'one', 1: 'two', length: 2 };
+  const arr = ['one', 'two'];
+  const result = isDeepEqualData(obj, arr);
+  assert.equal(result, false);
+});
+
+it('should return false when comparing objects with different prototypes', () => {
+  const obj1 = Object.create({ a: 1 });
+  const obj2 = Object.create(null);
+  obj1.b = 2;
+  obj2.b = 2;
+  const result = isDeepEqualData(obj1, obj2);
+  assert.equal(result, false);
+});
+
+it('should handle date object comparisons correctly', () => {
+  const date1 = new Date(2000, 0, 1);
+  const date2 = new Date(2000, 0, 1);
+  const date3 = new Date(2000, 0, 2);
+  assert.equal(isDeepEqualData(date1, date2), true);
+  assert.equal(isDeepEqualData(date1, date3), false);
+});
+
+it('should handle function comparisons', () => {
+  const func1 = () => {
+    console.log('hello');
+  };
+  const func2 = () => {
+    console.log('hello');
+  };
+  const func3 = () => {
+    console.log('world');
+  };
+  assert.equal(isDeepEqualData(func1, func2), false);
+  assert.equal(isDeepEqualData(func1, func3), false);
+});

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,
+  });
+}