@illuma-ai/agents 1.4.0-alpha.6 → 1.5.0

package/dist/cjs/main.cjs

@@ -10,43 +10,36 @@ var prune = require('./messages/prune.cjs');
 var format = require('./messages/format.cjs');
 var cache = require('./messages/cache.cjs');
 var content = require('./messages/content.cjs');
-var tools = require('./messages/tools.cjs');
+var tools$1 = require('./messages/tools.cjs');
 var summarize = require('./messages/summarize.cjs');
 var dedup = require('./messages/dedup.cjs');
+var contextPruning = require('./messages/contextPruning.cjs');
+var contextPruningSettings = require('./messages/contextPruningSettings.cjs');
 var Graph = require('./graphs/Graph.cjs');
 var MultiAgentGraph = require('./graphs/MultiAgentGraph.cjs');
-var HandoffRegistry = require('./graphs/HandoffRegistry.cjs');
 var Calculator = require('./tools/Calculator.cjs');
 var CodeExecutor = require('./tools/CodeExecutor.cjs');
+var BashExecutor = require('./tools/BashExecutor.cjs');
+var BashProgrammaticToolCalling = require('./tools/BashProgrammaticToolCalling.cjs');
+var ReadFile = require('./tools/ReadFile.cjs');
+var SkillTool = require('./tools/SkillTool.cjs');
+var skillCatalog = require('./tools/skillCatalog.cjs');
+var SubagentTool = require('./tools/SubagentTool.cjs');
+var SubagentExecutor = require('./tools/subagent/SubagentExecutor.cjs');
 var BrowserTools = require('./tools/BrowserTools.cjs');
 var ProgrammaticToolCalling = require('./tools/ProgrammaticToolCalling.cjs');
 var ToolSearch = require('./tools/ToolSearch.cjs');
 var ToolNode = require('./tools/ToolNode.cjs');
 var AskUser = require('./tools/AskUser.cjs');
-var schema$3 = require('./tools/schema.cjs');
+var schema$1 = require('./tools/schema.cjs');
 var handlers$1 = require('./tools/handlers.cjs');
-var tool$2 = require('./tools/search/tool.cjs');
-var schema$1 = require('./tools/search/schema.cjs');
+var tool = require('./tools/search/tool.cjs');
+var schema = require('./tools/search/schema.cjs');
 var index$2 = require('./tools/memory/index.cjs');
-var tool$1 = require('./tools/fileSearch/tool.cjs');
-var ragClient = require('./tools/fileSearch/ragClient.cjs');
-var formatter = require('./tools/fileSearch/formatter.cjs');
-var schema$2 = require('./tools/fileSearch/schema.cjs');
-var tool = require('./tools/artifacts/tool.cjs');
-var schema = require('./tools/artifacts/schema.cjs');
-var proxyTool = require('./tools/proxyTool.cjs');
-var types = require('./providers/types.cjs');
-var capabilityNaming = require('./providers/capabilityNaming.cjs');
-var ToolsServerCapabilityProvider = require('./providers/tools-server/ToolsServerCapabilityProvider.cjs');
-var MCPCapabilityProvider = require('./providers/mcp/MCPCapabilityProvider.cjs');
-var transport = require('./providers/mcp/transport.cjs');
-var config$1 = require('./providers/mcp/config.cjs');
-var A2ACapabilityProvider = require('./providers/a2a/A2ACapabilityProvider.cjs');
-var client = require('./providers/a2a/client.cjs');
-var config = require('./providers/a2a/config.cjs');
-var ContentStore = require('./content/ContentStore.cjs');
-var ArtifactStore = require('./content/ArtifactStore.cjs');
-var mcpAutoCache = require('./content/mcpAutoCache.cjs');
+var HookRegistry = require('./hooks/HookRegistry.cjs');
+var executeHooks = require('./hooks/executeHooks.cjs');
+var matchers = require('./hooks/matchers.cjs');
+var types = require('./hooks/types.cjs');
 var constants$2 = require('./memory/constants.cjs');
 var paths = require('./memory/paths.cjs');
 var pgvectorStore = require('./memory/pgvectorStore.cjs');
@@ -65,7 +58,6 @@ var validate = require('./schemas/validate.cjs');
 var ApprovalGateNode = require('./nodes/ApprovalGateNode.cjs');
 var _enum = require('./common/enum.cjs');
 var constants$1 = require('./common/constants.cjs');
-var spawnPath = require('./common/spawnPath.cjs');
 var constants = require('./tools/approval/constants.cjs');
 var graph = require('./utils/graph.cjs');
 var llm = require('./utils/llm.cjs');
@@ -75,16 +67,18 @@ var run$1 = require('./utils/run.cjs');
 var tokens = require('./utils/tokens.cjs');
 var toonFormat = require('./utils/toonFormat.cjs');
 var contextAnalytics = require('./utils/contextAnalytics.cjs');
-var schema$4 = require('./utils/schema.cjs');
+var schema$2 = require('./utils/schema.cjs');
 var toolCallContinuation = require('./utils/toolCallContinuation.cjs');
 var contextPressure = require('./utils/contextPressure.cjs');
 var toolDiscoveryCache = require('./utils/toolDiscoveryCache.cjs');
 var pruneCalibration = require('./utils/pruneCalibration.cjs');
 var fileManifest = require('./utils/fileManifest.cjs');
 var errors = require('./utils/errors.cjs');
-var httpClient = require('./utils/httpClient.cjs');
-var credentials = require('./utils/credentials.cjs');
-var toolManifest = require('./utils/toolManifest.cjs');
+var truncation = require('./utils/truncation.cjs');
+var messages = require('@langchain/core/messages');
+var prompts = require('@langchain/core/prompts');
+var runnables = require('@langchain/core/runnables');
+var tools = require('@langchain/core/tools');
 var index$1 = require('./llm/openai/index.cjs');
 var index = require('./llm/openrouter/index.cjs');
 var providers = require('./llm/providers.cjs');
@@ -122,6 +116,10 @@ exports.checkValidNumber = prune.checkValidNumber;
 exports.createPruneMessages = prune.createPruneMessages;
 exports.getContextUtilization = prune.getContextUtilization;
 exports.getMessagesWithinTokenLimit = prune.getMessagesWithinTokenLimit;
+exports.preFlightTruncateToolCallInputs = prune.preFlightTruncateToolCallInputs;
+exports.preFlightTruncateToolResults = prune.preFlightTruncateToolResults;
+exports.repairOrphanedToolMessages = prune.repairOrphanedToolMessages;
+exports.sanitizeOrphanToolBlocks = prune.sanitizeOrphanToolBlocks;
 exports.ensureThinkingBlockInMessages = format.ensureThinkingBlockInMessages;
 exports.formatAgentMessages = format.formatAgentMessages;
 exports.formatFromLangChain = format.formatFromLangChain;
@@ -135,8 +133,8 @@ exports.addCacheControl = cache.addCacheControl;
 exports.stripAnthropicCacheControl = cache.stripAnthropicCacheControl;
 exports.stripBedrockCacheControl = cache.stripBedrockCacheControl;
 exports.formatContentStrings = content.formatContentStrings;
-exports.extractToolDiscoveries = tools.extractToolDiscoveries;
-exports.hasToolSearchInCurrentTurn = tools.hasToolSearchInCurrentTurn;
+exports.extractToolDiscoveries = tools$1.extractToolDiscoveries;
+exports.hasToolSearchInCurrentTurn = tools$1.hasToolSearchInCurrentTurn;
 exports.FULL_SUMMARY_TEMPLATE = summarize.FULL_SUMMARY_TEMPLATE;
 exports.SIMPLE_SUMMARY_TEMPLATE = summarize.SIMPLE_SUMMARY_TEMPLATE;
 exports.buildFullSummaryPrompt = summarize.buildFullSummaryPrompt;
@@ -146,10 +144,12 @@ exports.formatMessagesForSummary = summarize.formatMessagesForSummary;
 exports.summarize = summarize.summarize;
 exports.validateSummarySize = summarize.validateSummarySize;
 exports.deduplicateSystemMessages = dedup.deduplicateSystemMessages;
+exports.applyContextPruning = contextPruning.applyContextPruning;
+exports.DEFAULT_CONTEXT_PRUNING_SETTINGS = contextPruningSettings.DEFAULT_CONTEXT_PRUNING_SETTINGS;
+exports.resolveContextPruningSettings = contextPruningSettings.resolveContextPruningSettings;
 exports.Graph = Graph.Graph;
 exports.StandardGraph = Graph.StandardGraph;
 exports.MultiAgentGraph = MultiAgentGraph.MultiAgentGraph;
-exports.HandoffRegistry = HandoffRegistry.HandoffRegistry;
 exports.Calculator = Calculator.Calculator;
 exports.CalculatorSchema = Calculator.CalculatorSchema;
 exports.CalculatorToolDefinition = Calculator.CalculatorToolDefinition;
@@ -162,6 +162,42 @@ exports.CodeExecutionToolSchema = CodeExecutor.CodeExecutionToolSchema;
 exports.createCodeExecutionTool = CodeExecutor.createCodeExecutionTool;
 exports.getCodeBaseURL = CodeExecutor.getCodeBaseURL;
 exports.imageExtRegex = CodeExecutor.imageExtRegex;
+exports.renderFileSection = CodeExecutor.renderFileSection;
+exports.BashExecutionToolDefinition = BashExecutor.BashExecutionToolDefinition;
+exports.BashExecutionToolDescription = BashExecutor.BashExecutionToolDescription;
+exports.BashExecutionToolName = BashExecutor.BashExecutionToolName;
+exports.BashExecutionToolSchema = BashExecutor.BashExecutionToolSchema;
+exports.BashToolOutputReferencesGuide = BashExecutor.BashToolOutputReferencesGuide;
+exports.buildBashExecutionToolDescription = BashExecutor.buildBashExecutionToolDescription;
+exports.createBashExecutionTool = BashExecutor.createBashExecutionTool;
+exports.BashProgrammaticToolCallingDefinition = BashProgrammaticToolCalling.BashProgrammaticToolCallingDefinition;
+exports.BashProgrammaticToolCallingDescription = BashProgrammaticToolCalling.BashProgrammaticToolCallingDescription;
+exports.BashProgrammaticToolCallingName = BashProgrammaticToolCalling.BashProgrammaticToolCallingName;
+exports.BashProgrammaticToolCallingSchema = BashProgrammaticToolCalling.BashProgrammaticToolCallingSchema;
+exports.createBashProgrammaticToolCallingTool = BashProgrammaticToolCalling.createBashProgrammaticToolCallingTool;
+exports.extractUsedBashToolNames = BashProgrammaticToolCalling.extractUsedBashToolNames;
+exports.filterBashToolsByUsage = BashProgrammaticToolCalling.filterBashToolsByUsage;
+exports.normalizeToBashIdentifier = BashProgrammaticToolCalling.normalizeToBashIdentifier;
+exports.ReadFileToolDefinition = ReadFile.ReadFileToolDefinition;
+exports.ReadFileToolDescription = ReadFile.ReadFileToolDescription;
+exports.ReadFileToolName = ReadFile.ReadFileToolName;
+exports.ReadFileToolSchema = ReadFile.ReadFileToolSchema;
+exports.SkillToolDefinition = SkillTool.SkillToolDefinition;
+exports.SkillToolDescription = SkillTool.SkillToolDescription;
+exports.SkillToolName = SkillTool.SkillToolName;
+exports.SkillToolSchema = SkillTool.SkillToolSchema;
+exports.formatSkillCatalog = skillCatalog.formatSkillCatalog;
+exports.SubagentToolDefinition = SubagentTool.SubagentToolDefinition;
+exports.SubagentToolDescription = SubagentTool.SubagentToolDescription;
+exports.SubagentToolName = SubagentTool.SubagentToolName;
+exports.SubagentToolSchema = SubagentTool.SubagentToolSchema;
+exports.buildSubagentToolParams = SubagentTool.buildSubagentToolParams;
+exports.createSubagentToolDefinition = SubagentTool.createSubagentToolDefinition;
+exports.SubagentExecutor = SubagentExecutor.SubagentExecutor;
+exports.buildChildInputs = SubagentExecutor.buildChildInputs;
+exports.filterSubagentResult = SubagentExecutor.filterSubagentResult;
+exports.resolveSubagentConfigs = SubagentExecutor.resolveSubagentConfigs;
+exports.summarizeEvent = SubagentExecutor.summarizeEvent;
 exports.EBrowserTools = BrowserTools.EBrowserTools;
 exports.createBrowserTools = BrowserTools.createBrowserTools;
 exports.hasBrowserCapability = BrowserTools.hasBrowserCapability;
@@ -204,80 +240,38 @@ exports.AskUserStepSchema = AskUser.AskUserStepSchema;
 exports.AskUserToolName = AskUser.AskUserToolName;
 exports.HITL_FIELDS = AskUser.HITL_FIELDS;
 exports.createAskUserTool = AskUser.createAskUserTool;
-exports.createSchemaOnlyTool = schema$3.createSchemaOnlyTool;
-exports.createSchemaOnlyTools = schema$3.createSchemaOnlyTools;
+exports.createSchemaOnlyTool = schema$1.createSchemaOnlyTool;
+exports.createSchemaOnlyTools = schema$1.createSchemaOnlyTools;
 exports.handleServerToolResult = handlers$1.handleServerToolResult;
 exports.handleToolCallChunks = handlers$1.handleToolCallChunks;
 exports.handleToolCalls = handlers$1.handleToolCalls;
 exports.toolResultTypes = handlers$1.toolResultTypes;
-exports.createSearchTool = tool$2.createSearchTool;
+exports.createSearchTool = tool.createSearchTool;
 Object.defineProperty(exports, "DATE_RANGE", {
 	enumerable: true,
-	get: function () { return schema$1.DATE_RANGE; }
-});
-exports.DEFAULT_COUNTRY_DESCRIPTION = schema$1.DEFAULT_COUNTRY_DESCRIPTION;
-exports.DEFAULT_QUERY_DESCRIPTION = schema$1.DEFAULT_QUERY_DESCRIPTION;
-exports.WebSearchToolDefinition = schema$1.WebSearchToolDefinition;
-exports.WebSearchToolDescription = schema$1.WebSearchToolDescription;
-exports.WebSearchToolName = schema$1.WebSearchToolName;
-exports.WebSearchToolSchema = schema$1.WebSearchToolSchema;
-exports.countrySchema = schema$1.countrySchema;
-exports.dateSchema = schema$1.dateSchema;
-exports.imagesSchema = schema$1.imagesSchema;
-exports.newsSchema = schema$1.newsSchema;
-exports.querySchema = schema$1.querySchema;
-exports.videosSchema = schema$1.videosSchema;
+	get: function () { return schema.DATE_RANGE; }
+});
+exports.DEFAULT_COUNTRY_DESCRIPTION = schema.DEFAULT_COUNTRY_DESCRIPTION;
+exports.DEFAULT_QUERY_DESCRIPTION = schema.DEFAULT_QUERY_DESCRIPTION;
+exports.WebSearchToolDefinition = schema.WebSearchToolDefinition;
+exports.WebSearchToolDescription = schema.WebSearchToolDescription;
+exports.WebSearchToolName = schema.WebSearchToolName;
+exports.WebSearchToolSchema = schema.WebSearchToolSchema;
+exports.countrySchema = schema.countrySchema;
+exports.dateSchema = schema.dateSchema;
+exports.imagesSchema = schema.imagesSchema;
+exports.newsSchema = schema.newsSchema;
+exports.querySchema = schema.querySchema;
+exports.videosSchema = schema.videosSchema;
 exports.buildMemoryTools = index$2.buildMemoryTools;
-exports.createFileSearchTool = tool$1.createFileSearchTool;
-exports.HttpRagClient = ragClient.HttpRagClient;
-exports.RAG_API_URL_ENV = ragClient.RAG_API_URL_ENV;
-exports.getRagBaseUrl = ragClient.getRagBaseUrl;
-exports.createCitationAnchorFormatter = formatter.createCitationAnchorFormatter;
-exports.plainTextFormatter = formatter.plainTextFormatter;
-exports.FileSearchToolName = schema$2.FileSearchToolName;
-exports.fileSearchInputSchema = schema$2.fileSearchInputSchema;
-exports.createArtifactTool = tool.createArtifactTool;
-exports.createContentReaderTool = tool.createContentReaderTool;
-exports.ARTIFACT_TOOL_NAME = schema.ARTIFACT_TOOL_NAME;
-exports.ARTIFACT_WRITE_ACTIONS = schema.ARTIFACT_WRITE_ACTIONS;
-exports.CONTENT_READER_NAME = schema.CONTENT_READER_NAME;
-exports.CONTENT_READ_ACTIONS = schema.CONTENT_READ_ACTIONS;
-exports.artifactToolSchema = schema.artifactToolSchema;
-exports.contentReaderSchema = schema.contentReaderSchema;
-exports.buildProxyTool = proxyTool.buildProxyTool;
-Object.defineProperty(exports, "AuthSource", {
-	enumerable: true,
-	get: function () { return types.AuthSource; }
-});
-Object.defineProperty(exports, "CapabilityKind", {
-	enumerable: true,
-	get: function () { return types.CapabilityKind; }
-});
-exports.CAPABILITY_NAME_SEPARATOR = capabilityNaming.CAPABILITY_NAME_SEPARATOR;
-exports.formatCapabilityName = capabilityNaming.formatCapabilityName;
-exports.parseCapabilityName = capabilityNaming.parseCapabilityName;
-exports.ToolsServerCapabilityProvider = ToolsServerCapabilityProvider.ToolsServerCapabilityProvider;
-exports.MCPCapabilityProvider = MCPCapabilityProvider.MCPCapabilityProvider;
-exports.flattenToolCallResponse = MCPCapabilityProvider.flattenToolCallResponse;
-exports.createTransport = transport.createTransport;
-exports.getMCPEnvDefaults = config$1.getMCPEnvDefaults;
-exports.mcpConsoleLogger = config$1.consoleLogger;
-exports.A2ACapabilityProvider = A2ACapabilityProvider.A2ACapabilityProvider;
-exports.MESSAGE_INPUT_SCHEMA = A2ACapabilityProvider.MESSAGE_INPUT_SCHEMA;
-exports.coerceInputToA2AMessage = A2ACapabilityProvider.coerceInputToA2AMessage;
-exports.skillToCapability = A2ACapabilityProvider.skillToCapability;
-exports.A2AClient = client.A2AClient;
-exports.extractTaskText = client.extractTaskText;
-exports.generateRpcId = client.generateRpcId;
-exports.a2aConsoleLogger = config.consoleLogger;
-exports.getA2AEnvDefaults = config.getA2AEnvDefaults;
-exports.CONTENT_TTL_MS = ContentStore.CONTENT_TTL_MS;
-exports.ContentStore = ContentStore.ContentStore;
-exports.ArtifactStore = ArtifactStore.ArtifactStore;
-exports.sanitizeName = ArtifactStore.sanitizeName;
-exports.buildCachedResponse = mcpAutoCache.buildCachedResponse;
-exports.extractUiMarkers = mcpAutoCache.extractUiMarkers;
-exports.interceptMcpResult = mcpAutoCache.interceptMcpResult;
+exports.HookRegistry = HookRegistry.HookRegistry;
+exports.DEFAULT_HOOK_TIMEOUT_MS = executeHooks.DEFAULT_HOOK_TIMEOUT_MS;
+exports.executeHooks = executeHooks.executeHooks;
+exports.MAX_CACHE_SIZE = matchers.MAX_CACHE_SIZE;
+exports.MAX_PATTERN_LENGTH = matchers.MAX_PATTERN_LENGTH;
+exports.hasNestedQuantifier = matchers.hasNestedQuantifier;
+exports.matchesQuery = matchers.matchesQuery;
+exports.HOOK_EVENTS = types.HOOK_EVENTS;
 exports.DEFAULT_CITATIONS_MODE = constants$2.DEFAULT_CITATIONS_MODE;
 exports.DEFAULT_FLUSH_RESERVE_FLOOR_TOKENS = constants$2.DEFAULT_FLUSH_RESERVE_FLOOR_TOKENS;
 exports.DEFAULT_FLUSH_SOFT_THRESHOLD_TOKENS = constants$2.DEFAULT_FLUSH_SOFT_THRESHOLD_TOKENS;
@@ -360,6 +354,7 @@ exports.validateStructuredOutput = validate.validateStructuredOutput;
 exports.zodToJsonSchema = validate.zodToJsonSchema;
 exports.createApprovalGateNode = ApprovalGateNode.createApprovalGateNode;
 exports.getApprovalGateNodeId = ApprovalGateNode.getApprovalGateNodeId;
+exports.CODE_EXECUTION_TOOLS = _enum.CODE_EXECUTION_TOOLS;
 Object.defineProperty(exports, "Callback", {
 	enumerable: true,
 	get: function () { return _enum.Callback; }
@@ -376,7 +371,6 @@ Object.defineProperty(exports, "ContentTypes", {
 	enumerable: true,
 	get: function () { return _enum.ContentTypes; }
 });
-exports.DEFAULT_HANDOFF_MAX_RESULT_CHARS = _enum.DEFAULT_HANDOFF_MAX_RESULT_CHARS;
 Object.defineProperty(exports, "EdgeType", {
 	enumerable: true,
 	get: function () { return _enum.EdgeType; }
@@ -401,7 +395,6 @@ Object.defineProperty(exports, "GraphNodeKeys", {
 	enumerable: true,
 	get: function () { return _enum.GraphNodeKeys; }
 });
-exports.HANDOFF_TIMEOUT_MS = _enum.HANDOFF_TIMEOUT_MS;
 Object.defineProperty(exports, "MessageTypes", {
 	enumerable: true,
 	get: function () { return _enum.MessageTypes; }
@@ -434,14 +427,6 @@ exports.SUMMARIZATION_CONTEXT_THRESHOLD = constants$1.SUMMARIZATION_CONTEXT_THRE
 exports.SUMMARIZATION_RESERVE_RATIO = constants$1.SUMMARIZATION_RESERVE_RATIO;
 exports.TOOL_DISCOVERY_CACHE_MAX_SIZE = constants$1.TOOL_DISCOVERY_CACHE_MAX_SIZE;
 exports.TOOL_TURN_THINKING_BUDGET = constants$1.TOOL_TURN_THINKING_BUDGET;
-exports.MAX_NESTING_DEPTH = spawnPath.MAX_NESTING_DEPTH;
-exports.SPAWN_PATH_SEP = spawnPath.SPAWN_PATH_SEP;
-exports.buildSpawnPath = spawnPath.buildSpawnPath;
-exports.isAncestorSpawnPath = spawnPath.isAncestorSpawnPath;
-exports.leafSpawnKey = spawnPath.leafSpawnKey;
-exports.parentSpawnPath = spawnPath.parentSpawnPath;
-exports.spawnPathDepth = spawnPath.spawnPathDepth;
-exports.spawnPathParts = spawnPath.spawnPathParts;
 Object.defineProperty(exports, "ActionCategory", {
 	enumerable: true,
 	get: function () { return constants.ActionCategory; }
@@ -483,8 +468,8 @@ exports.isToonFormat = toonFormat.isToonFormat;
 exports.jsonToToon = toonFormat.jsonToToon;
 exports.processToolOutput = toonFormat.processToolOutput;
 exports.buildContextAnalytics = contextAnalytics.buildContextAnalytics;
-exports.isZodSchema = schema$4.isZodSchema;
-exports.toJsonSchema = schema$4.toJsonSchema;
+exports.isZodSchema = schema$2.isZodSchema;
+exports.toJsonSchema = schema$2.toJsonSchema;
 exports.extractFinishReason = toolCallContinuation.extractFinishReason;
 exports.isMaxTokensFinish = toolCallContinuation.isMaxTokensFinish;
 exports.buildMultiDocHintContent = contextPressure.buildMultiDocHintContent;
@@ -501,22 +486,88 @@ exports.buildFileManifestBlock = fileManifest.buildFileManifestBlock;
 exports.extractErrorMessage = errors.extractErrorMessage;
 exports.isContextOverflowError = errors.isContextOverflowError;
 exports.isLikelyContextOverflowError = errors.isLikelyContextOverflowError;
-exports.HttpError = httpClient.HttpError;
-exports.assertOk = httpClient.assertOk;
-exports.createHttpClient = httpClient.createHttpClient;
-Object.defineProperty(exports, "CredentialOrigin", {
-	enumerable: true,
-	get: function () { return credentials.CredentialOrigin; }
-});
-exports.collectRequiredAuthFields = credentials.collectRequiredAuthFields;
-exports.credentialsFromEnv = credentials.credentialsFromEnv;
-exports.filterForwardableCredentials = credentials.filterForwardableCredentials;
-exports.findMissingCredentials = credentials.findMissingCredentials;
-exports.isForwardable = credentials.isForwardable;
-exports.mergeCredentials = credentials.mergeCredentials;
-exports.ManifestCache = toolManifest.ManifestCache;
-exports.applyFilter = toolManifest.applyFilter;
-exports.filterToCacheKey = toolManifest.filterToCacheKey;
+exports.HARD_MAX_TOOL_RESULT_CHARS = truncation.HARD_MAX_TOOL_RESULT_CHARS;
+exports.HARD_MAX_TOTAL_TOOL_OUTPUT_SIZE = truncation.HARD_MAX_TOTAL_TOOL_OUTPUT_SIZE;
+exports.calculateMaxToolResultChars = truncation.calculateMaxToolResultChars;
+exports.calculateMaxTotalToolOutputSize = truncation.calculateMaxTotalToolOutputSize;
+exports.truncateToolInput = truncation.truncateToolInput;
+exports.truncateToolResultContent = truncation.truncateToolResultContent;
+Object.defineProperty(exports, "AIMessage", {
+	enumerable: true,
+	get: function () { return messages.AIMessage; }
+});
+Object.defineProperty(exports, "AIMessageChunk", {
+	enumerable: true,
+	get: function () { return messages.AIMessageChunk; }
+});
+Object.defineProperty(exports, "BaseMessage", {
+	enumerable: true,
+	get: function () { return messages.BaseMessage; }
+});
+Object.defineProperty(exports, "BaseMessageChunk", {
+	enumerable: true,
+	get: function () { return messages.BaseMessageChunk; }
+});
+Object.defineProperty(exports, "HumanMessage", {
+	enumerable: true,
+	get: function () { return messages.HumanMessage; }
+});
+Object.defineProperty(exports, "SystemMessage", {
+	enumerable: true,
+	get: function () { return messages.SystemMessage; }
+});
+Object.defineProperty(exports, "ToolMessage", {
+	enumerable: true,
+	get: function () { return messages.ToolMessage; }
+});
+Object.defineProperty(exports, "getBufferString", {
+	enumerable: true,
+	get: function () { return messages.getBufferString; }
+});
+Object.defineProperty(exports, "isAIMessage", {
+	enumerable: true,
+	get: function () { return messages.isAIMessage; }
+});
+Object.defineProperty(exports, "isBaseMessage", {
+	enumerable: true,
+	get: function () { return messages.isBaseMessage; }
+});
+Object.defineProperty(exports, "isToolMessage", {
+	enumerable: true,
+	get: function () { return messages.isToolMessage; }
+});
+Object.defineProperty(exports, "PromptTemplate", {
+	enumerable: true,
+	get: function () { return prompts.PromptTemplate; }
+});
+Object.defineProperty(exports, "Runnable", {
+	enumerable: true,
+	get: function () { return runnables.Runnable; }
+});
+Object.defineProperty(exports, "RunnableLambda", {
+	enumerable: true,
+	get: function () { return runnables.RunnableLambda; }
+});
+Object.defineProperty(exports, "RunnableSequence", {
+	enumerable: true,
+	get: function () { return runnables.RunnableSequence; }
+});
+Object.defineProperty(exports, "DynamicStructuredTool", {
+	enumerable: true,
+	get: function () { return tools.DynamicStructuredTool; }
+});
+Object.defineProperty(exports, "StructuredTool", {
+	enumerable: true,
+	get: function () { return tools.StructuredTool; }
+});
+Object.defineProperty(exports, "Tool", {
+	enumerable: true,
+	get: function () { return tools.Tool; }
+});
+Object.defineProperty(exports, "tool", {
+	enumerable: true,
+	get: function () { return tools.tool; }
+});
 exports.CustomOpenAIClient = index$1.CustomOpenAIClient;
 exports.ChatOpenRouter = index.ChatOpenRouter;
 exports.getChatModelClass = providers.getChatModelClass;

package/dist/cjs/main.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"main.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"main.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/cjs/messages/cache.cjs

@@ -3,6 +3,47 @@
 var messages = require('@langchain/core/messages');
 var _enum = require('../common/enum.cjs');
 
+/**
+ * Strips Anthropic-style `cache_control` markers from every block in the
+ * given content array. Returns the (possibly cloned) content and a flag
+ * indicating whether anything was actually modified — so callers can avoid
+ * unnecessary message clones.
+ *
+ * Used to sanitize a system message's content array before adding Bedrock
+ * cache points, so stray Anthropic markers (e.g. left over from a previous
+ * Anthropic-provider turn) don't prevent the Bedrock provider from caching
+ * the system prefix.
+ */
+function stripAnthropicCacheControlFromBlocks(content) {
+    let modified = false;
+    const strippedContent = content.map((block) => {
+        if (!('cache_control' in block)) {
+            return block;
+        }
+        const cloned = { ...block };
+        delete cloned.cache_control;
+        modified = true;
+        return cloned;
+    });
+    return { content: strippedContent, modified };
+}
+/**
+ * For the Bedrock cache pass, system messages must NOT carry Anthropic
+ * cache_control markers (those are an Anthropic-specific encoding and
+ * Bedrock uses cachePoint blocks instead). Strip them before the cache
+ * point insertion logic walks the message.
+ */
+function sanitizeBedrockSystemMessage(message) {
+    const content = message.content;
+    if (!Array.isArray(content)) {
+        return message;
+    }
+    const stripped = stripAnthropicCacheControlFromBlocks(content);
+    if (!stripped.modified) {
+        return message;
+    }
+    return cloneMessage(message, stripped.content);
+}
 /** Debug logger for cache operations - set ILLUMA_DEBUG_CACHE=true to enable */
 const debugCache = (message, data) => {
     if (process.env.ILLUMA_DEBUG_CACHE === 'true') {
@@ -270,8 +311,33 @@ function addBedrockCacheControl(messages) {
     });
     // Clone messages to avoid mutating originals
     const updatedMessages = messages.map((msg) => {
+        /* PRESERVE cachePoint on system messages — they're added inline by
+         * AgentContext.buildSystemRunnable to mark the cacheable system prefix
+         * for account-level caching. Only strip stray Anthropic cache_control
+         * (which Bedrock ignores). For non-system messages keep the existing
+         * behaviour: full strip + repopulate based on last-2 strategy. */
+        const msgType = 'getType' in msg && typeof msg.getType === 'function'
+            ? msg.getType()
+            : undefined;
+        const msgRole = msg.role;
+        const isSystem = msgType === 'system' || msgRole === 'system';
         const content = msg.content;
         if (Array.isArray(content)) {
+            if (isSystem) {
+                /* System: keep cachePoint, only strip Anthropic cache_control. */
+                if (hasAnthropicCacheControl(content)) {
+                    const stripped = content.map((block) => {
+                        const rec = block;
+                        if ('cache_control' in rec) {
+                            const { cache_control: _, ...rest } = rec;
+                            return rest;
+                        }
+                        return block;
+                    });
+                    return cloneMessage(msg, stripped);
+                }
+                return cloneMessage(msg, content);
+            }
             // Strip existing cachePoint blocks and Anthropic-style cache_control
             const stripped = content
                 .filter((block) => !isCachePoint(block))
@@ -351,6 +417,29 @@ function addBedrockCacheControl(messages) {
     for (let i = updatedMessages.length - 1; i >= 0 && applied < MAX_CACHE_POINTS; i--) {
         const message = updatedMessages[i];
         const msgContent = message.content;
+        /* System messages are handled by AgentContext.buildSystemRunnable —
+         * the cachePoint is emitted INLINE in the system message content array
+         * so the cacheable system prefix gets a marker every turn (not just
+         * when the system message happens to be in the last 2 eligible). The
+         * Bedrock converter (src/llm/bedrock/utils/message_inputs.ts:261-294)
+         * passes through cachePoint blocks in system content arrays.
+         *
+         * If we ALSO marked system here, we'd: (a) waste one of the two
+         * cachePoint budget slots that Bedrock honours per-request, starving
+         * the conversation tail, and (b) potentially double-mark a stable
+         * prefix that already has its own cachePoint.
+         *
+         * As a defensive cleanup, strip stray Anthropic-style cache_control
+         * markers from the system message — Bedrock ignores them and they
+         * can confuse provider validation. */
+        const _msgType = 'getType' in message && typeof message.getType === 'function'
+            ? message.getType()
+            : undefined;
+        const _msgRole = message.role;
+        if (_msgType === 'system' || _msgRole === 'system') {
+            updatedMessages[i] = sanitizeBedrockSystemMessage(message);
+            continue;
+        }
         // Skip empty/whitespace-only content
         if (msgContent == null)
             continue;