@illuma-ai/agents 1.0.81

package/dist/types/graphs/Graph.d.ts

@@ -0,0 +1,216 @@
+import { ToolNode } from '@langchain/langgraph/prebuilt';
+import { Runnable, RunnableConfig } from '@langchain/core/runnables';
+import type { UsageMetadata, BaseMessage } from '@langchain/core/messages';
+import type { ToolCall } from '@langchain/core/messages/tool';
+import type * as t from '@/types';
+import { Providers } from '@/common';
+import { type ContextAnalytics } from '@/utils/contextAnalytics';
+import { ToolNode as CustomToolNode } from '@/tools/ToolNode';
+import { AgentContext } from '@/agents/AgentContext';
+import { HandlerRegistry } from '@/events';
+export declare abstract class Graph<T extends t.BaseGraphState = t.BaseGraphState, _TNodeName extends string = string> {
+    abstract resetValues(): void;
+    abstract initializeTools({ currentTools, currentToolMap, }: {
+        currentTools?: t.GraphTools;
+        currentToolMap?: t.ToolMap;
+    }): CustomToolNode<T> | ToolNode<T>;
+    abstract initializeModel({ currentModel, tools, clientOptions, }: {
+        currentModel?: t.ChatModel;
+        tools?: t.GraphTools;
+        clientOptions?: t.ClientOptions;
+    }): Runnable;
+    abstract getRunMessages(): BaseMessage[] | undefined;
+    abstract getContentParts(): t.MessageContentComplex[] | undefined;
+    abstract generateStepId(stepKey: string): [string, number];
+    abstract getKeyList(metadata: Record<string, unknown> | undefined): (string | number | undefined)[];
+    abstract getStepKey(metadata: Record<string, unknown> | undefined): string;
+    abstract checkKeyList(keyList: (string | number | undefined)[]): boolean;
+    abstract getStepIdByKey(stepKey: string, index?: number): string;
+    abstract getRunStep(stepId: string): t.RunStep | undefined;
+    abstract dispatchRunStep(stepKey: string, stepDetails: t.StepDetails, metadata?: Record<string, unknown>): Promise<string>;
+    abstract dispatchRunStepDelta(id: string, delta: t.ToolCallDelta): Promise<void>;
+    abstract dispatchMessageDelta(id: string, delta: t.MessageDelta): Promise<void>;
+    abstract dispatchReasoningDelta(stepId: string, delta: t.ReasoningDelta): Promise<void>;
+    abstract handleToolCallCompleted(data: t.ToolEndData, metadata?: Record<string, unknown>, omitOutput?: boolean): Promise<void>;
+    abstract createCallModel(agentId?: string, currentModel?: t.ChatModel): (state: T, config?: RunnableConfig) => Promise<Partial<T>>;
+    messageStepHasToolCalls: Map<string, boolean>;
+    messageIdsByStepKey: Map<string, string>;
+    prelimMessageIdsByStepKey: Map<string, string>;
+    config: RunnableConfig | undefined;
+    contentData: t.RunStep[];
+    stepKeyIds: Map<string, string[]>;
+    contentIndexMap: Map<string, number>;
+    toolCallStepIds: Map<string, string>;
+    signal?: AbortSignal;
+    /** Set of invoked tool call IDs from non-message run steps completed mid-run, if any */
+    invokedToolIds?: Set<string>;
+    handlerRegistry: HandlerRegistry | undefined;
+    /**
+     * Tool session contexts for automatic state persistence across tool invocations.
+     * Keyed by tool name (e.g., Constants.EXECUTE_CODE).
+     * Currently supports code execution session tracking (session_id, files).
+     */
+    sessions: t.ToolSessionMap;
+}
+export declare class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
+    overrideModel?: t.ChatModel;
+    /** Optional compile options passed into workflow.compile() */
+    compileOptions?: t.CompileOptions | undefined;
+    messages: BaseMessage[];
+    runId: string | undefined;
+    startIndex: number;
+    signal?: AbortSignal;
+    /** Map of agent contexts by agent ID */
+    agentContexts: Map<string, AgentContext>;
+    /** Default agent ID to use */
+    defaultAgentId: string;
+    /** Normalized finish/stop reason from the last LLM invocation */
+    lastFinishReason: string | undefined;
+    constructor({ runId, signal, agents, tokenCounter, indexTokenCountMap, }: t.StandardGraphInput);
+    resetValues(keepContent?: boolean): void;
+    /**
+     * Returns the normalized finish/stop reason from the last LLM invocation.
+     * Used by callers to detect when the response was truncated due to max_tokens.
+     */
+    getLastFinishReason(): string | undefined;
+    /**
+     * Estimates a human-friendly description of the conversation timeframe based on message count.
+     * Uses rough heuristics to provide context about how much history is available.
+     *
+     * @param messageCount - Number of messages in the remaining context
+     * @returns A friendly description like "the last few minutes", "the past hour", etc.
+     */
+    getContextTimeframeDescription(messageCount: number): string;
+    getRunStep(stepId: string): t.RunStep | undefined;
+    getAgentContext(metadata: Record<string, unknown> | undefined): AgentContext;
+    getStepKey(metadata: Record<string, unknown> | undefined): string;
+    getStepIdByKey(stepKey: string, index?: number): string;
+    generateStepId(stepKey: string): [string, number];
+    getKeyList(metadata: Record<string, unknown> | undefined): (string | number | undefined)[];
+    checkKeyList(keyList: (string | number | undefined)[]): boolean;
+    getRunMessages(): BaseMessage[] | undefined;
+    getContentParts(): t.MessageContentComplex[] | undefined;
+    /**
+     * Get all run steps, optionally filtered by agent ID
+     */
+    getRunSteps(agentId?: string): t.RunStep[];
+    /**
+     * Get run steps grouped by agent ID
+     */
+    getRunStepsByAgent(): Map<string, t.RunStep[]>;
+    /**
+     * Get agent IDs that participated in this run
+     */
+    getActiveAgentIds(): string[];
+    /**
+     * Maps contentPart indices to agent IDs for post-run analysis
+     * Returns a map where key is the contentPart index and value is the agentId
+     */
+    getContentPartAgentMap(): Map<number, string>;
+    /**
+     * Get the context breakdown from the primary agent for admin token tracking.
+     * Returns detailed token counts for instructions, tools, etc.
+     */
+    getContextBreakdown(): {
+        instructions: number;
+        artifacts: number;
+        tools: number;
+        toolCount: number;
+        toolContext: number;
+        total: number;
+        toolsDetail: Array<{
+            name: string;
+            tokens: number;
+        }>;
+        toolContextDetail: Array<{
+            name: string;
+            tokens: number;
+        }>;
+    } | null;
+    /**
+     * Get the latest context analytics from the graph.
+     * Returns metrics like utilization %, TOON stats, message breakdown.
+     */
+    getContextAnalytics(): ContextAnalytics | null;
+    /** Store the latest context analytics for retrieval after run */
+    private lastContextAnalytics;
+    createSystemRunnable({ provider, clientOptions, instructions, additional_instructions, }: {
+        provider?: Providers;
+        clientOptions?: t.ClientOptions;
+        instructions?: string;
+        additional_instructions?: string;
+    }): t.SystemRunnable | undefined;
+    initializeTools({ currentTools, currentToolMap, agentContext, }: {
+        currentTools?: t.GraphTools;
+        currentToolMap?: t.ToolMap;
+        agentContext?: AgentContext;
+    }): CustomToolNode<t.BaseGraphState> | ToolNode<t.BaseGraphState>;
+    initializeModel({ provider, tools, clientOptions, }: {
+        provider: Providers;
+        tools?: t.GraphTools;
+        clientOptions?: t.ClientOptions;
+    }): Runnable;
+    overrideTestModel(responses: string[], sleep?: number, toolCalls?: ToolCall[]): void;
+    getNewModel({ provider, clientOptions, }: {
+        provider: Providers;
+        clientOptions?: t.ClientOptions;
+    }): t.ChatModelInstance;
+    getUsageMetadata(finalMessage?: BaseMessage): Partial<UsageMetadata> | undefined;
+    /** Execute model invocation with streaming support */
+    private attemptInvoke;
+    /**
+     * Execute model invocation with structured output.
+     * Uses native constrained decoding (jsonSchema method) for supported providers,
+     * or falls back to withStructuredOutput with functionCalling/jsonMode.
+     *
+     * Native mode uses provider APIs directly:
+     * - Anthropic: output_config.format via LangChain's method: 'json_schema'
+     * - OpenAI/Azure: response_format.json_schema via LangChain's method: 'jsonSchema'
+     * - Bedrock: falls back to functionCalling (LangChain doesn't support native yet)
+     */
+    private attemptStructuredInvoke;
+    cleanupSignalListener(currentModel?: t.ChatModel): void;
+    /**
+     * Perform structured output invocation: creates a fresh model without tools bound,
+     * removes thinking configuration, invokes with the schema, emits the event,
+     * and returns a clean AIMessageChunk without tool_calls.
+     *
+     * Used by both the immediate path (no tools) and the deferred path (after tool use).
+     */
+    private performStructuredOutput;
+    createCallModel(agentId?: string): (state: t.BaseGraphState, config?: RunnableConfig) => Promise<Partial<t.BaseGraphState>>;
+    createAgentNode(agentId: string): t.CompiledAgentWorfklow;
+    createWorkflow(): t.CompiledStateWorkflow;
+    /**
+     * Indicates if this is a multi-agent graph.
+     * Override in MultiAgentGraph to return true.
+     * Used to conditionally include agentId in RunStep for frontend rendering.
+     */
+    protected isMultiAgentGraph(): boolean;
+    /**
+     * Get the parallel group ID for an agent, if any.
+     * Override in MultiAgentGraph to provide actual group IDs.
+     * Group IDs are incrementing numbers (1, 2, 3...) reflecting execution order.
+     * @param _agentId - The agent ID to look up
+     * @returns undefined for StandardGraph (no parallel groups), or group number for MultiAgentGraph
+     */
+    protected getParallelGroupIdForAgent(_agentId: string): number | undefined;
+    /**
+     * Dispatches a run step to the client, returns the step ID
+     */
+    dispatchRunStep(stepKey: string, stepDetails: t.StepDetails, metadata?: Record<string, unknown>): Promise<string>;
+    handleToolCallCompleted(data: t.ToolEndData, metadata?: Record<string, unknown>, omitOutput?: boolean): Promise<void>;
+    /**
+     * Static version of handleToolCallError to avoid creating strong references
+     * that prevent garbage collection
+     */
+    static handleToolCallErrorStatic(graph: StandardGraph, data: t.ToolErrorData, metadata?: Record<string, unknown>): Promise<void>;
+    /**
+     * Instance method that delegates to the static method
+     * Kept for backward compatibility
+     */
+    handleToolCallError(data: t.ToolErrorData, metadata?: Record<string, unknown>): Promise<void>;
+    dispatchRunStepDelta(id: string, delta: t.ToolCallDelta): Promise<void>;
+    dispatchMessageDelta(id: string, delta: t.MessageDelta): Promise<void>;
+    dispatchReasoningDelta: (stepId: string, delta: t.ReasoningDelta) => Promise<void>;
+}

package/dist/types/graphs/MultiAgentGraph.d.ts

@@ -0,0 +1,104 @@
+import type * as t from '@/types';
+import { StandardGraph } from './Graph';
+/**
+ * MultiAgentGraph extends StandardGraph to support dynamic multi-agent workflows
+ * with handoffs, fan-in/fan-out, and other composable patterns.
+ *
+ * Key behavior:
+ * - Agents with ONLY handoff edges: Can dynamically route to any handoff destination
+ * - Agents with ONLY direct edges: Always follow their direct edges
+ * - Agents with BOTH: Use Command for exclusive routing (handoff OR direct, not both)
+ *   - If handoff occurs: Only the handoff destination executes
+ *   - If no handoff: Direct edges execute (potentially in parallel)
+ *
+ * This enables the common pattern where an agent either delegates (handoff)
+ * OR continues its workflow (direct edges), but not both simultaneously.
+ */
+export declare class MultiAgentGraph extends StandardGraph {
+    private edges;
+    private startingNodes;
+    private directEdges;
+    private handoffEdges;
+    /**
+     * Map of agentId to parallel group info.
+     * Contains groupId (incrementing number reflecting execution order) for agents in parallel groups.
+     * Sequential agents (not in any parallel group) have undefined entry.
+     *
+     * Example for: researcher -> [analyst1, analyst2, analyst3] -> summarizer
+     * - researcher: undefined (sequential, order 0)
+     * - analyst1, analyst2, analyst3: { groupId: 1 } (parallel group, order 1)
+     * - summarizer: undefined (sequential, order 2)
+     */
+    private agentParallelGroups;
+    constructor(input: t.MultiAgentGraphInput);
+    /**
+     * Categorize edges into handoff and direct types
+     */
+    private categorizeEdges;
+    /**
+     * Analyze graph structure to determine starting nodes and connections
+     */
+    private analyzeGraph;
+    /**
+     * Compute parallel groups by traversing the graph in execution order.
+     * Assigns incrementing group IDs that reflect the sequential order of execution.
+     *
+     * For: researcher -> [analyst1, analyst2, analyst3] -> summarizer
+     * - researcher: no group (first sequential node)
+     * - analyst1, analyst2, analyst3: groupId 1 (first parallel group)
+     * - summarizer: no group (next sequential node)
+     *
+     * This allows frontend to render in order:
+     * Row 0: researcher
+     * Row 1: [analyst1, analyst2, analyst3] (grouped)
+     * Row 2: summarizer
+     */
+    private computeParallelCapability;
+    /**
+     * Get the parallel group ID for an agent, if any.
+     * Returns undefined if the agent is not part of a parallel group.
+     * Group IDs are incrementing numbers reflecting execution order.
+     */
+    getParallelGroupId(agentId: string): number | undefined;
+    /**
+     * Override to indicate this is a multi-agent graph.
+     * Enables agentId to be included in RunStep for frontend agent labeling.
+     */
+    protected isMultiAgentGraph(): boolean;
+    /**
+     * Override base class method to provide parallel group IDs for run steps.
+     */
+    protected getParallelGroupIdForAgent(agentId: string): number | undefined;
+    /**
+     * Create handoff tools for agents based on handoff edges only
+     */
+    private createHandoffTools;
+    /**
+     * Create handoff tools for an edge (handles multiple destinations)
+     * @param edge - The graph edge defining the handoff
+     * @param sourceAgentId - The ID of the agent that will perform the handoff
+     * @param sourceAgentName - The human-readable name of the source agent
+     */
+    private createHandoffToolsForEdge;
+    /**
+     * Create a complete agent subgraph (similar to createReactAgent)
+     */
+    private createAgentSubgraph;
+    /**
+     * Detects if the current agent is receiving a handoff and processes the messages accordingly.
+     * Returns filtered messages with the transfer tool call/message removed, plus any instructions,
+     * source agent, and parallel sibling information extracted from the transfer.
+     *
+     * Supports both single handoffs (last message is the transfer) and parallel handoffs
+     * (multiple transfer ToolMessages, need to find the one targeting this agent).
+     *
+     * @param messages - Current state messages
+     * @param agentId - The agent ID to check for handoff reception
+     * @returns Object with filtered messages, extracted instructions, source agent, and parallel siblings
+     */
+    private processHandoffReception;
+    /**
+     * Create the multi-agent workflow with dynamic handoffs
+     */
+    createWorkflow(): t.CompiledMultiAgentWorkflow;
+}

package/dist/types/graphs/index.d.ts

@@ -0,0 +1,2 @@
+export * from './Graph';
+export * from './MultiAgentGraph';

package/dist/types/index.d.ts

@@ -0,0 +1,21 @@
+export * from './run';
+export * from './stream';
+export * from './splitStream';
+export * from './events';
+export * from './messages';
+export * from './graphs';
+export * from './tools/Calculator';
+export * from './tools/CodeExecutor';
+export * from './tools/BrowserTools';
+export * from './tools/ProgrammaticToolCalling';
+export * from './tools/ToolSearch';
+export * from './tools/ToolNode';
+export * from './tools/schema';
+export * from './tools/handlers';
+export * from './tools/search';
+export * from './schemas';
+export * from './common';
+export * from './utils';
+export type * from './types';
+export { CustomOpenAIClient } from './llm/openai';
+export { getChatModelClass, llmProviders } from './llm/providers';

package/dist/types/instrumentation.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/llm/anthropic/index.d.ts

@@ -0,0 +1,39 @@
+import { ChatAnthropicMessages } from '@langchain/anthropic';
+import { ChatGenerationChunk } from '@langchain/core/outputs';
+import type { BaseChatModelParams } from '@langchain/core/language_models/chat_models';
+import type { BaseMessage, UsageMetadata } from '@langchain/core/messages';
+import type { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager';
+import type { AnthropicInput } from '@langchain/anthropic';
+import type { AnthropicMessageCreateParams, AnthropicStreamingMessageCreateParams } from '@/llm/anthropic/types';
+export type CustomAnthropicInput = AnthropicInput & {
+    _lc_stream_delay?: number;
+} & BaseChatModelParams;
+/**
+ * A type representing additional parameters that can be passed to the
+ * Anthropic API.
+ */
+type Kwargs = Record<string, any>;
+export declare class CustomAnthropic extends ChatAnthropicMessages {
+    _lc_stream_delay: number;
+    private message_start;
+    private message_delta;
+    private tools_in_params?;
+    private emitted_usage?;
+    top_k: number | undefined;
+    constructor(fields?: CustomAnthropicInput);
+    static lc_name(): 'IllumaAnthropic';
+    /**
+     * Get the parameters used to invoke the model
+     */
+    invocationParams(options?: this['ParsedCallOptions']): Omit<AnthropicMessageCreateParams | AnthropicStreamingMessageCreateParams, 'messages'> & Kwargs;
+    /**
+     * Get stream usage as returned by this client's API response.
+     * @returns The stream usage object.
+     */
+    getStreamUsage(): UsageMetadata | undefined;
+    resetTokenEvents(): void;
+    setDirectFields(fields?: CustomAnthropicInput): void;
+    private createGenerationChunk;
+    _streamResponseChunks(messages: BaseMessage[], options: this['ParsedCallOptions'], runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
+}
+export {};

package/dist/types/llm/anthropic/types.d.ts

@@ -0,0 +1,37 @@
+import Anthropic from '@anthropic-ai/sdk';
+import { BindToolsInput } from '@langchain/core/language_models/chat_models';
+export type AnthropicStreamUsage = Anthropic.Usage;
+export type AnthropicMessageDeltaEvent = Anthropic.MessageDeltaEvent;
+export type AnthropicMessageStartEvent = Anthropic.MessageStartEvent;
+export type AnthropicToolResponse = {
+    type: 'tool_use';
+    id: string;
+    name: string;
+    input: Record<string, any>;
+};
+export type AnthropicMessageParam = Anthropic.MessageParam;
+export type AnthropicMessageResponse = Anthropic.ContentBlock | AnthropicToolResponse;
+export type AnthropicMessageCreateParams = Anthropic.MessageCreateParamsNonStreaming;
+export type AnthropicStreamingMessageCreateParams = Anthropic.MessageCreateParamsStreaming;
+export type AnthropicThinkingConfigParam = Anthropic.ThinkingConfigParam;
+export type AnthropicMessageStreamEvent = Anthropic.MessageStreamEvent;
+export type AnthropicRequestOptions = Anthropic.RequestOptions;
+export type AnthropicToolChoice = {
+    type: 'tool';
+    name: string;
+} | 'any' | 'auto' | 'none' | string;
+export type ChatAnthropicToolType = Anthropic.Messages.Tool | BindToolsInput;
+export type AnthropicTextBlockParam = Anthropic.Messages.TextBlockParam;
+export type AnthropicImageBlockParam = Anthropic.Messages.ImageBlockParam;
+export type AnthropicToolUseBlockParam = Anthropic.Messages.ToolUseBlockParam;
+export type AnthropicToolResultBlockParam = Anthropic.Messages.ToolResultBlockParam;
+export type AnthropicDocumentBlockParam = Anthropic.Messages.DocumentBlockParam;
+export type AnthropicThinkingBlockParam = Anthropic.Messages.ThinkingBlockParam;
+export type AnthropicRedactedThinkingBlockParam = Anthropic.Messages.RedactedThinkingBlockParam;
+export type AnthropicServerToolUseBlockParam = Anthropic.Messages.ServerToolUseBlockParam;
+export type AnthropicWebSearchToolResultBlockParam = Anthropic.Messages.WebSearchToolResultBlockParam;
+export type AnthropicWebSearchResultBlockParam = Anthropic.Messages.WebSearchResultBlockParam;
+export type AnthropicSearchResultBlockParam = Anthropic.Beta.BetaSearchResultBlockParam;
+export type AnthropicContentBlock = AnthropicTextBlockParam | AnthropicImageBlockParam | AnthropicToolUseBlockParam | AnthropicToolResultBlockParam | AnthropicDocumentBlockParam | AnthropicThinkingBlockParam | AnthropicRedactedThinkingBlockParam | AnthropicServerToolUseBlockParam | AnthropicWebSearchToolResultBlockParam | AnthropicWebSearchResultBlockParam;
+export type ChatAnthropicContentBlock = AnthropicTextBlockParam | AnthropicImageBlockParam | AnthropicToolUseBlockParam | AnthropicToolResultBlockParam | AnthropicDocumentBlockParam | AnthropicThinkingBlockParam | AnthropicRedactedThinkingBlockParam | AnthropicServerToolUseBlockParam | AnthropicWebSearchToolResultBlockParam | AnthropicWebSearchResultBlockParam | AnthropicSearchResultBlockParam;
+export declare function isAnthropicImageBlockParam(block: unknown): block is AnthropicImageBlockParam;

package/dist/types/llm/anthropic/utils/message_inputs.d.ts

@@ -0,0 +1,14 @@
+/**
+ * This util file contains functions for converting LangChain messages to Anthropic messages.
+ */
+import { type BaseMessage } from '@langchain/core/messages';
+import { ToolCall } from '@langchain/core/messages/tool';
+import { AnthropicMessageCreateParams, AnthropicToolResponse } from '../types';
+export declare function _convertLangChainToolCallToAnthropic(toolCall: ToolCall): AnthropicToolResponse;
+/**
+ * Formats messages as a prompt for the model.
+ * Used in LangSmith, export is important here.
+ * @param messages The base messages to format as a prompt.
+ * @returns The formatted prompt.
+ */
+export declare function _convertMessagesToAnthropicPayload(messages: BaseMessage[]): AnthropicMessageCreateParams;

package/dist/types/llm/anthropic/utils/message_outputs.d.ts

@@ -0,0 +1,14 @@
+/**
+ * This util file contains functions for converting Anthropic messages to LangChain messages.
+ */
+import Anthropic from '@anthropic-ai/sdk';
+import { AIMessageChunk } from '@langchain/core/messages';
+import { ChatGeneration } from '@langchain/core/outputs';
+import { AnthropicMessageResponse } from '../types';
+export declare function _makeMessageChunkFromAnthropicEvent(data: Anthropic.Messages.RawMessageStreamEvent, fields: {
+    streamUsage: boolean;
+    coerceContentToString: boolean;
+}): {
+    chunk: AIMessageChunk;
+} | null;
+export declare function anthropicResponseToChatMessages(messages: AnthropicMessageResponse[], additionalKwargs: Record<string, unknown>): ChatGeneration[];

package/dist/types/llm/anthropic/utils/output_parsers.d.ts

@@ -0,0 +1,22 @@
+import { BaseLLMOutputParser } 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 { InteropZodType } from '@langchain/core/utils/types';
+interface AnthropicToolsOutputParserParams<T extends Record<string, any>> extends JsonOutputKeyToolsParserParamsInterop<T> {
+}
+export declare class AnthropicToolsOutputParser<T extends Record<string, any> = Record<string, any>> extends BaseLLMOutputParser<T> {
+    static lc_name(): string;
+    lc_namespace: string[];
+    returnId: boolean;
+    /** The type of tool calls to return. */
+    keyName: string;
+    /** Whether to return only the first tool call. */
+    returnSingle: boolean;
+    zodSchema?: InteropZodType<T>;
+    constructor(params: AnthropicToolsOutputParserParams<T>);
+    protected _validateResult(result: unknown): Promise<T>;
+    parseResult(generations: ChatGeneration[]): Promise<T>;
+}
+export declare function extractToolCalls(content: Record<string, any>[]): ToolCall[];
+export {};

package/dist/types/llm/anthropic/utils/tools.d.ts

@@ -0,0 +1,3 @@
+import type { Anthropic } from '@anthropic-ai/sdk';
+import { AnthropicToolChoice } from '../types.js';
+export declare function handleToolChoice(toolChoice?: AnthropicToolChoice): Anthropic.Messages.ToolChoiceAuto | Anthropic.Messages.ToolChoiceAny | Anthropic.Messages.ToolChoiceTool | undefined;

package/dist/types/llm/bedrock/index.d.ts

@@ -0,0 +1,141 @@
+/**
+ * Optimized ChatBedrockConverse wrapper that fixes contentBlockIndex conflicts
+ * and adds support for:
+ *
+ * - Prompt caching support for Bedrock Converse API (Illuma feature)
+ * - Application Inference Profiles (PR #9129)
+ * - Service Tiers (Priority/Standard/Flex) (PR #9785) - requires AWS SDK 3.966.0+
+ *
+ * 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.
+ *
+ * PROMPT CACHING:
+ * When promptCache: true is set, this wrapper adds cachePoint markers to the tools array
+ * to enable Bedrock prompt caching for tool definitions. This allows tool schemas to be
+ * cached and reused across requests, reducing latency and costs.
+ *
+ * CACHE TOKEN EXTRACTION:
+ * LangChain AWS doesn't extract cacheReadInputTokens/cacheWriteInputTokens from Bedrock's
+ * response. This wrapper adds input_token_details to usage_metadata with cache information.
+ */
+import { ChatBedrockConverse } from '@langchain/aws';
+import type { BaseMessage } from '@langchain/core/messages';
+import { ChatGenerationChunk, ChatResult } from '@langchain/core/outputs';
+import type { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager';
+import type { ChatBedrockConverseInput } from '@langchain/aws';
+/**
+ * Service tier type for Bedrock invocations.
+ * Requires AWS SDK >= 3.966.0 to actually work.
+ * @see https://docs.aws.amazon.com/bedrock/latest/userguide/service-tiers-inference.html
+ */
+export type ServiceTierType = 'priority' | 'default' | 'flex' | 'reserved';
+/**
+ * Extended input interface with additional features:
+ * - promptCache: Enable Bedrock prompt caching for tool definitions
+ * - applicationInferenceProfile: Use an inference profile ARN instead of model ID
+ * - serviceTier: Specify service tier (Priority, Standard, Flex, Reserved)
+ */
+export interface CustomChatBedrockConverseInput extends ChatBedrockConverseInput {
+    /**
+     * Enable Bedrock prompt caching for tool definitions.
+     * When true, adds cachePoint markers to tools array.
+     */
+    promptCache?: boolean;
+    /**
+     * Application Inference Profile ARN to use for the model.
+     * For example, "arn:aws:bedrock:eu-west-1:123456789102:application-inference-profile/fm16bt65tzgx"
+     * When provided, this ARN will be used for the actual inference calls instead of the model ID.
+     * Must still provide `model` as normal modelId to benefit from all the metadata.
+     * @see https://docs.aws.amazon.com/bedrock/latest/userguide/inference-profiles-create.html
+     */
+    applicationInferenceProfile?: string;
+    /**
+     * Service tier for model invocation.
+     * Specifies the processing tier type used for serving the request.
+     * Supported values are 'priority', 'default', 'flex', and 'reserved'.
+     *
+     * - 'priority': Prioritized processing for lower latency
+     * - 'default': Standard processing tier
+     * - 'flex': Flexible processing tier with lower cost
+     * - 'reserved': Reserved capacity for consistent performance
+     *
+     * If not provided, AWS uses the default tier.
+     * Note: Requires AWS SDK >= 3.966.0 to work.
+     * @see https://docs.aws.amazon.com/bedrock/latest/userguide/service-tiers-inference.html
+     */
+    serviceTier?: ServiceTierType;
+}
+/**
+ * Extended call options with serviceTier override support.
+ */
+export interface CustomChatBedrockConverseCallOptions {
+    serviceTier?: ServiceTierType;
+}
+export declare class CustomChatBedrockConverse extends ChatBedrockConverse {
+    /** Enable Bedrock prompt caching for tool definitions */
+    promptCache: boolean;
+    /** Application Inference Profile ARN to use instead of model ID */
+    applicationInferenceProfile?: string;
+    /** Service tier for model invocation */
+    serviceTier?: ServiceTierType;
+    constructor(fields?: CustomChatBedrockConverseInput);
+    static lc_name(): string;
+    /**
+     * Get the model ID to use for API calls.
+     * Returns applicationInferenceProfile if set, otherwise returns this.model.
+     */
+    protected getModelId(): string;
+    /**
+     * Override invocationParams to:
+     * 1. Add cachePoint to tools when promptCache is enabled
+     * 2. Add serviceTier support
+     *
+     * CACHING STRATEGY: Separate cachePoints for core tools and MCP tools
+     * - Core tools (web_search, execute_code, etc.) are stable → cache first
+     * - MCP tools (have '_mcp_' in name) are dynamic → cache separately after
+     * - This allows core tools to stay cached when MCP selection changes
+     *
+     * NOTE: Only Claude models support cachePoint - Nova and other models will reject it.
+     */
+    invocationParams(options?: this['ParsedCallOptions'] & CustomChatBedrockConverseCallOptions): ReturnType<ChatBedrockConverse['invocationParams']> & {
+        serviceTier?: {
+            type: ServiceTierType;
+        };
+    };
+    /**
+     * Override _generateNonStreaming to use applicationInferenceProfile as modelId.
+     * Uses the same model-swapping pattern as streaming for consistency.
+     */
+    _generateNonStreaming(messages: BaseMessage[], options: this['ParsedCallOptions'] & CustomChatBedrockConverseCallOptions, runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;
+    /**
+     * Override _streamResponseChunks to:
+     * 1. Use applicationInferenceProfile as modelId (by temporarily swapping this.model)
+     * 2. Strip contentBlockIndex from response_metadata to prevent merge conflicts
+     * 3. Extract cacheReadInputTokens/cacheWriteInputTokens and add to usage_metadata
+     *
+     * Note: We delegate to super._streamResponseChunks() to preserve @langchain/aws's
+     * internal chunk handling which correctly preserves array content for reasoning blocks.
+     */
+    _streamResponseChunks(messages: BaseMessage[], options: this['ParsedCallOptions'] & CustomChatBedrockConverseCallOptions, runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
+    /**
+     * Process a chunk by:
+     * 1. Removing contentBlockIndex from response_metadata
+     * 2. Extracting cache token information from Bedrock's usage data
+     */
+    private processChunk;
+    /**
+     * Check if contentBlockIndex exists at any level in the object
+     */
+    private hasContentBlockIndex;
+    /**
+     * Recursively remove contentBlockIndex from all levels of an object
+     */
+    private removeContentBlockIndex;
+}
+export type { ChatBedrockConverseInput };

package/dist/types/llm/bedrock/types.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Type definitions for Bedrock Converse utilities.
+ */
+import type { Message as BedrockMessage, SystemContentBlock as BedrockSystemContentBlock, ContentBlock as BedrockContentBlock, ConverseResponse, ContentBlockDeltaEvent, ConverseStreamMetadataEvent, ContentBlockStartEvent, ReasoningContentBlock, ReasoningContentBlockDelta } from '@aws-sdk/client-bedrock-runtime';
+/**
+ * Reasoning content block type for LangChain messages.
+ */
+export interface MessageContentReasoningBlock {
+    type: 'reasoning_content';
+    reasoningText?: {
+        text?: string;
+        signature?: string;
+    };
+    redactedContent?: string;
+}
+export interface MessageContentReasoningBlockReasoningTextPartial {
+    type: 'reasoning_content';
+    reasoningText: {
+        text?: string;
+        signature?: string;
+    };
+}
+export interface MessageContentReasoningBlockRedacted {
+    type: 'reasoning_content';
+    redactedContent: string;
+}
+export type { BedrockMessage, BedrockSystemContentBlock, BedrockContentBlock, ConverseResponse, ContentBlockDeltaEvent, ConverseStreamMetadataEvent, ContentBlockStartEvent, ReasoningContentBlock, ReasoningContentBlockDelta, };

package/dist/types/llm/bedrock/utils/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Bedrock Converse utility exports.
+ */
+export { convertToConverseMessages, extractImageInfo, langchainReasoningBlockToBedrockReasoningBlock, concatenateLangchainReasoningBlocks, } from './message_inputs';
+export { convertConverseMessageToLangChainMessage, handleConverseStreamContentBlockStart, handleConverseStreamContentBlockDelta, handleConverseStreamMetadata, bedrockReasoningBlockToLangchainReasoningBlock, bedrockReasoningDeltaToLangchainPartialReasoningBlock, } from './message_outputs';