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

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/memory/citations.cjs

@@ -3,7 +3,7 @@
 /**
  * Citation decoration — Phase 2.
  *
- * Ported from upstream `extensions/memory-core/src/tools.citations.ts`.
+ * Ported from a reference implementation `extensions/memory-core/src/tools.citations.ts`.
  * Decorates memory_search hits with `[path#L{start}-L{end}]` markers so
  * the model can attribute claims back to specific memory files when it
  * uses them in its answer.
@@ -12,7 +12,7 @@
  * compute line ranges from the returned content block on the fly:
  *   - `startLine` = 1 (line 1 of the file)
  *   - `endLine`   = total number of lines in the block
- * This matches upstream's output format exactly while keeping the pg
+ * This matches the standard output format exactly while keeping the pg
  * schema chunk-free.
  */
 const DEFAULT_CITATIONS_MODE = 'auto';
@@ -32,7 +32,7 @@ function formatCitation(path, startLine, endLine) {
     return `${path}#L${startLine}-L${endLine}`;
 }
 /**
- * Decorate each hit with a citation marker. Mirrors upstream's behavior:
+ * Decorate each hit with a citation marker. Mirrors the standard behavior:
  * appends `\n\nSource: <citation>` to the content and sets `citation`.
  * When `include=false`, clears any existing citation field.
  */
@@ -50,7 +50,7 @@ function decorateCitations(hits, include) {
 /**
  * Whether citations should be emitted for this call.
  *
- * Upstream keys `auto` off the session type (direct/group/channel). In
+ * The reference implementation keys `auto` off the session type (direct/group/channel). In
  * Phase 1 we only have direct chat, so `auto` => `on`. Callers that
  * later distinguish session types can pass `mode` explicitly.
  */

package/dist/cjs/memory/citations.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"citations.cjs","sources":["../../../src/memory/citations.ts"],"sourcesContent":["/**\n * Citation decoration — Phase 2.\n *\n * Ported from upstream `extensions/memory-core/src/tools.citations.ts`.\n * Decorates memory_search hits with `[path#L{start}-L{end}]` markers so\n * the model can attribute claims back to specific memory files when it\n * uses them in its answer.\n *\n * Since our backend stores files as single rows (not line-chunked), we\n * compute line ranges from the returned content block on the fly:\n *   - `startLine` = 1 (line 1 of the file)\n *   - `endLine`   = total number of lines in the block\n * This matches upstream's output format exactly while keeping the pg\n * schema chunk-free.\n */\n\nexport type MemoryCitationsMode = 'on' | 'off' | 'auto';\n\nexport const DEFAULT_CITATIONS_MODE: MemoryCitationsMode = 'auto';\n\nexport function resolveMemoryCitationsMode(\n  raw: string | undefined | null\n): MemoryCitationsMode {\n  if (raw === 'on' || raw === 'off' || raw === 'auto') return raw;\n  return DEFAULT_CITATIONS_MODE;\n}\n\nexport interface CitationCandidate {\n  path: string;\n  content: string;\n  startLine?: number;\n  endLine?: number;\n  citation?: string;\n}\n\nfunction countLines(text: string): number {\n  if (!text) return 1;\n  return Math.max(1, text.split('\\n').length);\n}\n\nfunction formatCitation(\n  path: string,\n  startLine: number,\n  endLine: number\n): string {\n  if (startLine === endLine) return `${path}#L${startLine}`;\n  return `${path}#L${startLine}-L${endLine}`;\n}\n\n/**\n * Decorate each hit with a citation marker. Mirrors upstream's behavior:\n * appends `\\n\\nSource: <citation>` to the content and sets `citation`.\n * When `include=false`, clears any existing citation field.\n */\nexport function decorateCitations<T extends CitationCandidate>(\n  hits: T[],\n  include: boolean\n): T[] {\n  if (!include) return hits.map((h) => ({ ...h, citation: undefined }));\n  return hits.map((h) => {\n    const start = Math.max(1, Math.floor(h.startLine ?? 1));\n    const end = Math.max(start, Math.floor(h.endLine ?? countLines(h.content)));\n    const citation = formatCitation(h.path, start, end);\n    const content = `${(h.content ?? '').trimEnd()}\\n\\nSource: ${citation}`;\n    return { ...h, citation, content, startLine: start, endLine: end };\n  });\n}\n\n/**\n * Whether citations should be emitted for this call.\n *\n * Upstream keys `auto` off the session type (direct/group/channel). In\n * Phase 1 we only have direct chat, so `auto` => `on`. Callers that\n * later distinguish session types can pass `mode` explicitly.\n */\nexport function shouldIncludeCitations(mode: MemoryCitationsMode): boolean {\n  if (mode === 'on') return true;\n  if (mode === 'off') return false;\n  return true;\n}\n"],"names":[],"mappings":";;AAAA;;;;;;;;;;;;;;AAcG;AAII,MAAM,sBAAsB,GAAwB;AAErD,SAAU,0BAA0B,CACxC,GAA8B,EAAA;IAE9B,IAAI,GAAG,KAAK,IAAI,IAAI,GAAG,KAAK,KAAK,IAAI,GAAG,KAAK,MAAM;AAAE,QAAA,OAAO,GAAG;AAC/D,IAAA,OAAO,sBAAsB;AAC/B;AAUA,SAAS,UAAU,CAAC,IAAY,EAAA;AAC9B,IAAA,IAAI,CAAC,IAAI;AAAE,QAAA,OAAO,CAAC;AACnB,IAAA,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC;AAC7C;AAEA,SAAS,cAAc,CACrB,IAAY,EACZ,SAAiB,EACjB,OAAe,EAAA;IAEf,IAAI,SAAS,KAAK,OAAO;AAAE,QAAA,OAAO,CAAA,EAAG,IAAI,CAAA,EAAA,EAAK,SAAS,EAAE;AACzD,IAAA,OAAO,GAAG,IAAI,CAAA,EAAA,EAAK,SAAS,CAAA,EAAA,EAAK,OAAO,EAAE;AAC5C;AAEA;;;;AAIG;AACG,SAAU,iBAAiB,CAC/B,IAAS,EACT,OAAgB,EAAA;AAEhB,IAAA,IAAI,CAAC,OAAO;QAAE,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,QAAQ,EAAE,SAAS,EAAE,CAAC,CAAC;AACrE,IAAA,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,KAAI;AACpB,QAAA,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,IAAI,CAAC,CAAC,CAAC;QACvD,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,OAAO,IAAI,UAAU,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC;AAC3E,QAAA,MAAM,QAAQ,GAAG,cAAc,CAAC,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,GAAG,CAAC;AACnD,QAAA,MAAM,OAAO,GAAG,CAAA,EAAG,CAAC,CAAC,CAAC,OAAO,IAAI,EAAE,EAAE,OAAO,EAAE,CAAA,YAAA,EAAe,QAAQ,EAAE;AACvE,QAAA,OAAO,EAAE,GAAG,CAAC,EAAE,QAAQ,EAAE,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE;AACpE,IAAA,CAAC,CAAC;AACJ;AAEA;;;;;;AAMG;AACG,SAAU,sBAAsB,CAAC,IAAyB,EAAA;IAC9D,IAAI,IAAI,KAAK,IAAI;AAAE,QAAA,OAAO,IAAI;IAC9B,IAAI,IAAI,KAAK,KAAK;AAAE,QAAA,OAAO,KAAK;AAChC,IAAA,OAAO,IAAI;AACb;;;;;;;"}
+{"version":3,"file":"citations.cjs","sources":["../../../src/memory/citations.ts"],"sourcesContent":["/**\n * Citation decoration — Phase 2.\n *\n * Ported from a reference implementation `extensions/memory-core/src/tools.citations.ts`.\n * Decorates memory_search hits with `[path#L{start}-L{end}]` markers so\n * the model can attribute claims back to specific memory files when it\n * uses them in its answer.\n *\n * Since our backend stores files as single rows (not line-chunked), we\n * compute line ranges from the returned content block on the fly:\n *   - `startLine` = 1 (line 1 of the file)\n *   - `endLine`   = total number of lines in the block\n * This matches the standard output format exactly while keeping the pg\n * schema chunk-free.\n */\n\nexport type MemoryCitationsMode = 'on' | 'off' | 'auto';\n\nexport const DEFAULT_CITATIONS_MODE: MemoryCitationsMode = 'auto';\n\nexport function resolveMemoryCitationsMode(\n  raw: string | undefined | null\n): MemoryCitationsMode {\n  if (raw === 'on' || raw === 'off' || raw === 'auto') return raw;\n  return DEFAULT_CITATIONS_MODE;\n}\n\nexport interface CitationCandidate {\n  path: string;\n  content: string;\n  startLine?: number;\n  endLine?: number;\n  citation?: string;\n}\n\nfunction countLines(text: string): number {\n  if (!text) return 1;\n  return Math.max(1, text.split('\\n').length);\n}\n\nfunction formatCitation(\n  path: string,\n  startLine: number,\n  endLine: number\n): string {\n  if (startLine === endLine) return `${path}#L${startLine}`;\n  return `${path}#L${startLine}-L${endLine}`;\n}\n\n/**\n * Decorate each hit with a citation marker. Mirrors the standard behavior:\n * appends `\\n\\nSource: <citation>` to the content and sets `citation`.\n * When `include=false`, clears any existing citation field.\n */\nexport function decorateCitations<T extends CitationCandidate>(\n  hits: T[],\n  include: boolean\n): T[] {\n  if (!include) return hits.map((h) => ({ ...h, citation: undefined }));\n  return hits.map((h) => {\n    const start = Math.max(1, Math.floor(h.startLine ?? 1));\n    const end = Math.max(start, Math.floor(h.endLine ?? countLines(h.content)));\n    const citation = formatCitation(h.path, start, end);\n    const content = `${(h.content ?? '').trimEnd()}\\n\\nSource: ${citation}`;\n    return { ...h, citation, content, startLine: start, endLine: end };\n  });\n}\n\n/**\n * Whether citations should be emitted for this call.\n *\n * The reference implementation keys `auto` off the session type (direct/group/channel). In\n * Phase 1 we only have direct chat, so `auto` => `on`. Callers that\n * later distinguish session types can pass `mode` explicitly.\n */\nexport function shouldIncludeCitations(mode: MemoryCitationsMode): boolean {\n  if (mode === 'on') return true;\n  if (mode === 'off') return false;\n  return true;\n}\n"],"names":[],"mappings":";;AAAA;;;;;;;;;;;;;;AAcG;AAII,MAAM,sBAAsB,GAAwB;AAErD,SAAU,0BAA0B,CACxC,GAA8B,EAAA;IAE9B,IAAI,GAAG,KAAK,IAAI,IAAI,GAAG,KAAK,KAAK,IAAI,GAAG,KAAK,MAAM;AAAE,QAAA,OAAO,GAAG;AAC/D,IAAA,OAAO,sBAAsB;AAC/B;AAUA,SAAS,UAAU,CAAC,IAAY,EAAA;AAC9B,IAAA,IAAI,CAAC,IAAI;AAAE,QAAA,OAAO,CAAC;AACnB,IAAA,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC;AAC7C;AAEA,SAAS,cAAc,CACrB,IAAY,EACZ,SAAiB,EACjB,OAAe,EAAA;IAEf,IAAI,SAAS,KAAK,OAAO;AAAE,QAAA,OAAO,CAAA,EAAG,IAAI,CAAA,EAAA,EAAK,SAAS,EAAE;AACzD,IAAA,OAAO,GAAG,IAAI,CAAA,EAAA,EAAK,SAAS,CAAA,EAAA,EAAK,OAAO,EAAE;AAC5C;AAEA;;;;AAIG;AACG,SAAU,iBAAiB,CAC/B,IAAS,EACT,OAAgB,EAAA;AAEhB,IAAA,IAAI,CAAC,OAAO;QAAE,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,QAAQ,EAAE,SAAS,EAAE,CAAC,CAAC;AACrE,IAAA,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,KAAI;AACpB,QAAA,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,IAAI,CAAC,CAAC,CAAC;QACvD,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,OAAO,IAAI,UAAU,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC;AAC3E,QAAA,MAAM,QAAQ,GAAG,cAAc,CAAC,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,GAAG,CAAC;AACnD,QAAA,MAAM,OAAO,GAAG,CAAA,EAAG,CAAC,CAAC,CAAC,OAAO,IAAI,EAAE,EAAE,OAAO,EAAE,CAAA,YAAA,EAAe,QAAQ,EAAE;AACvE,QAAA,OAAO,EAAE,GAAG,CAAC,EAAE,QAAQ,EAAE,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE;AACpE,IAAA,CAAC,CAAC;AACJ;AAEA;;;;;;AAMG;AACG,SAAU,sBAAsB,CAAC,IAAyB,EAAA;IAC9D,IAAI,IAAI,KAAK,IAAI;AAAE,QAAA,OAAO,IAAI;IAC9B,IAAI,IAAI,KAAK,KAAK;AAAE,QAAA,OAAO,KAAK;AAChC,IAAA,OAAO,IAAI;AACb;;;;;;;"}

package/dist/cjs/memory/constants.cjs

@@ -21,14 +21,14 @@ const DEFAULT_MEMORY_SCHEMA = 'public';
 const MEMORY_PHASE_NORMAL = 'normal';
 const MEMORY_PHASE_FLUSHING = 'memory_flushing';
 /**
- * Search defaults — aligned with upstream's upstream defaults.
+ * Search defaults — aligned with the standard defaults.
  *
  * Sources:
- * - `upstream reference` → maxResults=6
- * - `upstream reference` → maxInjectedChars=4000
+ * - `reference` → maxResults=6
+ * - `reference` → maxInjectedChars=4000
  *
- * Keeping these in lockstep with upstream means the mandatory-recall tool
- * description, budget clamps, and eval corpora line up with upstream's
+ * Keeping these in lockstep with means the mandatory-recall tool
+ * description, budget clamps, and eval corpora line up with the standard
  * tuning — we inherit their calibration instead of re-tuning from scratch.
  */
 const DEFAULT_MAX_SEARCH_RESULTS = 6;
@@ -38,11 +38,11 @@ const DEFAULT_MAX_INJECTED_CHARS = 4000;
 const HYBRID_VECTOR_WEIGHT = 0.7;
 const HYBRID_TEXT_WEIGHT = 0.3;
 /**
- * Phase 2 rerank defaults — ported from upstream.
+ * Phase 2 rerank defaults — ported from a reference implementation.
  *
  * Sources:
- * - `upstream reference` → lambda=0.7
- * - `upstream reference` → halfLifeDays=30
+ * - `reference` → lambda=0.7
+ * - `reference` → halfLifeDays=30
  *
  * Both features are opt-in (enabled=false by default) — the Phase 2
  * features are layered on top of hybrid search and don't change default
@@ -55,11 +55,11 @@ const DEFAULT_TEMPORAL_DECAY_HALF_LIFE_DAYS = 30;
 const DEFAULT_RECALL_TRACKING_ENABLED = false;
 const DEFAULT_CITATIONS_MODE = 'auto';
 /**
- * Flush trigger margins (token counts) — aligned with upstream upstream.
+ * Flush trigger margins (token counts) — aligned with standard.
  *
  * Sources:
- * - `upstream reference` → softThreshold=4000
- * - `upstream reference` → reserveFloor=20000
+ * - `reference` → softThreshold=4000
+ * - `reference` → reserveFloor=20000
  */
 const DEFAULT_FLUSH_SOFT_THRESHOLD_TOKENS = 4000;
 const DEFAULT_FLUSH_RESERVE_FLOOR_TOKENS = 20000;
@@ -69,7 +69,7 @@ const DEFAULT_MAX_APPENDS_PER_FLUSH = 20;
  * Hard cap on agentic loop iterations inside {@link runMemoryFlush}.
  *
  * Each iteration = one model.invoke() followed by execution of any
- * `memory_append` tool_calls it emits. Mirrors upstream's flush-plan
+ * `memory_append` tool_calls it emits. Mirrors the standard flush-plan
  * loop cap; 8 is enough for ~2–3 reflections of batched notes while
  * protecting against runaway cycles if the model refuses to stop.
  */
@@ -84,9 +84,9 @@ const MEMORY_APPEND_TOOL_NAME = 'memory_append';
  * Mandatory-recall description — the single most load-bearing line in the
  * whole memory system. Do not soften, shorten, or reword without an eval run.
  *
- * Ported VERBATIM from upstream `extensions/memory-core/src/tools.ts:186`.
+ * Ported VERBATIM from a reference implementation `extensions/memory-core/src/tools.ts:186`.
  * The wiki/corpus clause is retained even though Phase 1 doesn't ship
- * compiled-wiki supplements — keeping the string identical means upstream's
+ * compiled-wiki supplements — keeping the string identical means the standard
  * eval corpora remain drop-in valid.
  */
 const MEMORY_SEARCH_DESCRIPTION = 'Mandatory recall step: semantically search MEMORY.md + memory/*.md ' +
@@ -96,7 +96,7 @@ const MEMORY_SEARCH_DESCRIPTION = 'Mandatory recall step: semantically search ME
     'supplements. If response has disabled=true, memory retrieval is ' +
     'unavailable and should be surfaced to the user.';
 /**
- * Ported VERBATIM from upstream `extensions/memory-core/src/tools.ts:322`.
+ * Ported VERBATIM from a reference implementation `extensions/memory-core/src/tools.ts:322`.
  */
 const MEMORY_GET_DESCRIPTION = 'Safe snippet read from MEMORY.md or memory/*.md with optional from/lines; ' +
     '`corpus=wiki` reads from registered compiled-wiki supplements. Use after ' +
@@ -105,7 +105,7 @@ const MEMORY_GET_DESCRIPTION = 'Safe snippet read from MEMORY.md or memory/*.md
  * `memory_append` tool description.
  *
  * Phase 1 historically wrote to a single date-keyed file
- * (`memory/YYYY-MM-DD.md`), ported verbatim from upstream. That scheme
+ * (`memory/YYYY-MM-DD.md`), ported verbatim from a reference implementation. That scheme
  * is now replaced by an 8-path canonical whitelist — see
  * {@link ./paths.MEMORY_ALL_PATHS}. The tool description no longer
  * names a specific file; the flush-turn prompt renders the full rubric
@@ -118,7 +118,7 @@ const MEMORY_APPEND_DESCRIPTION = "Append a durable note to one of the agent's c
     'accumulates across sessions.';
 /**
  * Reply token that signals the flush turn produced no user-visible output.
- * Ported VERBATIM from upstream `src/auto-reply/tokens.ts:4`.
+ * Ported VERBATIM from a reference implementation `src/auto-reply/tokens.ts:4`.
  */
 const SILENT_REPLY_TOKEN = 'NO_REPLY';
 /**