illuma-agents 1.0.7 → 1.0.9

package/src/llm/google/utils/tools.ts

@@ -1,160 +1,160 @@
-import {
-  Tool as GenerativeAITool,
-  ToolConfig,
-  FunctionCallingMode,
-  FunctionDeclaration,
-  FunctionDeclarationsTool,
-  FunctionDeclarationSchema,
-} from '@google/generative-ai';
-import { ToolChoice } from '@langchain/core/language_models/chat_models';
-import { StructuredToolInterface } from '@langchain/core/tools';
-import { isLangChainTool } from '@langchain/core/utils/function_calling';
-import {
-  isOpenAITool,
-  ToolDefinition,
-} from '@langchain/core/language_models/base';
-import { convertToGenerativeAITools } from './common';
-import { GoogleGenerativeAIToolType } from '../types';
-import { removeAdditionalProperties } from './zod_to_genai_parameters';
-
-export function convertToolsToGenAI(
-  tools: GoogleGenerativeAIToolType[],
-  extra?: {
-    toolChoice?: ToolChoice;
-    allowedFunctionNames?: string[];
-  }
-): {
-  tools: GenerativeAITool[];
-  toolConfig?: ToolConfig;
-} {
-  // Extract function declaration processing to a separate function
-  const genAITools = processTools(tools);
-
-  // Simplify tool config creation
-  const toolConfig = createToolConfig(genAITools, extra);
-
-  return { tools: genAITools, toolConfig };
-}
-
-function processTools(tools: GoogleGenerativeAIToolType[]): GenerativeAITool[] {
-  let functionDeclarationTools: FunctionDeclaration[] = [];
-  const genAITools: GenerativeAITool[] = [];
-
-  tools.forEach((tool) => {
-    if (isLangChainTool(tool)) {
-      const [convertedTool] = convertToGenerativeAITools([
-        tool as StructuredToolInterface,
-      ]);
-      if (convertedTool.functionDeclarations) {
-        functionDeclarationTools.push(...convertedTool.functionDeclarations);
-      }
-    } else if (isOpenAITool(tool)) {
-      const { functionDeclarations } = convertOpenAIToolToGenAI(tool);
-      if (functionDeclarations) {
-        functionDeclarationTools.push(...functionDeclarations);
-      } else {
-        throw new Error(
-          'Failed to convert OpenAI structured tool to GenerativeAI tool'
-        );
-      }
-    } else {
-      genAITools.push(tool as GenerativeAITool);
-    }
-  });
-
-  const genAIFunctionDeclaration = genAITools.find(
-    (t) => 'functionDeclarations' in t
-  );
-  if (genAIFunctionDeclaration) {
-    return genAITools.map((tool) => {
-      if (
-        functionDeclarationTools.length > 0 &&
-        'functionDeclarations' in tool
-      ) {
-        const newTool = {
-          functionDeclarations: [
-            ...(tool.functionDeclarations || []),
-            ...functionDeclarationTools,
-          ],
-        };
-        // Clear the functionDeclarationTools array so it is not passed again
-        functionDeclarationTools = [];
-        return newTool;
-      }
-      return tool;
-    });
-  }
-
-  return [
-    ...genAITools,
-    ...(functionDeclarationTools.length > 0
-      ? [
-        {
-          functionDeclarations: functionDeclarationTools,
-        },
-      ]
-      : []),
-  ];
-}
-
-function convertOpenAIToolToGenAI(
-  tool: ToolDefinition
-): FunctionDeclarationsTool {
-  return {
-    functionDeclarations: [
-      {
-        name: tool.function.name,
-        description: tool.function.description,
-        parameters: removeAdditionalProperties(
-          tool.function.parameters
-        ) as FunctionDeclarationSchema,
-      },
-    ],
-  };
-}
-
-function createToolConfig(
-  genAITools: GenerativeAITool[],
-  extra?: {
-    toolChoice?: ToolChoice;
-    allowedFunctionNames?: string[];
-  }
-): ToolConfig | undefined {
-  if (!genAITools.length || !extra) return undefined;
-
-  const { toolChoice, allowedFunctionNames } = extra;
-
-  const modeMap: Record<string, FunctionCallingMode> = {
-    any: FunctionCallingMode.ANY,
-    auto: FunctionCallingMode.AUTO,
-    none: FunctionCallingMode.NONE,
-  };
-
-  if (
-    toolChoice != null &&
-    ['any', 'auto', 'none'].includes(toolChoice as string)
-  ) {
-    return {
-      functionCallingConfig: {
-        mode: modeMap[toolChoice as keyof typeof modeMap] ?? 'MODE_UNSPECIFIED',
-        allowedFunctionNames,
-      },
-    };
-  }
-
-  if (typeof toolChoice === 'string' || allowedFunctionNames) {
-    return {
-      functionCallingConfig: {
-        mode: FunctionCallingMode.ANY,
-        allowedFunctionNames: [
-          ...(allowedFunctionNames ?? []),
-          ...(toolChoice != null && typeof toolChoice === 'string'
-            ? [toolChoice]
-            : []),
-        ],
-      },
-    };
-  }
-
-  return undefined;
-}
+import {
+  Tool as GenerativeAITool,
+  ToolConfig,
+  FunctionCallingMode,
+  FunctionDeclaration,
+  FunctionDeclarationsTool,
+  FunctionDeclarationSchema,
+} from '@google/generative-ai';
+import { ToolChoice } from '@langchain/core/language_models/chat_models';
+import { StructuredToolInterface } from '@langchain/core/tools';
+import { isLangChainTool } from '@langchain/core/utils/function_calling';
+import {
+  isOpenAITool,
+  ToolDefinition,
+} from '@langchain/core/language_models/base';
+import { convertToGenerativeAITools } from './common';
+import { GoogleGenerativeAIToolType } from '../types';
+import { removeAdditionalProperties } from './zod_to_genai_parameters';
+
+export function convertToolsToGenAI(
+  tools: GoogleGenerativeAIToolType[],
+  extra?: {
+    toolChoice?: ToolChoice;
+    allowedFunctionNames?: string[];
+  }
+): {
+  tools: GenerativeAITool[];
+  toolConfig?: ToolConfig;
+} {
+  // Extract function declaration processing to a separate function
+  const genAITools = processTools(tools);
+
+  // Simplify tool config creation
+  const toolConfig = createToolConfig(genAITools, extra);
+
+  return { tools: genAITools, toolConfig };
+}
+
+function processTools(tools: GoogleGenerativeAIToolType[]): GenerativeAITool[] {
+  let functionDeclarationTools: FunctionDeclaration[] = [];
+  const genAITools: GenerativeAITool[] = [];
+
+  tools.forEach((tool) => {
+    if (isLangChainTool(tool)) {
+      const [convertedTool] = convertToGenerativeAITools([
+        tool as StructuredToolInterface,
+      ]);
+      if (convertedTool.functionDeclarations) {
+        functionDeclarationTools.push(...convertedTool.functionDeclarations);
+      }
+    } else if (isOpenAITool(tool)) {
+      const { functionDeclarations } = convertOpenAIToolToGenAI(tool);
+      if (functionDeclarations) {
+        functionDeclarationTools.push(...functionDeclarations);
+      } else {
+        throw new Error(
+          'Failed to convert OpenAI structured tool to GenerativeAI tool'
+        );
+      }
+    } else {
+      genAITools.push(tool as GenerativeAITool);
+    }
+  });
+
+  const genAIFunctionDeclaration = genAITools.find(
+    (t) => 'functionDeclarations' in t
+  );
+  if (genAIFunctionDeclaration) {
+    return genAITools.map((tool) => {
+      if (
+        functionDeclarationTools.length > 0 &&
+        'functionDeclarations' in tool
+      ) {
+        const newTool = {
+          functionDeclarations: [
+            ...(tool.functionDeclarations || []),
+            ...functionDeclarationTools,
+          ],
+        };
+        // Clear the functionDeclarationTools array so it is not passed again
+        functionDeclarationTools = [];
+        return newTool;
+      }
+      return tool;
+    });
+  }
+
+  return [
+    ...genAITools,
+    ...(functionDeclarationTools.length > 0
+      ? [
+        {
+          functionDeclarations: functionDeclarationTools,
+        },
+      ]
+      : []),
+  ];
+}
+
+function convertOpenAIToolToGenAI(
+  tool: ToolDefinition
+): FunctionDeclarationsTool {
+  return {
+    functionDeclarations: [
+      {
+        name: tool.function.name,
+        description: tool.function.description,
+        parameters: removeAdditionalProperties(
+          tool.function.parameters
+        ) as FunctionDeclarationSchema,
+      },
+    ],
+  };
+}
+
+function createToolConfig(
+  genAITools: GenerativeAITool[],
+  extra?: {
+    toolChoice?: ToolChoice;
+    allowedFunctionNames?: string[];
+  }
+): ToolConfig | undefined {
+  if (!genAITools.length || !extra) return undefined;
+
+  const { toolChoice, allowedFunctionNames } = extra;
+
+  const modeMap: Record<string, FunctionCallingMode> = {
+    any: FunctionCallingMode.ANY,
+    auto: FunctionCallingMode.AUTO,
+    none: FunctionCallingMode.NONE,
+  };
+
+  if (
+    toolChoice != null &&
+    ['any', 'auto', 'none'].includes(toolChoice as string)
+  ) {
+    return {
+      functionCallingConfig: {
+        mode: modeMap[toolChoice as keyof typeof modeMap] ?? 'MODE_UNSPECIFIED',
+        allowedFunctionNames,
+      },
+    };
+  }
+
+  if (typeof toolChoice === 'string' || allowedFunctionNames) {
+    return {
+      functionCallingConfig: {
+        mode: FunctionCallingMode.ANY,
+        allowedFunctionNames: [
+          ...(allowedFunctionNames ?? []),
+          ...(toolChoice != null && typeof toolChoice === 'string'
+            ? [toolChoice]
+            : []),
+        ],
+      },
+    };
+  }
+
+  return undefined;
+}

package/src/llm/openai/types.ts

@@ -1,24 +1,24 @@
-import type { OpenAICallOptions } from '@langchain/openai';
-
-export interface OpenAIChatCallOptions extends OpenAICallOptions {
-  promptIndex?: number;
-}
-
-// TODO import from SDK when available
-export type OpenAIRoleEnum =
-  | 'system'
-  | 'developer'
-  | 'assistant'
-  | 'user'
-  | 'function'
-  | 'tool';
-
-export type HeaderValue = string | undefined | null;
-export type HeadersLike =
-  | Headers
-  | readonly HeaderValue[][]
-  | Record<string, HeaderValue | readonly HeaderValue[]>
-  | undefined
-  | null
-  // NullableHeaders
-  | { values: Headers; [key: string]: unknown };
+import type { OpenAICallOptions } from '@langchain/openai';
+
+export interface OpenAIChatCallOptions extends OpenAICallOptions {
+  promptIndex?: number;
+}
+
+// TODO import from SDK when available
+export type OpenAIRoleEnum =
+  | 'system'
+  | 'developer'
+  | 'assistant'
+  | 'user'
+  | 'function'
+  | 'tool';
+
+export type HeaderValue = string | undefined | null;
+export type HeadersLike =
+  | Headers
+  | readonly HeaderValue[][]
+  | Record<string, HeaderValue | readonly HeaderValue[]>
+  | undefined
+  | null
+  // NullableHeaders
+  | { values: Headers; [key: string]: unknown };

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>(