illuma-agents 1.0.8 → 1.0.10

package/src/llm/fake.ts

@@ -1,133 +1,133 @@
-import { ChatGenerationChunk } from '@langchain/core/outputs';
-import { AIMessageChunk } from '@langchain/core/messages';
-import type { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager';
-import type { BaseMessage } from '@langchain/core/messages';
-import { FakeListChatModel } from '@langchain/core/utils/testing';
-import { ToolCall, ToolCallChunk } from '@langchain/core/messages/tool';
-
-type SplitStrategy = {
-  type: 'regex' | 'fixed';
-  value: RegExp | number;
-};
-
-export class FakeChatModel extends FakeListChatModel {
-  private splitStrategy: SplitStrategy;
-  private toolCalls: ToolCall[] = [];
-  private addedToolCalls: boolean = false;
-
-  constructor({
-    responses,
-    sleep,
-    emitCustomEvent,
-    splitStrategy = { type: 'regex', value: /(?<=\s+)|(?=\s+)/ },
-    toolCalls = []
-  }: {
-    responses: string[];
-    sleep?: number;
-    emitCustomEvent?: boolean;
-    splitStrategy?: SplitStrategy;
-    toolCalls?: ToolCall[];
-  }) {
-    super({ responses, sleep, emitCustomEvent });
-    this.splitStrategy = splitStrategy;
-    this.toolCalls = toolCalls;
-  }
-
-  private splitText(text: string): string[] {
-    if (this.splitStrategy.type === 'regex') {
-      return text.split(this.splitStrategy.value as RegExp);
-    } else {
-      const chunkSize = this.splitStrategy.value as number;
-      const chunks: string[] = [];
-      for (let i = 0; i < text.length; i += chunkSize) {
-        chunks.push(text.slice(i, i + chunkSize));
-      }
-      return chunks;
-    }
-  }
-  _createResponseChunk(text: string, tool_call_chunks?: ToolCallChunk[]): ChatGenerationChunk {
-    return new ChatGenerationChunk({
-      text,
-      generationInfo: {},
-      message: new AIMessageChunk({
-        content: text,
-        tool_call_chunks,
-        additional_kwargs: tool_call_chunks ? {
-          tool_calls: tool_call_chunks.map((toolCall) => ({
-            index: toolCall.index ?? 0,
-            id: toolCall.id ?? '',
-            type: 'function',
-            function: {
-              name: toolCall.name ?? '',
-              arguments: toolCall.args ?? '',
-            },
-          })),
-        } : undefined,
-      })});
-  }
-
-  async *_streamResponseChunks(
-    _messages: BaseMessage[],
-    options: this['ParsedCallOptions'],
-    runManager?: CallbackManagerForLLMRun
-  ): AsyncGenerator<ChatGenerationChunk> {
-    const response = this._currentResponse();
-    this._incrementResponse();
-
-    if (this.emitCustomEvent) {
-      await runManager?.handleCustomEvent('some_test_event', {
-        someval: true,
-      });
-    }
-
-    const chunks = this.splitText(response);
-    for await (const chunk of chunks) {
-      await this._sleepIfRequested();
-
-      if (options.thrownErrorString != null && options.thrownErrorString) {
-        throw new Error(options.thrownErrorString);
-      }
-
-      const responseChunk = super._createResponseChunk(chunk);
-      yield responseChunk;
-      void runManager?.handleLLMNewToken(chunk);
-    }
-
-    await this._sleepIfRequested();
-    if (this.toolCalls.length > 0 && !this.addedToolCalls) {
-      this.addedToolCalls = true;
-      const toolCallChunks = this.toolCalls.map((toolCall) => {;
-        return {
-          name: toolCall.name,
-          args: JSON.stringify(toolCall.args),
-          id: toolCall.id,
-          type: 'tool_call_chunk',
-        } as ToolCallChunk;
-      });
-      const responseChunk = this._createResponseChunk('', toolCallChunks);
-      yield responseChunk;
-      void runManager?.handleLLMNewToken('');
-    }
-  }
-}
-
-export function createFakeStreamingLLM({
-  responses,
-  sleep,
-  splitStrategy,
-  toolCalls,
-} : {
-  responses: string[],
-  sleep?: number,
-  splitStrategy?: SplitStrategy,
-  toolCalls?: ToolCall[]
-}
-): FakeChatModel {
-  return new FakeChatModel({
-    sleep,
-    responses,
-    emitCustomEvent: true,
-    splitStrategy,
-    toolCalls,
-  });
-}
+import { ChatGenerationChunk } from '@langchain/core/outputs';
+import { AIMessageChunk } from '@langchain/core/messages';
+import type { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager';
+import type { BaseMessage } from '@langchain/core/messages';
+import { FakeListChatModel } from '@langchain/core/utils/testing';
+import { ToolCall, ToolCallChunk } from '@langchain/core/messages/tool';
+
+type SplitStrategy = {
+  type: 'regex' | 'fixed';
+  value: RegExp | number;
+};
+
+export class FakeChatModel extends FakeListChatModel {
+  private splitStrategy: SplitStrategy;
+  private toolCalls: ToolCall[] = [];
+  private addedToolCalls: boolean = false;
+
+  constructor({
+    responses,
+    sleep,
+    emitCustomEvent,
+    splitStrategy = { type: 'regex', value: /(?<=\s+)|(?=\s+)/ },
+    toolCalls = []
+  }: {
+    responses: string[];
+    sleep?: number;
+    emitCustomEvent?: boolean;
+    splitStrategy?: SplitStrategy;
+    toolCalls?: ToolCall[];
+  }) {
+    super({ responses, sleep, emitCustomEvent });
+    this.splitStrategy = splitStrategy;
+    this.toolCalls = toolCalls;
+  }
+
+  private splitText(text: string): string[] {
+    if (this.splitStrategy.type === 'regex') {
+      return text.split(this.splitStrategy.value as RegExp);
+    } else {
+      const chunkSize = this.splitStrategy.value as number;
+      const chunks: string[] = [];
+      for (let i = 0; i < text.length; i += chunkSize) {
+        chunks.push(text.slice(i, i + chunkSize));
+      }
+      return chunks;
+    }
+  }
+  _createResponseChunk(text: string, tool_call_chunks?: ToolCallChunk[]): ChatGenerationChunk {
+    return new ChatGenerationChunk({
+      text,
+      generationInfo: {},
+      message: new AIMessageChunk({
+        content: text,
+        tool_call_chunks,
+        additional_kwargs: tool_call_chunks ? {
+          tool_calls: tool_call_chunks.map((toolCall) => ({
+            index: toolCall.index ?? 0,
+            id: toolCall.id ?? '',
+            type: 'function',
+            function: {
+              name: toolCall.name ?? '',
+              arguments: toolCall.args ?? '',
+            },
+          })),
+        } : undefined,
+      })});
+  }
+
+  async *_streamResponseChunks(
+    _messages: BaseMessage[],
+    options: this['ParsedCallOptions'],
+    runManager?: CallbackManagerForLLMRun
+  ): AsyncGenerator<ChatGenerationChunk> {
+    const response = this._currentResponse();
+    this._incrementResponse();
+
+    if (this.emitCustomEvent) {
+      await runManager?.handleCustomEvent('some_test_event', {
+        someval: true,
+      });
+    }
+
+    const chunks = this.splitText(response);
+    for await (const chunk of chunks) {
+      await this._sleepIfRequested();
+
+      if (options.thrownErrorString != null && options.thrownErrorString) {
+        throw new Error(options.thrownErrorString);
+      }
+
+      const responseChunk = super._createResponseChunk(chunk);
+      yield responseChunk;
+      void runManager?.handleLLMNewToken(chunk);
+    }
+
+    await this._sleepIfRequested();
+    if (this.toolCalls.length > 0 && !this.addedToolCalls) {
+      this.addedToolCalls = true;
+      const toolCallChunks = this.toolCalls.map((toolCall) => {;
+        return {
+          name: toolCall.name,
+          args: JSON.stringify(toolCall.args),
+          id: toolCall.id,
+          type: 'tool_call_chunk',
+        } as ToolCallChunk;
+      });
+      const responseChunk = this._createResponseChunk('', toolCallChunks);
+      yield responseChunk;
+      void runManager?.handleLLMNewToken('');
+    }
+  }
+}
+
+export function createFakeStreamingLLM({
+  responses,
+  sleep,
+  splitStrategy,
+  toolCalls,
+} : {
+  responses: string[],
+  sleep?: number,
+  splitStrategy?: SplitStrategy,
+  toolCalls?: ToolCall[]
+}
+): FakeChatModel {
+  return new FakeChatModel({
+    sleep,
+    responses,
+    emitCustomEvent: true,
+    splitStrategy,
+    toolCalls,
+  });
+}

package/src/llm/google/llm.spec.ts

@@ -1,6 +1,8 @@
 import { config } from 'dotenv';
 config();
-import { test } from '@jest/globals';
+import { test, jest } from '@jest/globals';
+
+jest.setTimeout(90000);
 import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
 import {

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;
+}