@elizaos/core 1.5.4 → 1.5.5

package/src/types/transcription.ts

@@ -1,133 +0,0 @@
-import { Service, ServiceType } from './service';
-
-export interface TranscriptionOptions {
-  language?: string;
-  model?: string;
-  temperature?: number;
-  prompt?: string;
-  response_format?: 'json' | 'text' | 'srt' | 'vtt' | 'verbose_json';
-  timestamp_granularities?: ('word' | 'segment')[];
-  word_timestamps?: boolean;
-  segment_timestamps?: boolean;
-}
-
-export interface TranscriptionResult {
-  text: string;
-  language?: string;
-  duration?: number;
-  segments?: TranscriptionSegment[];
-  words?: TranscriptionWord[];
-  confidence?: number;
-}
-
-export interface TranscriptionSegment {
-  id: number;
-  text: string;
-  start: number;
-  end: number;
-  confidence?: number;
-  tokens?: number[];
-  temperature?: number;
-  avg_logprob?: number;
-  compression_ratio?: number;
-  no_speech_prob?: number;
-}
-
-export interface TranscriptionWord {
-  word: string;
-  start: number;
-  end: number;
-  confidence?: number;
-}
-
-export interface SpeechToTextOptions {
-  language?: string;
-  model?: string;
-  continuous?: boolean;
-  interimResults?: boolean;
-  maxAlternatives?: number;
-}
-
-export interface TextToSpeechOptions {
-  voice?: string;
-  model?: string;
-  speed?: number;
-  format?: 'mp3' | 'wav' | 'flac' | 'aac';
-  response_format?: 'mp3' | 'opus' | 'aac' | 'flac';
-}
-
-/**
- * Interface for audio transcription and speech services
- */
-export abstract class ITranscriptionService extends Service {
-  static override readonly serviceType = ServiceType.TRANSCRIPTION;
-
-  public readonly capabilityDescription = 'Audio transcription and speech processing capabilities';
-
-  /**
-   * Transcribe audio file to text
-   * @param audioPath - Path to audio file or audio buffer
-   * @param options - Transcription options
-   * @returns Promise resolving to transcription result
-   */
-  abstract transcribeAudio(
-    audioPath: string | Buffer,
-    options?: TranscriptionOptions
-  ): Promise<TranscriptionResult>;
-
-  /**
-   * Transcribe video file to text (extracts audio first)
-   * @param videoPath - Path to video file or video buffer
-   * @param options - Transcription options
-   * @returns Promise resolving to transcription result
-   */
-  abstract transcribeVideo(
-    videoPath: string | Buffer,
-    options?: TranscriptionOptions
-  ): Promise<TranscriptionResult>;
-
-  /**
-   * Real-time speech to text from audio stream
-   * @param audioStream - Audio stream or buffer
-   * @param options - Speech to text options
-   * @returns Promise resolving to transcription result
-   */
-  abstract speechToText(
-    audioStream: NodeJS.ReadableStream | Buffer,
-    options?: SpeechToTextOptions
-  ): Promise<TranscriptionResult>;
-
-  /**
-   * Convert text to speech
-   * @param text - Text to convert to speech
-   * @param options - Text to speech options
-   * @returns Promise resolving to audio buffer
-   */
-  abstract textToSpeech(text: string, options?: TextToSpeechOptions): Promise<Buffer>;
-
-  /**
-   * Get supported languages for transcription
-   * @returns Promise resolving to array of supported language codes
-   */
-  abstract getSupportedLanguages(): Promise<string[]>;
-
-  /**
-   * Get available voices for text to speech
-   * @returns Promise resolving to array of available voices
-   */
-  abstract getAvailableVoices(): Promise<
-    Array<{
-      id: string;
-      name: string;
-      language: string;
-      gender?: 'male' | 'female' | 'neutral';
-    }>
-  >;
-
-  /**
-   * Detect language of audio file
-   * @param audioPath - Path to audio file or audio buffer
-   * @returns Promise resolving to detected language code
-   */
-  abstract detectLanguage(audioPath: string | Buffer): Promise<string>;
-}

package/src/types/video.ts

@@ -1,108 +0,0 @@
-import { Service, ServiceType } from './service';
-
-export interface VideoInfo {
-  title?: string;
-  duration?: number;
-  url: string;
-  thumbnail?: string;
-  description?: string;
-  uploader?: string;
-  viewCount?: number;
-  uploadDate?: Date;
-  formats?: VideoFormat[];
-}
-
-export interface VideoFormat {
-  formatId: string;
-  url: string;
-  extension: string;
-  quality: string;
-  fileSize?: number;
-  videoCodec?: string;
-  audioCodec?: string;
-  resolution?: string;
-  fps?: number;
-  bitrate?: number;
-}
-
-export interface VideoDownloadOptions {
-  format?: string;
-  quality?: 'best' | 'worst' | 'bestvideo' | 'bestaudio' | string;
-  outputPath?: string;
-  audioOnly?: boolean;
-  videoOnly?: boolean;
-  subtitles?: boolean;
-  embedSubs?: boolean;
-  writeInfoJson?: boolean;
-}
-
-export interface VideoProcessingOptions {
-  startTime?: number;
-  endTime?: number;
-  outputFormat?: string;
-  resolution?: string;
-  bitrate?: string;
-  framerate?: number;
-  audioCodec?: string;
-  videoCodec?: string;
-}
-
-/**
- * Interface for video processing and download services
- */
-export abstract class IVideoService extends Service {
-  static override readonly serviceType = ServiceType.VIDEO;
-
-  public readonly capabilityDescription = 'Video download, processing, and conversion capabilities';
-
-  /**
-   * Get video information without downloading
-   * @param url - Video URL
-   * @returns Promise resolving to video information
-   */
-  abstract getVideoInfo(url: string): Promise<VideoInfo>;
-
-  /**
-   * Download a video from URL
-   * @param url - Video URL
-   * @param options - Download options
-   * @returns Promise resolving to downloaded file path
-   */
-  abstract downloadVideo(url: string, options?: VideoDownloadOptions): Promise<string>;
-
-  /**
-   * Extract audio from video
-   * @param videoPath - Path to video file or video URL
-   * @param outputPath - Optional output path for audio file
-   * @returns Promise resolving to audio file path
-   */
-  abstract extractAudio(videoPath: string, outputPath?: string): Promise<string>;
-
-  /**
-   * Generate thumbnail from video
-   * @param videoPath - Path to video file or video URL
-   * @param timestamp - Timestamp in seconds to capture thumbnail
-   * @returns Promise resolving to thumbnail image path
-   */
-  abstract getThumbnail(videoPath: string, timestamp?: number): Promise<string>;
-
-  /**
-   * Convert video to different format
-   * @param videoPath - Path to input video file
-   * @param outputPath - Path for output video file
-   * @param options - Processing options
-   * @returns Promise resolving to converted video path
-   */
-  abstract convertVideo(
-    videoPath: string,
-    outputPath: string,
-    options?: VideoProcessingOptions
-  ): Promise<string>;
-
-  /**
-   * Get available formats for a video URL
-   * @param url - Video URL
-   * @returns Promise resolving to available formats
-   */
-  abstract getAvailableFormats(url: string): Promise<VideoFormat[]>;
-}

package/src/types/wallet.ts

@@ -1,56 +0,0 @@
-import { Service, ServiceType } from './service';
-import type { TokenBalance } from './token';
-
-/**
- * Represents a single asset holding within a wallet, including its value.
- * This extends a generic TokenBalance with wallet-specific valuation.
- */
-export interface WalletAsset extends TokenBalance {
-  priceUsd?: number;
-  valueUsd?: number;
-}
-
-/**
- * Represents the entire portfolio of assets in a wallet.
- */
-export interface WalletPortfolio {
-  totalValueUsd: number;
-  assets: WalletAsset[];
-}
-
-/**
- * Abstract interface for a Wallet Service.
- * Plugins that provide wallet functionality (e.g., for Solana, EVM) should implement this service.
- * It provides a standardized way for other plugins to query the state of a wallet.
- */
-export abstract class IWalletService extends Service {
-  static override readonly serviceType = ServiceType.WALLET;
-
-  public readonly capabilityDescription =
-    'Provides standardized access to wallet balances and portfolios.';
-
-  /**
-   * Retrieves the entire portfolio of assets held by the wallet.
-   * @param owner - Optional: The specific wallet address/owner to query if the service manages multiple.
-   * @returns A promise that resolves to the wallet's portfolio.
-   */
-  abstract getPortfolio(owner?: string): Promise<WalletPortfolio>;
-
-  /**
-   * Retrieves the balance of a specific asset in the wallet.
-   * @param assetAddress - The mint address or native identifier of the asset.
-   * @param owner - Optional: The specific wallet address/owner to query.
-   * @returns A promise that resolves to the user-friendly (decimal-adjusted) balance of the asset held.
-   */
-  abstract getBalance(assetAddress: string, owner?: string): Promise<number>;
-
-  /**
-   * Transfers SOL from a specified keypair to a given public key.
-   * This is a low-level function primarily for Solana-based wallet services.
-   * @param from - The Keypair of the sender.
-   * @param to - The PublicKey of the recipient.
-   * @param lamports - The amount in lamports to transfer.
-   * @returns A promise that resolves with the transaction signature.
-   */
-  abstract transferSol(from: any, to: any, lamports: number): Promise<string>;
-}

package/src/types/web-search.ts

@@ -1,146 +0,0 @@
-import { Service, ServiceType } from './service';
-
-export interface SearchOptions {
-  limit?: number;
-  offset?: number;
-  language?: string;
-  region?: string;
-  dateRange?: {
-    start?: Date;
-    end?: Date;
-  };
-  fileType?: string;
-  site?: string;
-  sortBy?: 'relevance' | 'date' | 'popularity';
-  safeSearch?: 'strict' | 'moderate' | 'off';
-}
-
-export interface SearchResult {
-  title: string;
-  url: string;
-  description: string;
-  displayUrl?: string;
-  thumbnail?: string;
-  publishedDate?: Date;
-  source?: string;
-  relevanceScore?: number;
-  snippet?: string;
-}
-
-export interface SearchResponse {
-  query: string;
-  results: SearchResult[];
-  totalResults?: number;
-  searchTime?: number;
-  suggestions?: string[];
-  nextPageToken?: string;
-  relatedSearches?: string[];
-}
-
-export interface NewsSearchOptions extends SearchOptions {
-  category?:
-    | 'general'
-    | 'business'
-    | 'entertainment'
-    | 'health'
-    | 'science'
-    | 'sports'
-    | 'technology';
-  freshness?: 'day' | 'week' | 'month';
-}
-
-export interface ImageSearchOptions extends SearchOptions {
-  size?: 'small' | 'medium' | 'large' | 'wallpaper' | 'any';
-  color?:
-    | 'color'
-    | 'monochrome'
-    | 'red'
-    | 'orange'
-    | 'yellow'
-    | 'green'
-    | 'blue'
-    | 'purple'
-    | 'pink'
-    | 'brown'
-    | 'black'
-    | 'gray'
-    | 'white';
-  type?: 'photo' | 'clipart' | 'line' | 'animated';
-  layout?: 'square' | 'wide' | 'tall' | 'any';
-  license?: 'any' | 'public' | 'share' | 'sharecommercially' | 'modify';
-}
-
-export interface VideoSearchOptions extends SearchOptions {
-  duration?: 'short' | 'medium' | 'long' | 'any';
-  resolution?: 'high' | 'standard' | 'any';
-  quality?: 'high' | 'standard' | 'any';
-}
-
-/**
- * Interface for web search services
- */
-export abstract class IWebSearchService extends Service {
-  static override readonly serviceType = ServiceType.WEB_SEARCH;
-
-  public readonly capabilityDescription = 'Web search and content discovery capabilities';
-
-  /**
-   * Perform a general web search
-   * @param query - Search query
-   * @param options - Search options
-   * @returns Promise resolving to search results
-   */
-  abstract search(query: string, options?: SearchOptions): Promise<SearchResponse>;
-
-  /**
-   * Search for news articles
-   * @param query - Search query
-   * @param options - News search options
-   * @returns Promise resolving to news search results
-   */
-  abstract searchNews(query: string, options?: NewsSearchOptions): Promise<SearchResponse>;
-
-  /**
-   * Search for images
-   * @param query - Search query
-   * @param options - Image search options
-   * @returns Promise resolving to image search results
-   */
-  abstract searchImages(query: string, options?: ImageSearchOptions): Promise<SearchResponse>;
-
-  /**
-   * Search for videos
-   * @param query - Search query
-   * @param options - Video search options
-   * @returns Promise resolving to video search results
-   */
-  abstract searchVideos(query: string, options?: VideoSearchOptions): Promise<SearchResponse>;
-
-  /**
-   * Get search suggestions for a query
-   * @param query - Partial search query
-   * @returns Promise resolving to array of suggestions
-   */
-  abstract getSuggestions(query: string): Promise<string[]>;
-
-  /**
-   * Get trending searches
-   * @param region - Optional region code
-   * @returns Promise resolving to trending search queries
-   */
-  abstract getTrendingSearches(region?: string): Promise<string[]>;
-
-  /**
-   * Get detailed information about a specific URL
-   * @param url - URL to analyze
-   * @returns Promise resolving to page information
-   */
-  abstract getPageInfo(url: string): Promise<{
-    title: string;
-    description: string;
-    content: string;
-    metadata: Record<string, string>;
-    images: string[];
-    links: string[];
-  }>;
-}

package/src/utils/__tests__/buffer.test.ts

@@ -1,80 +0,0 @@
-import { describe, it, expect } from 'bun:test';
-import {
-  fromHex,
-  toHex,
-  fromString,
-  toString,
-  fromBytes,
-  alloc,
-  concat,
-  slice,
-  equals,
-  isBuffer,
-  byteLength,
-  randomBytes,
-} from '../buffer';
-
-describe('buffer utils', () => {
-  it('converts hex <-> buffer', () => {
-    const hex = 'deadbeef01ff';
-    const buf = fromHex(hex);
-    expect(byteLength(buf)).toBe(6);
-    expect(toHex(buf)).toBe(hex);
-  });
-
-  it('converts string utf8 <-> buffer', () => {
-    const str = 'Hello, 世界';
-    const buf = fromString(str, 'utf8');
-    const out = toString(buf, 'utf8');
-    expect(out).toBe(str);
-  });
-
-  it('converts string base64 <-> buffer', () => {
-    const str = 'hello-base64';
-    const b64 = 'aGVsbG8tYmFzZTY0';
-    const bufFromB64 = fromString(b64, 'base64');
-    expect(toString(bufFromB64, 'utf8')).toBe(str);
-
-    const bufFromStr = fromString(str, 'utf8');
-    expect(toString(bufFromStr, 'base64')).toBe(b64);
-  });
-
-  it('creates from bytes and allocates', () => {
-    const bytes = [1, 2, 3, 4];
-    const buf = fromBytes(bytes);
-    expect(byteLength(buf)).toBe(4);
-    expect(toHex(buf)).toBe('01020304');
-
-    const zero = alloc(3);
-    expect(byteLength(zero)).toBe(3);
-    // All zeros
-    expect(toHex(zero)).toBe('000000');
-  });
-
-  it('concatenates and slices buffers', () => {
-    const a = fromHex('aa');
-    const b = fromHex('bbcc');
-    const c = concat([a, b]);
-    expect(toHex(c)).toBe('aabbcc');
-
-    const s = slice(c, 1, 3);
-    expect(toHex(s)).toBe('bbcc');
-  });
-
-  it('checks equality and buffer detection', () => {
-    const a = fromHex('0a0b0c');
-    const b = fromHex('0a0b0c');
-    const c = fromHex('0a0b0d');
-    expect(equals(a, b)).toBe(true);
-    expect(equals(a, c)).toBe(false);
-
-    expect(isBuffer(a)).toBe(true);
-    expect(isBuffer(new Uint8Array([1, 2, 3]))).toBe(true);
-    expect(isBuffer({})).toBe(false);
-  });
-
-  it('generates random bytes with correct length', () => {
-    const r = randomBytes(16);
-    expect(byteLength(r)).toBe(16);
-  });
-});

package/src/utils/__tests__/environment.test.ts

@@ -1,58 +0,0 @@
-import { describe, it, expect } from 'bun:test';
-import {
-  detectEnvironment,
-  getEnvironment,
-  getEnv,
-  setEnv,
-  hasEnv,
-  getBooleanEnv,
-  getNumberEnv,
-  initBrowserEnvironment,
-} from '../environment';
-
-describe('environment utils', () => {
-  it('detects runtime (node in tests)', () => {
-    const runtime = detectEnvironment();
-    expect(['node', 'browser', 'unknown']).toContain(runtime);
-  });
-
-  it('gets and sets env vars via API', () => {
-    const key = 'TEST_ENV_UTILS_KEY';
-    setEnv(key, 'value1');
-    expect(getEnv(key)).toBe('value1');
-    expect(hasEnv(key)).toBe(true);
-  });
-
-  it('boolean env parsing works', () => {
-    const key = 'TEST_BOOL_ENV';
-    setEnv(key, 'true');
-    expect(getBooleanEnv(key, false)).toBe(true);
-    setEnv(key, '0');
-    expect(getBooleanEnv(key, true)).toBe(false);
-  });
-
-  it('number env parsing works', () => {
-    const key = 'TEST_NUM_ENV';
-    setEnv(key, '42');
-    expect(getNumberEnv(key)).toBe(42);
-    setEnv(key, 'NaN');
-    expect(getNumberEnv(key, 7)).toBe(7);
-  });
-
-  it('browser init helper is safe in node', () => {
-    // Should not throw even though we are not in browser
-    initBrowserEnvironment({ SOME_KEY: 'x' });
-    expect(true).toBe(true);
-  });
-
-  it('environment cache can be cleared indirectly by creating a new instance', () => {
-    const env = getEnvironment();
-    // Access a key, then change it, ensure fresh read gets latest
-    const key = 'TEST_CACHE_KEY';
-    setEnv(key, 'a');
-    expect(getEnv(key)).toBe('a');
-    setEnv(key, 'b');
-    // getEnv reads through the singleton which clears cache on set
-    expect(getEnv(key)).toBe('b');
-  });
-});

package/src/utils/__tests__/stringToUuid.test.ts

@@ -1,88 +0,0 @@
-import { describe, it, expect } from 'bun:test';
-import { stringToUuid } from '../../utils';
-import type { UUID } from '../../types';
-
-describe('stringToUuid SHA-1 implementation', () => {
-  // Test vectors to ensure deterministic output
-  // These are the actual SHA-1 based outputs for consistency
-  const testVectors = [
-    { input: 'test', expected: 'a94a8fe5-ccb1-0ba6-9c4c-0873d391e987' },
-    { input: 'hello world', expected: 'f0355dd5-2823-054c-ae66-a0b12842c215' },
-    { input: '', expected: 'da39a3ee-5e6b-0b0d-b255-bfef95601890' },
-    { input: '123', expected: '40bd0015-6308-0fc3-9165-329ea1ff5c5e' },
-    { input: 'user:agent', expected: 'a49810ce-da30-0d3b-97ee-d4d47774d8af' },
-  ];
-
-  it('should produce deterministic UUIDs for known inputs', () => {
-    testVectors.forEach(({ input, expected }) => {
-      const result = stringToUuid(input);
-      expect(result).toBe(expected);
-    });
-  });
-
-  it('should handle UTF-8 strings correctly', () => {
-    // Generate actual values for unicode tests
-    const unicodeTests = [
-      { input: 'Hello 世界', expected: stringToUuid('Hello 世界') },
-      { input: '🌍🌎🌏', expected: stringToUuid('🌍🌎🌏') },
-      { input: 'Café', expected: stringToUuid('Café') },
-    ];
-
-    unicodeTests.forEach(({ input, expected }) => {
-      const result = stringToUuid(input);
-      expect(result).toBe(expected);
-    });
-  });
-
-  it('should return existing UUIDs unchanged', () => {
-    const existingUuid = '550e8400-e29b-41d4-a716-446655440000' as UUID;
-    const result = stringToUuid(existingUuid);
-    expect(result).toBe(existingUuid);
-  });
-
-  it('should handle URL-unsafe characters consistently', () => {
-    const urlTests = [
-      { input: 'test?query=value&param=123', expected: stringToUuid('test?query=value&param=123') },
-      { input: 'path/to/resource#anchor', expected: stringToUuid('path/to/resource#anchor') },
-    ];
-
-    urlTests.forEach(({ input, expected }) => {
-      const result = stringToUuid(input);
-      expect(result).toBe(expected);
-    });
-  });
-
-  it('should handle numbers correctly', () => {
-    expect(stringToUuid(42)).toBe(stringToUuid('42'));
-    expect(stringToUuid(0)).toBe(stringToUuid('0'));
-    expect(stringToUuid(-1)).toBe(stringToUuid('-1'));
-  });
-
-  it('should throw for invalid inputs', () => {
-    expect(() => stringToUuid(null as any)).toThrow(TypeError);
-    expect(() => stringToUuid(undefined as any)).toThrow(TypeError);
-    expect(() => stringToUuid({} as any)).toThrow(TypeError);
-    expect(() => stringToUuid([] as any)).toThrow(TypeError);
-  });
-
-  it('should set correct UUID format bits', () => {
-    const uuid = stringToUuid('test');
-    // Check format
-    expect(uuid).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/);
-
-    // Check variant bits (should be 10xxxxxx in the 9th byte)
-    const parts = uuid.split('-');
-    const variantByte = parseInt(parts[3].substring(0, 2), 16);
-    expect(variantByte & 0xc0).toBe(0x80); // 10xxxxxx pattern
-
-    // Check version nibble (should be 0 for custom)
-    const versionNibble = parseInt(parts[2][0], 16);
-    expect(versionNibble).toBe(0);
-  });
-
-  it('should handle long inputs without errors', () => {
-    const longInput = 'a'.repeat(10000);
-    const result = stringToUuid(longInput);
-    expect(result).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/);
-  });
-});