language fix

Author: simllll

agents/src/voice/transcription/transforms.test.ts

@@ -6,6 +6,7 @@ import { describe, expect, it } from 'vitest';
 import {
   DEFAULT_TTS_TEXT_TRANSFORMS,
   applyTextTransforms,
+  getAllAvailableTransforms,
   getAvailableTransforms,
 } from './transforms.js';
 
@@ -57,11 +58,24 @@ describe('Text Transforms Core', () => {
     expect(transforms.has('format_euro_amounts')).toBe(true);
   });
 
+  it('should list all available transforms across all languages', () => {
+    const transforms = getAllAvailableTransforms();
+    // Language-agnostic transforms
+    expect(transforms.has('filter_markdown')).toBe(true);
+    expect(transforms.has('filter_emoji')).toBe(true);
+    // English transforms
+    expect(transforms.has('format_numbers')).toBe(true);
+    expect(transforms.has('format_dollar_amounts')).toBe(true);
+    // German transforms
+    expect(transforms.has('format_numbers_de')).toBe(true);
+    expect(transforms.has('format_euro_amounts')).toBe(true);
+  });
+
   it('should throw error for invalid transform name', async () => {
     const stream = stringToStream('test');
-    await expect(
-      applyTextTransforms(stream, ['invalid_transform' as any], { language: 'en' }),
-    ).rejects.toThrow('Invalid transform');
+    await expect(applyTextTransforms(stream, ['invalid_transform' as any])).rejects.toThrow(
+      'Invalid transform',
+    );
   });
 
   it('should apply custom transform function', async () => {
@@ -89,15 +103,38 @@ describe('Text Transforms Core', () => {
 
   it('should apply multiple transforms in sequence', async () => {
     const stream = stringToStream('**Price: $5** 🎉');
-    const result = await applyTextTransforms(
-      stream,
-      ['filter_markdown', 'filter_emoji', 'format_dollar_amounts'],
-      { language: 'en' },
-    );
+    const result = await applyTextTransforms(stream, [
+      'filter_markdown',
+      'filter_emoji',
+      'format_dollar_amounts',
+    ]);
     const output = await streamToString(result);
     expect(output).toContain('Price:');
     expect(output).toContain('five dollars');
     expect(output).not.toContain('**');
     expect(output).not.toContain('🎉');
   });
+
+  it('should find transforms across all languages without specifying language', async () => {
+    // Test that English transform can be found without language config
+    const stream1 = stringToStream('$5');
+    const result1 = await applyTextTransforms(stream1, ['format_dollar_amounts']);
+    const output1 = await streamToString(result1);
+    expect(output1).toBe('five dollars');
+
+    // Test that German transform can be found without language config
+    const stream2 = stringToStream('5€');
+    const result2 = await applyTextTransforms(stream2, ['format_euro_amounts']);
+    const output2 = await streamToString(result2);
+    expect(output2).toBe('fünf Euro');
+
+    // Test that mixed language transforms can be used together
+    const stream3 = stringToStream('$5 and 5€');
+    const result3 = await applyTextTransforms(stream3, [
+      'format_dollar_amounts',
+      'format_euro_amounts',
+    ]);
+    const output3 = await streamToString(result3);
+    expect(output3).toBe('five dollars and fünf Euro');
+  });
 });

agents/src/voice/transcription/transforms.ts

@@ -17,17 +17,6 @@ export type Language = 'en' | 'de' | string;
  */
 export type TextTransform = (text: ReadableStream<string>) => ReadableStream<string>;
 
-/**
- * Configuration for language-specific transforms
- */
-export interface LanguageTransformConfig {
-  /**
-   * The language code for language-specific transforms
-   * Defaults to 'en' (English)
-   */
-  language?: Language;
-}
-
 /**
  * Built-in language-agnostic transform names
  */
@@ -135,30 +124,49 @@ export function getRecommendedTTSTransforms(language: Language = 'en'): BuiltInT
 /**
  * Apply a sequence of text transforms to a text stream
  *
+ * Transforms can be specified either as built-in transform names (strings)
+ * or as custom transform functions. Built-in transforms are looked up across
+ * all registered transforms (language-agnostic and all language-specific).
+ *
  * @param text - Input text stream
  * @param transforms - Array of transform names or custom transform functions
- * @param config - Configuration for language-specific transforms
  * @returns Transformed text stream
+ *
+ * @example
+ * ```typescript
+ * // Use built-in transforms (names)
+ * const text = new ReadableStream(...);
+ * const transformed = await applyTextTransforms(text, [
+ *   'filter_markdown',
+ *   'format_numbers',  // English
+ *   'format_euro_amounts',  // German
+ * ]);
+ *
+ * // Mix built-in and custom transforms
+ * const customTransform: TextTransform = (stream) => ...;
+ * const transformed = await applyTextTransforms(text, [
+ *   'filter_markdown',
+ *   customTransform,
+ * ]);
+ * ```
  */
 export async function applyTextTransforms(
   text: ReadableStream<string>,
   transforms: readonly TextTransformSpec[],
-  config: LanguageTransformConfig = {},
 ): Promise<ReadableStream<string>> {
-  const { language = 'en' } = config;
   let result = text;
 
   for (const transform of transforms) {
     if (typeof transform === 'function') {
       // Custom transform function
       result = transform(result);
     } else {
-      // Built-in transform name
-      const transformFn = getBuiltInTransform(transform, language);
+      // Built-in transform name - search across all registries
+      const transformFn = getBuiltInTransform(transform);
       if (!transformFn) {
         throw new Error(
           `Invalid transform: ${transform}. ` +
-            `Available transforms: ${Array.from(getAvailableTransforms(language)).join(', ')}`,
+            `Available transforms: ${Array.from(getAllAvailableTransforms()).join(', ')}`,
         );
       }
       result = transformFn(result);
@@ -170,25 +178,66 @@ export async function applyTextTransforms(
 
 /**
  * Get a built-in transform function by name
+ *
+ * Searches across all registered transforms:
+ * 1. First checks language-agnostic transforms
+ * 2. Then searches through all language-specific transform registries
+ *
+ * @param name - The built-in transform name
+ * @returns The transform function, or null if not found
  */
-function getBuiltInTransform(name: BuiltInTransformName, language: Language): TextTransform | null {
+function getBuiltInTransform(name: BuiltInTransformName): TextTransform | null {
   // Check language-agnostic transforms first
   const agnostic = languageAgnosticTransforms.get(name as LanguageAgnosticTransformName);
   if (agnostic) {
     return agnostic;
   }
 
-  // Check language-specific transforms
-  const langTransforms = languageSpecificTransforms.get(language);
-  if (langTransforms) {
-    return langTransforms.get(name) || null;
+  // Check all language-specific transform registries
+  for (const langTransforms of languageSpecificTransforms.values()) {
+    const transform = langTransforms.get(name);
+    if (transform) {
+      return transform;
+    }
   }
 
   return null;
 }
 
+/**
+ * Get all available transform names across all languages
+ *
+ * Returns a set containing all registered transform names, including
+ * language-agnostic and all language-specific transforms.
+ *
+ * @returns Set of all available transform names
+ */
+export function getAllAvailableTransforms(): Set<string> {
+  const available = new Set<string>();
+
+  // Add language-agnostic transforms
+  for (const name of languageAgnosticTransforms.keys()) {
+    available.add(name);
+  }
+
+  // Add all language-specific transforms
+  for (const langTransforms of languageSpecificTransforms.values()) {
+    for (const name of langTransforms.keys()) {
+      available.add(name);
+    }
+  }
+
+  return available;
+}
+
 /**
  * Get all available transform names for a given language
+ *
+ * Returns a set containing language-agnostic transforms plus transforms
+ * specific to the requested language.
+ *
+ * @param language - The language code (e.g., 'en', 'de')
+ * @returns Set of available transform names for the language
  */
 export function getAvailableTransforms(language: Language = 'en'): Set<string> {
   const available = new Set<string>();