illuma-agents 1.0.8 → 1.0.9

package/src/llm/openai/utils/isReasoningModel.test.ts

@@ -1,90 +1,90 @@
-import { isReasoningModel } from './index';
-
-describe('isReasoningModel', () => {
-  describe('should return true for reasoning models', () => {
-    test('basic o-series models', () => {
-      expect(isReasoningModel('o1')).toBe(true);
-      expect(isReasoningModel('o2')).toBe(true);
-      expect(isReasoningModel('o9')).toBe(true);
-      expect(isReasoningModel('o1-preview')).toBe(true);
-      expect(isReasoningModel('o1-mini')).toBe(true);
-    });
-
-    test('gpt-5+ models', () => {
-      expect(isReasoningModel('gpt-5')).toBe(true);
-      expect(isReasoningModel('gpt-6')).toBe(true);
-      expect(isReasoningModel('gpt-7')).toBe(true);
-      expect(isReasoningModel('gpt-8')).toBe(true);
-      expect(isReasoningModel('gpt-9')).toBe(true);
-    });
-
-    test('with provider prefixes', () => {
-      expect(isReasoningModel('azure/o1')).toBe(true);
-      expect(isReasoningModel('azure/gpt-5')).toBe(true);
-      expect(isReasoningModel('openai/o1')).toBe(true);
-      expect(isReasoningModel('openai/gpt-5')).toBe(true);
-    });
-
-    test('with custom prefixes', () => {
-      expect(isReasoningModel('custom-provider/o1')).toBe(true);
-      expect(isReasoningModel('my-deployment/gpt-5')).toBe(true);
-      expect(isReasoningModel('company/azure/gpt-5')).toBe(true);
-    });
-
-    test('case insensitive', () => {
-      expect(isReasoningModel('O1')).toBe(true);
-      expect(isReasoningModel('GPT-5')).toBe(true);
-      expect(isReasoningModel('gPt-6')).toBe(true);
-      expect(isReasoningModel('Azure/O1')).toBe(true);
-    });
-  });
-
-  describe('should return false for non-reasoning models', () => {
-    test('older GPT models', () => {
-      expect(isReasoningModel('gpt-3.5-turbo')).toBe(false);
-      expect(isReasoningModel('gpt-4')).toBe(false);
-      expect(isReasoningModel('gpt-4-turbo')).toBe(false);
-      expect(isReasoningModel('gpt-4o')).toBe(false);
-      expect(isReasoningModel('gpt-4o-mini')).toBe(false);
-    });
-
-    test('other model families', () => {
-      expect(isReasoningModel('claude-3')).toBe(false);
-      expect(isReasoningModel('claude-3-opus')).toBe(false);
-      expect(isReasoningModel('llama-2')).toBe(false);
-      expect(isReasoningModel('gemini-pro')).toBe(false);
-    });
-
-    test('partial matches that should not match', () => {
-      expect(isReasoningModel('proto1')).toBe(false);
-      expect(isReasoningModel('version-o1')).toBe(true);
-      expect(isReasoningModel('gpt-40')).toBe(false);
-      expect(isReasoningModel('gpt-3.5')).toBe(false);
-    });
-
-    test('empty, null, and undefined', () => {
-      expect(isReasoningModel('')).toBe(false);
-      expect(isReasoningModel()).toBe(false);
-      expect(isReasoningModel(undefined)).toBe(false);
-    });
-  });
-
-  describe('edge cases', () => {
-    test('with special characters', () => {
-      expect(isReasoningModel('deployment_o1_model')).toBe(false);
-      expect(isReasoningModel('gpt-5-deployment')).toBe(true);
-      expect(isReasoningModel('o1@latest')).toBe(true);
-      expect(isReasoningModel('gpt-5.0')).toBe(true);
-    });
-
-    test('word boundary behavior', () => {
-      // These should match because o1 and gpt-5 are whole words
-      expect(isReasoningModel('use-o1-model')).toBe(true);
-      expect(isReasoningModel('model-gpt-5-latest')).toBe(true);
-
-      // These should not match because o1/gpt-5 are not whole words
-      expect(isReasoningModel('proto1model')).toBe(false);
-      expect(isReasoningModel('supergpt-50')).toBe(false);
-    });
-  });
-});
+import { isReasoningModel } from './index';
+
+describe('isReasoningModel', () => {
+  describe('should return true for reasoning models', () => {
+    test('basic o-series models', () => {
+      expect(isReasoningModel('o1')).toBe(true);
+      expect(isReasoningModel('o2')).toBe(true);
+      expect(isReasoningModel('o9')).toBe(true);
+      expect(isReasoningModel('o1-preview')).toBe(true);
+      expect(isReasoningModel('o1-mini')).toBe(true);
+    });
+
+    test('gpt-5+ models', () => {
+      expect(isReasoningModel('gpt-5')).toBe(true);
+      expect(isReasoningModel('gpt-6')).toBe(true);
+      expect(isReasoningModel('gpt-7')).toBe(true);
+      expect(isReasoningModel('gpt-8')).toBe(true);
+      expect(isReasoningModel('gpt-9')).toBe(true);
+    });
+
+    test('with provider prefixes', () => {
+      expect(isReasoningModel('azure/o1')).toBe(true);
+      expect(isReasoningModel('azure/gpt-5')).toBe(true);
+      expect(isReasoningModel('openai/o1')).toBe(true);
+      expect(isReasoningModel('openai/gpt-5')).toBe(true);
+    });
+
+    test('with custom prefixes', () => {
+      expect(isReasoningModel('custom-provider/o1')).toBe(true);
+      expect(isReasoningModel('my-deployment/gpt-5')).toBe(true);
+      expect(isReasoningModel('company/azure/gpt-5')).toBe(true);
+    });
+
+    test('case insensitive', () => {
+      expect(isReasoningModel('O1')).toBe(true);
+      expect(isReasoningModel('GPT-5')).toBe(true);
+      expect(isReasoningModel('gPt-6')).toBe(true);
+      expect(isReasoningModel('Azure/O1')).toBe(true);
+    });
+  });
+
+  describe('should return false for non-reasoning models', () => {
+    test('older GPT models', () => {
+      expect(isReasoningModel('gpt-3.5-turbo')).toBe(false);
+      expect(isReasoningModel('gpt-4')).toBe(false);
+      expect(isReasoningModel('gpt-4-turbo')).toBe(false);
+      expect(isReasoningModel('gpt-4o')).toBe(false);
+      expect(isReasoningModel('gpt-4o-mini')).toBe(false);
+    });
+
+    test('other model families', () => {
+      expect(isReasoningModel('claude-3')).toBe(false);
+      expect(isReasoningModel('claude-3-opus')).toBe(false);
+      expect(isReasoningModel('llama-2')).toBe(false);
+      expect(isReasoningModel('gemini-pro')).toBe(false);
+    });
+
+    test('partial matches that should not match', () => {
+      expect(isReasoningModel('proto1')).toBe(false);
+      expect(isReasoningModel('version-o1')).toBe(true);
+      expect(isReasoningModel('gpt-40')).toBe(false);
+      expect(isReasoningModel('gpt-3.5')).toBe(false);
+    });
+
+    test('empty, null, and undefined', () => {
+      expect(isReasoningModel('')).toBe(false);
+      expect(isReasoningModel()).toBe(false);
+      expect(isReasoningModel(undefined)).toBe(false);
+    });
+  });
+
+  describe('edge cases', () => {
+    test('with special characters', () => {
+      expect(isReasoningModel('deployment_o1_model')).toBe(false);
+      expect(isReasoningModel('gpt-5-deployment')).toBe(true);
+      expect(isReasoningModel('o1@latest')).toBe(true);
+      expect(isReasoningModel('gpt-5.0')).toBe(true);
+    });
+
+    test('word boundary behavior', () => {
+      // These should match because o1 and gpt-5 are whole words
+      expect(isReasoningModel('use-o1-model')).toBe(true);
+      expect(isReasoningModel('model-gpt-5-latest')).toBe(true);
+
+      // These should not match because o1/gpt-5 are not whole words
+      expect(isReasoningModel('proto1model')).toBe(false);
+      expect(isReasoningModel('supergpt-50')).toBe(false);
+    });
+  });
+});

package/src/llm/providers.ts

@@ -1,8 +1,5 @@
 // src/llm/providers.ts
 import { ChatMistralAI } from '@langchain/mistralai';
-import { ChatBedrockConverse } from '@langchain/aws';
-// import { ChatAnthropic } from '@langchain/anthropic';
-// import { ChatVertexAI } from '@langchain/google-vertexai';
 import type {
   ChatModelConstructorMap,
   ProviderOptionsMap,
@@ -15,16 +12,15 @@ import {
   ChatXAI,
 } from '@/llm/openai';
 import { CustomChatGoogleGenerativeAI } from '@/llm/google';
+import { CustomChatBedrockConverse } from '@/llm/bedrock';
 import { CustomAnthropic } from '@/llm/anthropic';
 import { ChatOpenRouter } from '@/llm/openrouter';
 import { ChatVertexAI } from '@/llm/vertexai';
-import { ChatOllama } from '@/llm/ollama';
 import { Providers } from '@/common';
 
 export const llmProviders: Partial<ChatModelConstructorMap> = {
   [Providers.XAI]: ChatXAI,
   [Providers.OPENAI]: ChatOpenAI,
-  [Providers.OLLAMA]: ChatOllama,
   [Providers.AZURE]: AzureChatOpenAI,
   [Providers.VERTEXAI]: ChatVertexAI,
   [Providers.DEEPSEEK]: ChatDeepSeek,
@@ -32,7 +28,7 @@ export const llmProviders: Partial<ChatModelConstructorMap> = {
   [Providers.MISTRAL]: ChatMistralAI,
   [Providers.ANTHROPIC]: CustomAnthropic,
   [Providers.OPENROUTER]: ChatOpenRouter,
-  [Providers.BEDROCK]: ChatBedrockConverse,
+  [Providers.BEDROCK]: CustomChatBedrockConverse,
   // [Providers.ANTHROPIC]: ChatAnthropic,
   [Providers.GOOGLE]: CustomChatGoogleGenerativeAI,
 };
@@ -40,7 +36,6 @@ export const llmProviders: Partial<ChatModelConstructorMap> = {
 export const manualToolStreamProviders = new Set<Providers | string>([
   Providers.ANTHROPIC,
   Providers.BEDROCK,
-  Providers.OLLAMA,
 ]);
 
 export const getChatModelClass = <P extends Providers>(

package/src/llm/text.ts

@@ -1,94 +1,94 @@
-export interface TextStreamOptions {
-  minChunkSize?: number;
-  maxChunkSize?: number;
-  delay?: number;
-  firstWordChunk?: boolean;
-}
-
-export type ProgressCallback = (chunk: string) => void;
-export type PostChunkCallback = (chunk: string) => void;
-
-export class TextStream {
-  private text: string;
-  private currentIndex: number;
-  private minChunkSize: number;
-  private maxChunkSize: number;
-  private delay: number;
-  private firstWordChunk: boolean;
-
-  constructor(text: string, options: TextStreamOptions = {}) {
-    this.text = text;
-    this.currentIndex = 0;
-    this.minChunkSize = options.minChunkSize ?? 4;
-    this.maxChunkSize = options.maxChunkSize ?? 8;
-    this.delay = options.delay ?? 20;
-    this.firstWordChunk = options.firstWordChunk ?? true;
-  }
-
-  private randomInt(min: number, max: number): number {
-    return Math.floor(Math.random() * (max - min)) + min;
-  }
-
-  private static readonly BOUNDARIES = new Set([
-    ' ',
-    '.',
-    ',',
-    '!',
-    '?',
-    ';',
-    ':',
-  ]);
-
-  private findFirstWordBoundary(text: string, minSize: number): number {
-    if (minSize >= text.length) return text.length;
-
-    // Ensure we meet the minimum size first
-    let pos = minSize;
-
-    // Look forward until we find a boundary
-    while (pos < text.length) {
-      if (TextStream.BOUNDARIES.has(text[pos])) {
-        return pos + 1; // Include the boundary character
-      }
-      pos++;
-    }
-
-    return text.length; // If no boundary found, return entire remaining text
-  }
-
-  async *generateText(
-    signal?: AbortSignal,
-    progressCallback?: ProgressCallback
-  ): AsyncGenerator<string, void, unknown> {
-    const { delay, minChunkSize, maxChunkSize } = this;
-
-    while (this.currentIndex < this.text.length) {
-      if (signal?.aborted === true) {
-        break;
-      }
-      await new Promise((resolve) => setTimeout(resolve, delay));
-
-      const remainingText = this.text.slice(this.currentIndex);
-      let chunkSize: number;
-
-      if (this.firstWordChunk) {
-        chunkSize = this.findFirstWordBoundary(remainingText, minChunkSize);
-      } else {
-        const remainingChars = remainingText.length;
-        chunkSize = Math.min(
-          this.randomInt(minChunkSize, maxChunkSize + 1),
-          remainingChars
-        );
-      }
-
-      const chunk = this.text.slice(
-        this.currentIndex,
-        this.currentIndex + chunkSize
-      );
-      progressCallback?.(chunk);
-
-      yield chunk;
-      this.currentIndex += chunkSize;
-    }
-  }
-}
+export interface TextStreamOptions {
+  minChunkSize?: number;
+  maxChunkSize?: number;
+  delay?: number;
+  firstWordChunk?: boolean;
+}
+
+export type ProgressCallback = (chunk: string) => void;
+export type PostChunkCallback = (chunk: string) => void;
+
+export class TextStream {
+  private text: string;
+  private currentIndex: number;
+  private minChunkSize: number;
+  private maxChunkSize: number;
+  private delay: number;
+  private firstWordChunk: boolean;
+
+  constructor(text: string, options: TextStreamOptions = {}) {
+    this.text = text;
+    this.currentIndex = 0;
+    this.minChunkSize = options.minChunkSize ?? 4;
+    this.maxChunkSize = options.maxChunkSize ?? 8;
+    this.delay = options.delay ?? 20;
+    this.firstWordChunk = options.firstWordChunk ?? true;
+  }
+
+  private randomInt(min: number, max: number): number {
+    return Math.floor(Math.random() * (max - min)) + min;
+  }
+
+  private static readonly BOUNDARIES = new Set([
+    ' ',
+    '.',
+    ',',
+    '!',
+    '?',
+    ';',
+    ':',
+  ]);
+
+  private findFirstWordBoundary(text: string, minSize: number): number {
+    if (minSize >= text.length) return text.length;
+
+    // Ensure we meet the minimum size first
+    let pos = minSize;
+
+    // Look forward until we find a boundary
+    while (pos < text.length) {
+      if (TextStream.BOUNDARIES.has(text[pos])) {
+        return pos + 1; // Include the boundary character
+      }
+      pos++;
+    }
+
+    return text.length; // If no boundary found, return entire remaining text
+  }
+
+  async *generateText(
+    signal?: AbortSignal,
+    progressCallback?: ProgressCallback
+  ): AsyncGenerator<string, void, unknown> {
+    const { delay, minChunkSize, maxChunkSize } = this;
+
+    while (this.currentIndex < this.text.length) {
+      if (signal?.aborted === true) {
+        break;
+      }
+      await new Promise((resolve) => setTimeout(resolve, delay));
+
+      const remainingText = this.text.slice(this.currentIndex);
+      let chunkSize: number;
+
+      if (this.firstWordChunk) {
+        chunkSize = this.findFirstWordBoundary(remainingText, minChunkSize);
+      } else {
+        const remainingChars = remainingText.length;
+        chunkSize = Math.min(
+          this.randomInt(minChunkSize, maxChunkSize + 1),
+          remainingChars
+        );
+      }
+
+      const chunk = this.text.slice(
+        this.currentIndex,
+        this.currentIndex + chunkSize
+      );
+      progressCallback?.(chunk);
+
+      yield chunk;
+      this.currentIndex += chunkSize;
+    }
+  }
+}