@illuma-ai/agents 1.0.89 → 1.0.93

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

@@ -5,7 +5,7 @@ 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: {
+export declare function _makeMessageChunkFromAnthropicEvent(data: Anthropic.Beta.Messages.BetaRawMessageStreamEvent, fields: {
     streamUsage: boolean;
     coerceContentToString: boolean;
 }): {

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

@@ -1,19 +1,25 @@
 /**
- * Optimized ChatBedrockConverse wrapper that fixes contentBlockIndex conflicts
- * and adds support for:
+ * Optimized ChatBedrockConverse wrapper that fixes content block merging for
+ * streaming responses and adds support for latest @langchain/aws features:
  *
  * - 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.
+ * Bedrock's `@langchain/aws` library does not include an `index` property on content
+ * blocks (unlike Anthropic/OpenAI), which causes LangChain's `_mergeLists` to append
+ * each streaming chunk as a separate array entry instead of merging by index.
  *
- * 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.
+ * This wrapper takes full ownership of the stream by directly interfacing with the
+ * AWS SDK client (`this.client`) and using custom handlers from `./utils/` that
+ * include `contentBlockIndex` in response_metadata for every delta type. It then
+ * promotes `contentBlockIndex` to an `index` property on each content block
+ * (mirroring Anthropic's pattern) and strips it from metadata to avoid
+ * `_mergeDicts` conflicts.
+ *
+ * When multiple content block types are present (e.g. reasoning + text), text deltas
+ * are promoted from strings to array form with `index` so they merge correctly once
+ * the accumulated content is already an array.
  *
  * PROMPT CACHING:
  * When promptCache: true is set, this wrapper adds cachePoint markers to the tools array
@@ -21,8 +27,8 @@
  * 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.
+ * Cache token extraction is handled in `./utils/message_outputs.ts` and added
+ * to usage_metadata with input_token_details (cacheReadInputTokens/cacheWriteInputTokens).
  */
 import { ChatBedrockConverse } from '@langchain/aws';
 import type { BaseMessage } from '@langchain/core/messages';
@@ -41,7 +47,7 @@ export type ServiceTierType = 'priority' | 'default' | 'flex' | 'reserved';
  * - applicationInferenceProfile: Use an inference profile ARN instead of model ID
  * - serviceTier: Specify service tier (Priority, Standard, Flex, Reserved)
  */
-export interface CustomChatBedrockConverseInput extends ChatBedrockConverseInput {
+export interface IllumaBedrockConverseInput extends ChatBedrockConverseInput {
     /**
      * Enable Bedrock prompt caching for tool definitions.
      * When true, adds cachePoint markers to tools array.
@@ -74,17 +80,17 @@ export interface CustomChatBedrockConverseInput extends ChatBedrockConverseInput
 /**
  * Extended call options with serviceTier override support.
  */
-export interface CustomChatBedrockConverseCallOptions {
+export interface IllumaBedrockConverseCallOptions {
     serviceTier?: ServiceTierType;
 }
-export declare class CustomChatBedrockConverse extends ChatBedrockConverse {
+export declare class IllumaBedrockConverse 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);
+    constructor(fields?: IllumaBedrockConverseInput);
     static lc_name(): string;
     /**
      * Get the model ID to use for API calls.
@@ -103,7 +109,7 @@ export declare class CustomChatBedrockConverse extends ChatBedrockConverse {
      *
      * NOTE: Only Claude models support cachePoint - Nova and other models will reject it.
      */
-    invocationParams(options?: this['ParsedCallOptions'] & CustomChatBedrockConverseCallOptions): ReturnType<ChatBedrockConverse['invocationParams']> & {
+    invocationParams(options?: this['ParsedCallOptions'] & IllumaBedrockConverseCallOptions): ReturnType<ChatBedrockConverse['invocationParams']> & {
         serviceTier?: {
             type: ServiceTierType;
         };
@@ -112,30 +118,31 @@ export declare class CustomChatBedrockConverse extends ChatBedrockConverse {
      * 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>;
+    _generateNonStreaming(messages: BaseMessage[], options: this['ParsedCallOptions'] & IllumaBedrockConverseCallOptions, 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
+     * Own the stream end-to-end so we have direct access to every
+     * `contentBlockDelta.contentBlockIndex` from the AWS SDK.
      *
-     * 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
+     * This replaces the parent's implementation which strips contentBlockIndex
+     * from text and reasoning deltas, making it impossible to merge correctly.
      */
-    private processChunk;
+    _streamResponseChunks(messages: BaseMessage[], options: this['ParsedCallOptions'] & IllumaBedrockConverseCallOptions, runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
     /**
-     * Check if contentBlockIndex exists at any level in the object
+     * Inject `index` on content blocks for proper merge behaviour, then strip
+     * `contentBlockIndex` from response_metadata to prevent `_mergeDicts` conflicts.
+     *
+     * Text string content is promoted to array form only when the stream contains
+     * multiple content block indices (e.g. reasoning at index 0, text at index 1),
+     * ensuring text merges correctly with the already-array accumulated content.
      */
-    private hasContentBlockIndex;
+    enrichChunk(chunk: ChatGenerationChunk, seenBlockIndices: Set<number>): ChatGenerationChunk;
     /**
-     * Recursively remove contentBlockIndex from all levels of an object
+     * Extract `contentBlockIndex` from the top level of response_metadata.
+     * Our custom handlers always place it at the top level.
      */
+    private extractContentBlockIndex;
     private removeContentBlockIndex;
 }
+/** @deprecated Use IllumaBedrockConverse. Alias kept for backward compatibility with existing imports. */
+export declare const CustomChatBedrockConverse: typeof IllumaBedrockConverse;
 export type { ChatBedrockConverseInput };

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

@@ -2,8 +2,8 @@
  * Utility functions for converting Bedrock Converse responses to LangChain messages.
  * Ported from @langchain/aws common.js
  */
-import { AIMessage } from '@langchain/core/messages';
 import { ChatGenerationChunk } from '@langchain/core/outputs';
+import { AIMessage } from '@langchain/core/messages';
 import type { BedrockMessage, ConverseResponse, ContentBlockDeltaEvent, ConverseStreamMetadataEvent, ContentBlockStartEvent, ReasoningContentBlock, ReasoningContentBlockDelta, MessageContentReasoningBlock, MessageContentReasoningBlockReasoningTextPartial, MessageContentReasoningBlockRedacted } from '../types';
 /**
  * Convert a Bedrock reasoning block delta to a LangChain partial reasoning block.

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

@@ -3,10 +3,9 @@ import { ChatGoogleGenerativeAI } from '@langchain/google-genai';
 import type { GenerateContentRequest } from '@google/generative-ai';
 import type { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager';
 import type { BaseMessage } from '@langchain/core/messages';
-import type { GeminiGenerationConfig } from '@langchain/google-common';
-import type { GoogleClientOptions } from '@/types';
+import type { GoogleClientOptions, GoogleThinkingConfig } from '@/types';
 export declare class CustomChatGoogleGenerativeAI extends ChatGoogleGenerativeAI {
-    thinkingConfig?: GeminiGenerationConfig['thinkingConfig'];
+    thinkingConfig?: GoogleThinkingConfig;
     /**
      * Override to add gemini-3 model support for multimodal and function calling thought signatures
      */

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

@@ -3,13 +3,33 @@ import { ChatGenerationChunk } from '@langchain/core/outputs';
 import { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager';
 import type { FunctionMessageChunk, SystemMessageChunk, HumanMessageChunk, ToolMessageChunk, ChatMessageChunk, AIMessageChunk, BaseMessage } from '@langchain/core/messages';
 import type { ChatOpenAICallOptions, OpenAIChatInput, OpenAIClient } from '@langchain/openai';
-export interface ChatOpenRouterCallOptions extends ChatOpenAICallOptions {
+export type OpenRouterReasoningEffort = 'xhigh' | 'high' | 'medium' | 'low' | 'minimal' | 'none';
+export interface OpenRouterReasoning {
+    effort?: OpenRouterReasoningEffort;
+    max_tokens?: number;
+    exclude?: boolean;
+    enabled?: boolean;
+}
+export interface ChatOpenRouterCallOptions extends Omit<ChatOpenAICallOptions, 'reasoning'> {
+    /** @deprecated Use `reasoning` object instead */
     include_reasoning?: boolean;
+    reasoning?: OpenRouterReasoning;
     modelKwargs?: OpenAIChatInput['modelKwargs'];
 }
+/** invocationParams return type extended with OpenRouter reasoning */
+export type OpenRouterInvocationParams = Omit<OpenAIClient.Chat.ChatCompletionCreateParams, 'messages'> & {
+    reasoning?: OpenRouterReasoning;
+};
 export declare class ChatOpenRouter extends ChatOpenAI {
+    private openRouterReasoning?;
+    /** @deprecated Use `reasoning` object instead */
+    private includeReasoning?;
     constructor(_fields: Partial<ChatOpenRouterCallOptions>);
     static lc_name(): 'IllumaOpenRouter';
+    invocationParams(options?: this['ParsedCallOptions'], extra?: {
+        streaming?: boolean;
+    }): OpenRouterInvocationParams;
+    private buildOpenRouterReasoning;
     protected _convertOpenAIDeltaToBaseMessageChunk(delta: Record<string, any>, rawResponse: OpenAIClient.ChatCompletionChunk, defaultRole?: 'function' | 'user' | 'system' | 'developer' | 'assistant' | 'tool'): AIMessageChunk | HumanMessageChunk | SystemMessageChunk | FunctionMessageChunk | ToolMessageChunk | ChatMessageChunk;
     _streamResponseChunks2(messages: BaseMessage[], options: this['ParsedCallOptions'], runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
 }

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

@@ -1,6 +1,6 @@
 import { ChatGoogle } from '@langchain/google-gauth';
 import type { GoogleAIModelRequestParams, GoogleAbstractedClient } from '@langchain/google-common';
-import type { VertexAIClientOptions } from '@/types';
+import type { GoogleThinkingConfig, VertexAIClientOptions } from '@/types';
 /**
  * Integration with Google Vertex AI chat models.
  *
@@ -286,8 +286,9 @@ import type { VertexAIClientOptions } from '@/types';
 export declare class ChatVertexAI extends ChatGoogle {
     lc_namespace: string[];
     dynamicThinkingBudget: boolean;
+    thinkingConfig?: GoogleThinkingConfig;
     static lc_name(): 'IllumaVertexAI';
     constructor(fields?: VertexAIClientOptions);
     invocationParams(options?: this['ParsedCallOptions'] | undefined): GoogleAIModelRequestParams;
-    buildConnection(fields: VertexAIClientOptions, client: GoogleAbstractedClient): void;
+    buildConnection(fields: VertexAIClientOptions | undefined, client: GoogleAbstractedClient): void;
 }

package/dist/types/messages/cache.d.ts

@@ -34,7 +34,7 @@ export declare function stripBedrockCacheControl<T extends MessageWithContent>(m
  *
  * Why this works:
  * - System message has its own cachePoint (added in AgentContext)
- * - Tools have their own cachePoint (added in CustomChatBedrockConverse)
+ * - Tools have their own cachePoint (added in IllumaBedrockConverse)
  * - Conversation history grows, but the PREFIX stays the same
  * - Only the NEW user message is uncached (it's always different)
  *

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

@@ -5,3 +5,4 @@ export * from './format';
 export * from './cache';
 export * from './content';
 export * from './tools';
+export * from './summarize';

package/dist/types/messages/prune.d.ts

@@ -27,13 +27,6 @@ export type PruningResult = {
     messagesToRefine: BaseMessage[];
     thinkingStartIndex?: number;
 };
-/**
- * Processes an array of messages and returns a context of messages that fit within a specified token limit.
- * It iterates over the messages from newest to oldest, adding them to the context until the token limit is reached.
- *
- * @param options Configuration options for processing messages
- * @returns Object containing the message context, remaining tokens, messages not included, and summary index
- */
 export declare function getMessagesWithinTokenLimit({ messages: _messages, maxContextTokens, indexTokenCountMap, startType: _startType, thinkingEnabled, tokenCounter, thinkingStartIndex: _thinkingStartIndex, reasoningType, }: {
     messages: BaseMessage[];
     maxContextTokens: number;
@@ -50,3 +43,5 @@ export declare function createPruneMessages(factoryParams: PruneMessagesFactoryP
     indexTokenCountMap: Record<string, number | undefined>;
     messagesToRefine: BaseMessage[];
 };
+/** Calculates context utilization as a percentage (0-100) */
+export declare function getContextUtilization(indexTokenCountMap: Record<string, number | undefined>, instructionTokens: number, maxContextTokens: number): number;

package/dist/types/messages/summarize.d.ts

@@ -0,0 +1,33 @@
+import { BaseMessage } from '@langchain/core/messages';
+import type { TokenCounter } from '@/types/run';
+export type SummarizeTier = 'full' | 'simple' | 'emergency';
+export type SummarizeConfig = {
+    /** Max tokens for the summary output */
+    maxOutputTokens?: number;
+    /** Token counter for validation */
+    tokenCounter?: TokenCounter;
+    /** Max tokens the summary should fit within */
+    summaryBudget?: number;
+    /** Whether this is a multi-agent conversation */
+    isMultiAgent?: boolean;
+    /** Current agent workflow state for multi-agent context */
+    agentWorkflowState?: {
+        currentAgentId: string;
+        agentChain: string[];
+        pendingAgents: string[];
+    };
+};
+export type SummarizeResult = {
+    summary: string;
+    tier: SummarizeTier;
+    tokenCount?: number;
+    messagesCompacted: number;
+};
+export declare const FULL_SUMMARY_TEMPLATE = "Analyze this conversation and produce a structured summary covering each section below. Be precise and preserve actionable details.\n\n## 1. Task Overview & User Intent\nWhat the user originally asked for and their high-level goal.\n\n## 2. Technical Context\nLanguages, frameworks, libraries, APIs, and architectural patterns involved.\n\n## 3. Files & Code State\nAll file paths mentioned, their current state, and any pending modifications.\n\n## 4. Problem Resolution History\nProblems encountered, debugging steps taken, and their outcomes.\n\n## 5. Agent Workflow State\n{agent_workflow}\n\n## 6. Tool Results Summary\nTools called, their inputs, and key outputs (omit verbose raw data).\n\n## 7. Progress Tracking\nWhat has been completed, what remains, and any blockers.\n\n## 8. Active Working State\nVariables, configurations, and runtime state that must be preserved.\n\n## 9. Continuation Plan\nImmediate next steps and the order in which they should be executed.\n\n## 10. Critical Context\nAny constraints, warnings, edge cases, or decisions that must not be lost.\n\nConversation:\n{conversation}\n\nStructured Summary:";
+export declare const SIMPLE_SUMMARY_TEMPLATE = "Summarize this conversation preserving: user's original request, key decisions, current task state, and any file paths mentioned.\n\nConversation:\n{conversation}\n\nSummary:";
+export declare function formatMessagesForSummary(messages: BaseMessage[]): string;
+export declare function buildFullSummaryPrompt(conversation: string, config?: SummarizeConfig): string;
+export declare function buildSimpleSummaryPrompt(conversation: string): string;
+export declare function createEmergencySummary(messages: BaseMessage[]): string;
+export declare function validateSummarySize(summary: string, budget: number, tokenCounter: TokenCounter): boolean;
+export declare function summarize(messages: BaseMessage[], callback: (prompt: string, maxTokens: number) => Promise<string | undefined>, config?: SummarizeConfig): Promise<SummarizeResult>;

package/dist/types/run.d.ts

@@ -13,11 +13,17 @@ export declare class Run<_T extends t.BaseGraphState> {
     graphRunnable?: t.CompiledStateWorkflow;
     Graph: StandardGraph | MultiAgentGraph | undefined;
     returnContent: boolean;
+    private skipCleanup;
     private constructor();
     private createLegacyGraph;
     private createMultiAgentGraph;
     static create<T extends t.BaseGraphState>(config: t.RunConfig): Promise<Run<T>>;
     getRunMessages(): BaseMessage[] | undefined;
+    /**
+     * Manually trigger cleanup of heavy state (messages, config, etc.).
+     * Call this after all continuations are complete when using skipCleanup=true.
+     */
+    clearState(): void;
     /**
      * Returns the normalized finish/stop reason from the last LLM invocation.
      * Delegates to the underlying Graph instance.