illuma-agents 1.0.2

package/src/llm/anthropic/utils/message_outputs.ts

@@ -0,0 +1,289 @@
+/**
+ * This util file contains functions for converting Anthropic messages to LangChain messages.
+ */
+import Anthropic from '@anthropic-ai/sdk';
+import {
+  AIMessage,
+  AIMessageChunk,
+  UsageMetadata,
+} from '@langchain/core/messages';
+import type { ToolCallChunk } from '@langchain/core/messages/tool';
+import { ChatGeneration } from '@langchain/core/outputs';
+import { extractToolCalls } from './output_parsers';
+import { AnthropicMessageResponse } from '../types';
+
+export function _makeMessageChunkFromAnthropicEvent(
+  data: Anthropic.Messages.RawMessageStreamEvent,
+  fields: {
+    streamUsage: boolean;
+    coerceContentToString: boolean;
+  }
+): {
+  chunk: AIMessageChunk;
+} | null {
+  if (data.type === 'message_start') {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const { content, usage, ...additionalKwargs } = data.message;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const filteredAdditionalKwargs: Record<string, any> = {};
+    for (const [key, value] of Object.entries(additionalKwargs)) {
+      if (value !== undefined && value !== null) {
+        filteredAdditionalKwargs[key] = value;
+      }
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const { input_tokens, output_tokens, ...rest }: Record<string, any> =
+      usage ?? {};
+    const usageMetadata: UsageMetadata = {
+      input_tokens,
+      output_tokens,
+      total_tokens: input_tokens + output_tokens,
+      input_token_details: {
+        cache_creation: rest.cache_creation_input_tokens,
+        cache_read: rest.cache_read_input_tokens,
+      },
+    };
+    return {
+      chunk: new AIMessageChunk({
+        content: fields.coerceContentToString ? '' : [],
+        additional_kwargs: filteredAdditionalKwargs,
+        usage_metadata: fields.streamUsage ? usageMetadata : undefined,
+        response_metadata: {
+          usage: {
+            ...rest,
+          },
+        },
+        id: data.message.id,
+      }),
+    };
+  } else if (data.type === 'message_delta') {
+    const usageMetadata: UsageMetadata = {
+      input_tokens: 0,
+      output_tokens: data.usage.output_tokens,
+      total_tokens: data.usage.output_tokens,
+      input_token_details: {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        cache_creation: (data.usage as any).cache_creation_input_tokens,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        cache_read: (data.usage as any).cache_read_input_tokens,
+      },
+    };
+    return {
+      chunk: new AIMessageChunk({
+        content: fields.coerceContentToString ? '' : [],
+        additional_kwargs: { ...data.delta },
+        usage_metadata: fields.streamUsage ? usageMetadata : undefined,
+      }),
+    };
+  } else if (
+    data.type === 'content_block_start' &&
+    [
+      'tool_use',
+      'document',
+      'server_tool_use',
+      'web_search_tool_result',
+    ].includes(data.content_block.type)
+  ) {
+    const contentBlock = data.content_block;
+    let toolCallChunks: ToolCallChunk[];
+    if (contentBlock.type === 'tool_use') {
+      toolCallChunks = [
+        {
+          id: contentBlock.id,
+          index: data.index,
+          name: contentBlock.name,
+          args: '',
+        },
+      ];
+    } else if (contentBlock.type === 'server_tool_use') {
+      // Handle anthropic built-in server tool use (like web search)
+      toolCallChunks = [
+        {
+          id: contentBlock.id,
+          index: data.index,
+          name: contentBlock.name,
+          args: '',
+        },
+      ];
+    } else {
+      toolCallChunks = [];
+    }
+    return {
+      chunk: new AIMessageChunk({
+        content: fields.coerceContentToString
+          ? ''
+          : [
+            {
+              index: data.index,
+              ...data.content_block,
+              input:
+                  contentBlock.type === 'server_tool_use' ||
+                  contentBlock.type === 'tool_use'
+                    ? ''
+                    : undefined,
+            },
+          ],
+        additional_kwargs: {},
+        tool_call_chunks: toolCallChunks,
+      }),
+    };
+  } else if (
+    data.type === 'content_block_delta' &&
+    [
+      'text_delta',
+      'citations_delta',
+      'thinking_delta',
+      'signature_delta',
+    ].includes(data.delta.type)
+  ) {
+    if (fields.coerceContentToString && 'text' in data.delta) {
+      return {
+        chunk: new AIMessageChunk({
+          content: data.delta.text,
+        }),
+      };
+    } else {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const contentBlock: Record<string, any> = data.delta;
+      if ('citation' in contentBlock) {
+        contentBlock.citations = [contentBlock.citation];
+        delete contentBlock.citation;
+      }
+      if (
+        contentBlock.type === 'thinking_delta' ||
+        contentBlock.type === 'signature_delta'
+      ) {
+        return {
+          chunk: new AIMessageChunk({
+            content: [{ index: data.index, ...contentBlock, type: 'thinking' }],
+          }),
+        };
+      }
+
+      return {
+        chunk: new AIMessageChunk({
+          content: [{ index: data.index, ...contentBlock, type: 'text' }],
+        }),
+      };
+    }
+  } else if (
+    data.type === 'content_block_delta' &&
+    data.delta.type === 'input_json_delta'
+  ) {
+    return {
+      chunk: new AIMessageChunk({
+        content: fields.coerceContentToString
+          ? ''
+          : [
+            {
+              index: data.index,
+              input: data.delta.partial_json,
+              type: data.delta.type,
+            },
+          ],
+        additional_kwargs: {},
+        tool_call_chunks: [
+          {
+            index: data.index,
+            args: data.delta.partial_json,
+          },
+        ],
+      }),
+    };
+  } else if (
+    data.type === 'content_block_start' &&
+    data.content_block.type === 'text'
+  ) {
+    const content = data.content_block.text;
+    if (content !== undefined) {
+      return {
+        chunk: new AIMessageChunk({
+          content: fields.coerceContentToString
+            ? content
+            : [
+              {
+                index: data.index,
+                ...data.content_block,
+              },
+            ],
+          additional_kwargs: {},
+        }),
+      };
+    }
+  } else if (
+    data.type === 'content_block_start' &&
+    data.content_block.type === 'redacted_thinking'
+  ) {
+    return {
+      chunk: new AIMessageChunk({
+        content: fields.coerceContentToString
+          ? ''
+          : [{ index: data.index, ...data.content_block }],
+      }),
+    };
+  } else if (
+    data.type === 'content_block_start' &&
+    data.content_block.type === 'thinking'
+  ) {
+    const content = data.content_block.thinking;
+    return {
+      chunk: new AIMessageChunk({
+        content: fields.coerceContentToString
+          ? content
+          : [{ index: data.index, ...data.content_block }],
+      }),
+    };
+  }
+  return null;
+}
+
+export function anthropicResponseToChatMessages(
+  messages: AnthropicMessageResponse[],
+  additionalKwargs: Record<string, unknown>
+): ChatGeneration[] {
+  const usage: Record<string, number> | null | undefined =
+    additionalKwargs.usage as Record<string, number> | null | undefined;
+  const usageMetadata =
+    usage != null
+      ? {
+        input_tokens: usage.input_tokens ?? 0,
+        output_tokens: usage.output_tokens ?? 0,
+        total_tokens: (usage.input_tokens ?? 0) + (usage.output_tokens ?? 0),
+        input_token_details: {
+          cache_creation: usage.cache_creation_input_tokens,
+          cache_read: usage.cache_read_input_tokens,
+        },
+      }
+      : undefined;
+  if (messages.length === 1 && messages[0].type === 'text') {
+    return [
+      {
+        text: messages[0].text,
+        message: new AIMessage({
+          content: messages[0].text,
+          additional_kwargs: additionalKwargs,
+          usage_metadata: usageMetadata,
+          response_metadata: additionalKwargs,
+          id: additionalKwargs.id as string,
+        }),
+      },
+    ];
+  } else {
+    const toolCalls = extractToolCalls(messages);
+    const generations: ChatGeneration[] = [
+      {
+        text: '',
+        message: new AIMessage({
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          content: messages as any,
+          additional_kwargs: additionalKwargs,
+          tool_calls: toolCalls,
+          usage_metadata: usageMetadata,
+          response_metadata: additionalKwargs,
+          id: additionalKwargs.id as string,
+        }),
+      },
+    ];
+    return generations;
+  }
+}

package/src/llm/anthropic/utils/output_parsers.ts

@@ -0,0 +1,133 @@
+/* eslint-disable @typescript-eslint/explicit-function-return-type */
+/* eslint-disable @typescript-eslint/no-empty-object-type */
+import {
+  BaseLLMOutputParser,
+  OutputParserException,
+} from '@langchain/core/output_parsers';
+import { JsonOutputKeyToolsParserParamsInterop } from '@langchain/core/output_parsers/openai_tools';
+import { ChatGeneration } from '@langchain/core/outputs';
+import { ToolCall } from '@langchain/core/messages/tool';
+import {
+  interopSafeParseAsync,
+  InteropZodType,
+} from '@langchain/core/utils/types';
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+interface AnthropicToolsOutputParserParams<T extends Record<string, any>>
+  extends JsonOutputKeyToolsParserParamsInterop<T> {}
+
+export class AnthropicToolsOutputParser<
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  T extends Record<string, any> = Record<string, any>,
+> extends BaseLLMOutputParser<T> {
+  static lc_name() {
+    return 'AnthropicToolsOutputParser';
+  }
+
+  lc_namespace = ['langchain', 'anthropic', 'output_parsers'];
+
+  returnId = false;
+
+  /** The type of tool calls to return. */
+  keyName: string;
+
+  /** Whether to return only the first tool call. */
+  returnSingle = false;
+
+  zodSchema?: InteropZodType<T>;
+
+  constructor(params: AnthropicToolsOutputParserParams<T>) {
+    super(params);
+    this.keyName = params.keyName;
+    this.returnSingle = params.returnSingle ?? this.returnSingle;
+    this.zodSchema = params.zodSchema;
+  }
+
+  protected async _validateResult(result: unknown): Promise<T> {
+    let parsedResult = result;
+    if (typeof result === 'string') {
+      try {
+        parsedResult = JSON.parse(result);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      } catch (e: any) {
+        throw new OutputParserException(
+          `Failed to parse. Text: "${JSON.stringify(
+            result,
+            null,
+            2
+          )}". Error: ${JSON.stringify(e.message)}`,
+          result
+        );
+      }
+    } else {
+      parsedResult = result;
+    }
+    if (this.zodSchema === undefined) {
+      return parsedResult as T;
+    }
+    const zodParsedResult = await interopSafeParseAsync(
+      this.zodSchema,
+      parsedResult
+    );
+    if (zodParsedResult.success) {
+      return zodParsedResult.data;
+    } else {
+      throw new OutputParserException(
+        `Failed to parse. Text: "${JSON.stringify(
+          result,
+          null,
+          2
+        )}". Error: ${JSON.stringify(zodParsedResult.error.issues)}`,
+        JSON.stringify(parsedResult, null, 2)
+      );
+    }
+  }
+
+  async parseResult(generations: ChatGeneration[]): Promise<T> {
+    const tools = generations.flatMap((generation) => {
+      const { message } = generation;
+      if (!Array.isArray(message.content)) {
+        return [];
+      }
+      const tool = extractToolCalls(message.content)[0];
+      return tool;
+    });
+    if (tools[0] === undefined) {
+      throw new Error(
+        'No parseable tool calls provided to AnthropicToolsOutputParser.'
+      );
+    }
+    const [tool] = tools;
+    const validatedResult = await this._validateResult(tool.args);
+    return validatedResult;
+  }
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function extractToolCalls(content: Record<string, any>[]) {
+  const toolCalls: ToolCall[] = [];
+
+  for (const block of content) {
+    if (block.type === 'tool_use') {
+      toolCalls.push({
+        name: block.name,
+        args: block.input,
+        id: block.id,
+        type: 'tool_call',
+      });
+    } else if (
+      block.type === 'server_tool_use' &&
+      block.name === 'web_search'
+    ) {
+      // Handle Anthropic built-in web search tool
+      toolCalls.push({
+        name: block.name,
+        args: block.input,
+        id: block.id,
+        type: 'tool_call',
+      });
+    }
+  }
+
+  return toolCalls;
+}

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

@@ -0,0 +1,29 @@
+import type { Anthropic } from '@anthropic-ai/sdk';
+import { AnthropicToolChoice } from '../types.js';
+
+export function handleToolChoice(
+  toolChoice?: AnthropicToolChoice
+):
+  | Anthropic.Messages.ToolChoiceAuto
+  | Anthropic.Messages.ToolChoiceAny
+  | Anthropic.Messages.ToolChoiceTool
+  | undefined {
+  if (toolChoice == null) {
+    return undefined;
+  } else if (toolChoice === 'any') {
+    return {
+      type: 'any',
+    };
+  } else if (toolChoice === 'auto') {
+    return {
+      type: 'auto',
+    };
+  } else if (typeof toolChoice === 'string') {
+    return {
+      type: 'tool',
+      name: toolChoice,
+    };
+  } else {
+    return toolChoice;
+  }
+}

package/src/llm/fake.ts

@@ -0,0 +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,
+  });
+}