illuma-agents 1.0.8 → 1.0.9

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

@@ -1,133 +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;
-}
+/* 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

@@ -1,29 +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;
-  }
-}
+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/bedrock/index.ts

@@ -0,0 +1,128 @@
+/**
+ * Optimized ChatBedrockConverse wrapper that fixes contentBlockIndex conflicts
+ *
+ * Bedrock sends the same contentBlockIndex for both text and tool_use content blocks,
+ * causing LangChain's merge logic to fail with "field[contentBlockIndex] already exists"
+ * errors. This wrapper simply strips contentBlockIndex from response_metadata to avoid
+ * the conflict.
+ *
+ * The contentBlockIndex field is only used internally by Bedrock's streaming protocol
+ * and isn't needed by application logic - the index field on tool_call_chunks serves
+ * the purpose of tracking tool call ordering.
+ */
+
+import { ChatBedrockConverse } from '@langchain/aws';
+import type { ChatBedrockConverseInput } from '@langchain/aws';
+import { AIMessageChunk } from '@langchain/core/messages';
+import type { BaseMessage } from '@langchain/core/messages';
+import { ChatGenerationChunk } from '@langchain/core/outputs';
+import type { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager';
+
+export class CustomChatBedrockConverse extends ChatBedrockConverse {
+  constructor(fields?: ChatBedrockConverseInput) {
+    super(fields);
+  }
+
+  static lc_name(): string {
+    return 'IllumaBedrockConverse';
+  }
+
+  /**
+   * Override _streamResponseChunks to strip contentBlockIndex from response_metadata
+   * This prevents LangChain's merge conflicts when the same index is used for
+   * different content types (text vs tool calls)
+   */
+  async *_streamResponseChunks(
+    messages: BaseMessage[],
+    options: this['ParsedCallOptions'],
+    runManager?: CallbackManagerForLLMRun
+  ): AsyncGenerator<ChatGenerationChunk> {
+    const baseStream = super._streamResponseChunks(
+      messages,
+      options,
+      runManager
+    );
+
+    for await (const chunk of baseStream) {
+      // Only process if we have response_metadata
+      if (
+        chunk.message instanceof AIMessageChunk &&
+        (chunk.message as Partial<AIMessageChunk>).response_metadata &&
+        typeof chunk.message.response_metadata === 'object'
+      ) {
+        // Check if contentBlockIndex exists anywhere in response_metadata (top level or nested)
+        const hasContentBlockIndex = this.hasContentBlockIndex(
+          chunk.message.response_metadata
+        );
+
+        if (hasContentBlockIndex) {
+          const cleanedMetadata = this.removeContentBlockIndex(
+            chunk.message.response_metadata
+          ) as Record<string, unknown>;
+
+          yield new ChatGenerationChunk({
+            text: chunk.text,
+            message: new AIMessageChunk({
+              ...chunk.message,
+              response_metadata: cleanedMetadata,
+            }),
+            generationInfo: chunk.generationInfo,
+          });
+          continue;
+        }
+      }
+
+      yield chunk;
+    }
+  }
+
+  /**
+   * Check if contentBlockIndex exists at any level in the object
+   */
+  private hasContentBlockIndex(obj: unknown): boolean {
+    if (obj === null || obj === undefined || typeof obj !== 'object') {
+      return false;
+    }
+
+    if ('contentBlockIndex' in obj) {
+      return true;
+    }
+
+    for (const value of Object.values(obj)) {
+      if (typeof value === 'object' && value !== null) {
+        if (this.hasContentBlockIndex(value)) {
+          return true;
+        }
+      }
+    }
+
+    return false;
+  }
+
+  /**
+   * Recursively remove contentBlockIndex from all levels of an object
+   */
+  private removeContentBlockIndex(obj: unknown): unknown {
+    if (obj === null || obj === undefined) {
+      return obj;
+    }
+
+    if (Array.isArray(obj)) {
+      return obj.map((item) => this.removeContentBlockIndex(item));
+    }
+
+    if (typeof obj === 'object') {
+      const cleaned: Record<string, unknown> = {};
+      for (const [key, value] of Object.entries(obj)) {
+        if (key !== 'contentBlockIndex') {
+          cleaned[key] = this.removeContentBlockIndex(value);
+        }
+      }
+      return cleaned;
+    }
+
+    return obj;
+  }
+}
+
+export type { ChatBedrockConverseInput };