@elizaos/client 1.5.5-alpha.10

package/src/lib/media-utils.ts

@@ -0,0 +1,170 @@
+/**
+ * Utility functions for parsing and handling media URLs in chat messages
+ */
+
+export interface MediaInfo {
+  url: string;
+  type: 'image' | 'video' | 'unknown';
+  isEmbed: boolean;
+}
+
+// Common image extensions
+const IMAGE_EXTENSIONS = new Set([
+  'jpg',
+  'jpeg',
+  'png',
+  'gif',
+  'webp',
+  'svg',
+  'bmp',
+  'ico',
+  'tiff',
+  'avif',
+]);
+
+// Common video extensions
+const VIDEO_EXTENSIONS = new Set(['mp4', 'webm', 'mov', 'avi', 'mkv', 'flv', 'wmv', 'm4v', 'ogv']);
+
+// Video platforms that support embedding
+const VIDEO_PLATFORMS = {
+  youtube: {
+    patterns: [
+      /(?:https?:\/\/)?(?:www\.)?(?:youtube\.com\/watch\?v=|youtu\.be\/)([a-zA-Z0-9_-]{11})/,
+      /(?:https?:\/\/)?(?:www\.)?youtube\.com\/embed\/([a-zA-Z0-9_-]{11})/,
+    ],
+    getEmbedUrl: (id: string) => `https://www.youtube.com/embed/${id}`,
+  },
+  vimeo: {
+    patterns: [/(?:https?:\/\/)?(?:www\.)?vimeo\.com\/(\d+)/],
+    getEmbedUrl: (id: string) => `https://player.vimeo.com/video/${id}`,
+  },
+};
+
+/**
+ * Extracts the file extension from a URL
+ */
+function getFileExtension(url: string): string {
+  try {
+    const urlObj = new URL(url);
+    const pathname = urlObj.pathname;
+    const extension = pathname.split('.').pop()?.toLowerCase();
+    return extension || '';
+  } catch {
+    return '';
+  }
+}
+
+/**
+ * Checks if a URL points to an image
+ */
+export function isImageUrl(url: string): boolean {
+  const extension = getFileExtension(url);
+  return IMAGE_EXTENSIONS.has(extension);
+}
+
+/**
+ * Checks if a URL points to a video file
+ */
+export function isVideoFileUrl(url: string): boolean {
+  const extension = getFileExtension(url);
+  return VIDEO_EXTENSIONS.has(extension);
+}
+
+/**
+ * Checks if a URL is from a supported video platform
+ */
+export function getVideoPlatformInfo(
+  url: string
+): { platform: string; id: string; embedUrl: string } | null {
+  for (const [platform, config] of Object.entries(VIDEO_PLATFORMS)) {
+    for (const pattern of config.patterns) {
+      const match = url.match(pattern);
+      if (match && match[1]) {
+        return {
+          platform,
+          id: match[1],
+          embedUrl: config.getEmbedUrl(match[1]),
+        };
+      }
+    }
+  }
+  return null;
+}
+
+/**
+ * Parses URLs from text and identifies media types
+ */
+export function parseMediaFromText(text: string): MediaInfo[] {
+  if (!text) return [];
+
+  // Regular expression to find URLs
+  const urlRegex = /(https?:\/\/[^\s]+)/g;
+  const urls = text.match(urlRegex) || [];
+
+  return urls
+    .map((url) => {
+      // Remove trailing punctuation that might be captured
+      const cleanUrl = url.replace(/[.,!?;)]*$/, '');
+
+      if (isImageUrl(cleanUrl)) {
+        return {
+          url: cleanUrl,
+          type: 'image' as const,
+          isEmbed: false,
+        };
+      }
+
+      if (isVideoFileUrl(cleanUrl)) {
+        return {
+          url: cleanUrl,
+          type: 'video' as const,
+          isEmbed: false,
+        };
+      }
+
+      const platformInfo = getVideoPlatformInfo(cleanUrl);
+      if (platformInfo) {
+        return {
+          url: platformInfo.embedUrl,
+          type: 'video' as const,
+          isEmbed: true,
+        };
+      }
+
+      return {
+        url: cleanUrl,
+        type: 'unknown' as const,
+        isEmbed: false,
+      };
+    })
+    .filter((media) => media.type !== 'unknown');
+}
+
+/**
+ * Removes media URLs from text to avoid duplication in display
+ */
+export function removeMediaUrlsFromText(text: string, mediaInfos: MediaInfo[]): string {
+  let cleanText = text;
+
+  mediaInfos.forEach((media) => {
+    // For embedded videos, remove the original URL, not the embed URL
+    if (media.isEmbed) {
+      // Find the original URL that matches this embed
+      const urlRegex = /(https?:\/\/[^\s]+)/g;
+      const urls = text.match(urlRegex) || [];
+
+      for (const url of urls) {
+        const cleanUrl = url.replace(/[.,!?;)]*$/, '');
+        const platformInfo = getVideoPlatformInfo(cleanUrl);
+        if (platformInfo && platformInfo.embedUrl === media.url) {
+          cleanText = cleanText.replace(url, '').trim();
+          break;
+        }
+      }
+    } else {
+      cleanText = cleanText.replace(media.url, '').trim();
+    }
+  });
+
+  return cleanText;
+}

package/src/lib/pca.test.ts

@@ -0,0 +1,17 @@
+import { describe, it, expect } from 'bun:test';
+import { computePca } from './pca';
+
+describe('computePca', () => {
+  it('projects 3D vectors to 2D deterministically', () => {
+    const data = [
+      [1, 0, 0],
+      [0, 1, 0],
+      [0, 0, 1],
+    ];
+    const result = computePca(data, 2);
+    expect(result.length).toBe(3);
+    // first vector should have positive coordinates
+    expect(result[0][0]).toBeGreaterThan(0);
+    expect(result[0][1]).toBeDefined();
+  });
+});

package/src/lib/pca.ts

@@ -0,0 +1,52 @@
+export function computePca(data: number[][], dims = 2): number[][] {
+  if (data.length === 0) return [];
+  const dim = data[0].length;
+  const mean = Array(dim).fill(0);
+  for (const vec of data) {
+    for (let i = 0; i < dim; i++) mean[i] += vec[i];
+  }
+  for (let i = 0; i < dim; i++) mean[i] /= data.length;
+  const centered = data.map((v) => v.map((val, idx) => val - mean[idx]));
+  // covariance matrix
+  const cov = Array.from({ length: dim }, () => Array(dim).fill(0));
+  for (const vec of centered) {
+    for (let i = 0; i < dim; i++) {
+      for (let j = 0; j < dim; j++) {
+        cov[i][j] += vec[i] * vec[j];
+      }
+    }
+  }
+  for (let i = 0; i < dim; i++) {
+    for (let j = 0; j < dim; j++) {
+      cov[i][j] /= data.length - 1;
+    }
+  }
+  const eigenvectors: number[][] = [];
+  let matrix = cov.map((row) => row.slice());
+  for (let k = 0; k < dims; k++) {
+    // start with a deterministic unit vector for stability
+    let vec = Array(dim).fill(1 / Math.sqrt(dim));
+    for (let iter = 0; iter < 50; iter++) {
+      const next = multiplyMatrixVector(matrix, vec);
+      const norm = Math.sqrt(next.reduce((a, b) => a + b * b, 0));
+      if (norm === 0) break;
+      vec = next.map((v) => v / norm);
+    }
+    eigenvectors.push(vec.slice());
+    const lambda = dot(vec, multiplyMatrixVector(matrix, vec));
+    for (let i = 0; i < dim; i++) {
+      for (let j = 0; j < dim; j++) {
+        matrix[i][j] -= lambda * vec[i] * vec[j];
+      }
+    }
+  }
+  return centered.map((vec) => eigenvectors.map((ev) => dot(vec, ev)));
+}
+
+function multiplyMatrixVector(mat: number[][], vec: number[]): number[] {
+  return mat.map((row) => row.reduce((sum, val, i) => sum + val * vec[i], 0));
+}
+
+function dot(a: number[], b: number[]): number {
+  return a.reduce((sum, val, i) => sum + val * b[i], 0);
+}