@illuma-ai/agents 1.5.1 → 2.1.1

package/dist/types/agents/AgentContext.d.ts

@@ -58,18 +58,9 @@ export declare class AgentContext {
     toolDefinitions?: t.LCTool[];
     /** Set of tool names discovered via tool search (to be loaded) */
     discoveredToolNames: Set<string>;
-    /**
-     * Cacheable system content blocks emitted before `instructions`. Each
-     * gets its own cache marker (cachePoint on Bedrock, cache_control on
-     * Anthropic). Earlier entries = wider cache key (best for cross-tenant
-     * sharing). See `src/types/agent-cache.ts`.
-     */
-    systemCacheBlocks?: t.SystemCacheBlock[];
-    /** Stable/cacheable instructions for this agent (gets trailing marker). */
+    /** Instructions for this agent */
     instructions?: string;
-    /** TTL for the trailing instructions cache marker. Defaults to '5m'. */
-    instructionsCacheTtl?: t.AgentCacheTTL;
-    /** Dynamic system tail (per-user / per-message — never cached). */
+    /** Additional instructions for this agent */
     additionalInstructions?: string;
     /**
      * Dynamic context that changes per-request (e.g., current time, user info).
@@ -129,13 +120,25 @@ export declare class AgentContext {
     summarizationConfig?: t.SummarizationConfig;
     /** Lightweight file manifest for file-aware compaction (IDs and names only, no content) */
     fileManifest?: t.FileManifestEntry[];
+    /**
+     * Workspace-shared system-message tiers. When set, each entry becomes a
+     * separate text block in the SystemMessage with its own cachePoint /
+     * cache_control marker, BEFORE the per-agent `instructions` block.
+     * See {@link t.AgentInputs.system_cache_blocks} for full semantics.
+     */
+    systemCacheBlocks?: Array<{
+        text: string;
+        ttl?: '5m' | '1h';
+    }>;
+    /** TTL hint for the per-agent instructions cache marker. Defaults to '5m'. */
+    instructionsCacheTtl?: '5m' | '1h';
     /** Original AgentInputs used to create this context — used for self-spawn subagent resolution. */
     _sourceInputs?: t.AgentInputs;
     /** Subagent configurations for hierarchical delegation. */
     subagentConfigs?: t.SubagentConfig[];
     /** Maximum subagent nesting depth. */
     maxSubagentDepth?: number;
-    constructor({ agentId, name, description, provider, clientOptions, maxContextTokens, streamBuffer, tokenCounter, tools, toolMap, toolRegistry, toolDefinitions, systemCacheBlocks, instructions, instructionsCacheTtl, additionalInstructions, dynamicContext, reasoningKey, toolEnd, instructionTokens, useLegacyContent, structuredOutput, discoveredTools, summarizeCallback, persistedSummary, summarizationConfig, fileManifest, }: {
+    constructor({ agentId, name, description, provider, clientOptions, maxContextTokens, streamBuffer, tokenCounter, tools, toolMap, toolRegistry, toolDefinitions, instructions, additionalInstructions, dynamicContext, reasoningKey, toolEnd, instructionTokens, useLegacyContent, structuredOutput, discoveredTools, summarizeCallback, persistedSummary, summarizationConfig, fileManifest, systemCacheBlocks, instructionsCacheTtl, }: {
         agentId: string;
         name?: string;
         description?: string;
@@ -148,9 +151,7 @@ export declare class AgentContext {
         toolMap?: t.ToolMap;
         toolRegistry?: t.LCToolRegistry;
         toolDefinitions?: t.LCTool[];
-        systemCacheBlocks?: t.SystemCacheBlock[];
         instructions?: string;
-        instructionsCacheTtl?: t.AgentCacheTTL;
         additionalInstructions?: string;
         dynamicContext?: string;
         reasoningKey?: 'reasoning_content' | 'reasoning';
@@ -163,6 +164,11 @@ export declare class AgentContext {
         persistedSummary?: string;
         summarizationConfig?: t.SummarizationConfig;
         fileManifest?: t.FileManifestEntry[];
+        systemCacheBlocks?: Array<{
+            text: string;
+            ttl?: '5m' | '1h';
+        }>;
+        instructionsCacheTtl?: '5m' | '1h';
     });
     /**
      * Checks if structured output mode is enabled for this agent.
@@ -213,75 +219,18 @@ export declare class AgentContext {
      */
     initializeSystemRunnable(): void;
     /**
-     * Builds the cacheable instructions string (without creating SystemMessage).
-     * Includes agent identity preamble, the agent's static instructions, and
-     * programmatic-only tool documentation. This is the part of the system
-     * message that stays byte-stable across turns and across users for the
-     * same agent — the prompt cache prefix.
-     *
-     * Per-user/per-message dynamic context belongs in
-     * `buildDynamicInstructionsString()` so it does not invalidate the cache
-     * marker. (See `feedback_cache_stability_invariant` for the rule.)
+     * Builds the raw instructions string (without creating SystemMessage).
+     * Includes agent identity preamble and handoff context when available.
      */
-    private buildStableInstructionsString;
-    /**
-     * Builds the dynamic system-tail string (without creating SystemMessage).
-     * Keep this out of prompt-cache-marked content so volatile per-call
-     * context does not invalidate the stable prefix.
-     *
-     * `additional_instructions` is treated as dynamic (per-user/per-message
-     * memory, runtime context, etc.) and intentionally excluded from the
-     * cacheable prefix.
-     */
-    private buildDynamicInstructionsString;
+    private buildInstructionsString;
     /**
      * Builds the agent identity preamble including handoff context if present.
      * This helps the agent understand its role in the multi-agent workflow.
      */
     private buildIdentityPreamble;
     /**
-     * True when Anthropic prompt caching is enabled for this agent.
-     * Used by `buildSystemRunnable` to decide whether to emit a cache_control
-     * marker on the stable instructions prefix.
-     */
-    private hasAnthropicPromptCache;
-    /**
-     * True when Bedrock prompt caching is enabled for this agent AND the
-     * configured model supports `cachePoint` blocks. Only Claude (and Nova)
-     * models on Bedrock honour cachePoint — Llama / Titan reject it.
-     *
-     * Used by `buildSystemRunnable` to inline a `cachePoint` block right
-     * after the stable system text so the system prefix is cached at the
-     * AWS account level (cross-user, cross-conversation).
-     */
-    private hasBedrockPromptCache;
-    /**
-     * Build system runnable from cacheable blocks + the trailing
-     * `instructions` block + optional dynamic tail.
-     *
-     *   ┌──────────────────────────────────────────┐
-     *   │ system_cache_blocks[0].text              │ ← consumer-defined block 0
-     *   ├──── cache marker (TTL = blocks[0].ttl) ──┤
-     *   │ system_cache_blocks[1].text              │ ← consumer-defined block 1
-     *   ├──── cache marker (TTL = blocks[1].ttl) ──┤
-     *   │ instructions                             │ ← per-agent stable
-     *   ├──── cache marker (TTL = instructionsCacheTtl) ┤
-     *   │ additional_instructions                  │ ← dynamic (uncached)
-     *   └──────────────────────────────────────────┘
-     *
-     * If `system_cache_blocks` is empty, behavior reduces to the 2-tier
-     * (instructions + dynamic) path used by simpler consumers.
-     *
-     * Provider-specific cache marker:
-     *   - Anthropic: `cache_control: { type: 'ephemeral', ttl?: '1h'|'5m' }` on
-     *     each cacheable text block. Up to 4 cache breakpoints per workspace.
-     *   - Bedrock (Claude/Nova): a `{ cachePoint: { type: 'default', ttl?: '1h'|'5m' } }`
-     *     block inserted after each cacheable section. Up to 4 cachePoints per
-     *     request, of which the tools array can consume up to 2.
-     *
-     * Cache key composition: every byte from message start to a given cache
-     * marker forms that marker's cache key. Earlier blocks = wider cache key
-     * = more cross-tenant share. Place the most stable content first.
+     * Build system runnable from pre-built instructions string.
+     * Only called when content has actually changed.
      */
     private buildSystemRunnable;
     /**
@@ -292,25 +241,6 @@ export declare class AgentContext {
      * Update the token count map with instruction tokens
      */
     updateTokenMapWithInstructions(baseTokenMap: Record<string, number>): void;
-    /** Active tool definitions for token accounting (excludes deferred-and-undiscovered entries
-     * and definitions whose `allowed_callers` exclude `'direct'`). Mirrors the gate
-     * `getEventDrivenToolsForBinding` applies so accounting and binding stay aligned. */
-    private getActiveToolDefinitions;
-    /**
-     * Single source of truth for "which entries of `this.tools` should be
-     * treated as actually bound". Callers:
-     *   - `getToolsForBinding` (non-event-driven branch)
-     *   - `getEventDrivenToolsForBinding` (appends instance tools alongside
-     *     schema-only definitions)
-     *   - `calculateInstructionTokens` (counts schema bytes for accounting)
-     *
-     * In event-driven mode (`toolDefinitions` present) instance tools are
-     * appended unfiltered; outside event-driven mode they pass through
-     * `filterToolsForBinding`. Centralizing the decision here prevents the
-     * accounting/binding paths from drifting apart, which was the root
-     * cause of the original miscount (Fixes #121).
-     */
-    private getEffectiveInstanceTools;
     /**
      * Calculate tool tokens and add to instruction tokens
      * Note: System message tokens are calculated during systemRunnable creation

package/dist/types/common/enum.d.ts

@@ -82,19 +82,19 @@ export declare enum Providers {
 }
 export declare enum EdgeType {
     /**
-     * handoff: one-way routing where the parent agent exits
+     * Upstream-aligned handoff: one-way routing where the parent agent exits
      * via a `lc_transfer_to_<destination>` tool call, the child takes over,
      * and the child responds directly to the user. Replaces what used to be
-     * called "TRANSFER" in older versions; the parent-calls-child
+     * called "TRANSFER" in earlier Ranger versions; the parent-calls-child
      * supervisor pattern (formerly `EdgeType.HANDOFF`) is gone — use the
      * Subagent primitive (Tier 5) for deep delegation instead.
      */
     HANDOFF = "handoff",
     /**
-     * Fixed graph edges for automatic transitions. Standard naming.
-     * Downstream consumers may layer additional wiring on top of this edge
-     * type: fan-in with prompt + {results}, parallel groups, approval-gate
-     * node insertion, and the `excludeResults` agentMessages channel.
+     * Fixed graph edges for automatic transitions. Naming matches upstream.
+     * Ranger keeps its enriched wiring on top of this edge type:
+     * fan-in with prompt + {results}, parallel groups, ApprovalGateNode
+     * insertion, and the `excludeResults` agentMessages channel.
      */
     DIRECT = "direct"
 }
@@ -149,15 +149,15 @@ export declare enum Callback {
 export declare enum Constants {
     OFFICIAL_CODE_BASEURL = "https://api.illuma.ai/v1",
     EXECUTE_CODE = "execute_code",
-    /** Tool name for the bash execution primitive (Tier 3). */
+    /** Tool name for the bash execution primitive (upstream Tier 3). */
     BASH_TOOL = "execute_bash",
-    /** Tool name for the bash programmatic-tool-calling variant (Tier 3). */
+    /** Tool name for the bash programmatic-tool-calling variant (upstream Tier 3). */
     BASH_PROGRAMMATIC_TOOL_CALLING = "run_tools_with_bash",
-    /** Tool name for the read-file primitive (Tier 3). */
+    /** Tool name for the read-file primitive (upstream Tier 3). */
     READ_FILE = "read_file",
-    /** Tool name for the SkillTool primitive (Tier 2). */
+    /** Tool name for the SkillTool primitive (upstream Tier 2). */
     SKILL_TOOL = "skill",
-    /** Tool name for the Subagent primitive (Tier 5). */
+    /** Tool name for the Subagent primitive (upstream Tier 5). */
     SUBAGENT = "subagent",
     TOOL_SEARCH = "tool_search",
     PROGRAMMATIC_TOOL_CALLING = "run_tools_with_code",
@@ -219,6 +219,6 @@ export declare enum MessageTypes {
 /**
  * Tool names that use the code execution environment (shared session, file
  * tracking). Used by ToolNode to inject session context + file refs into
- * `invokeParams` before tool execution. constant.
+ * `invokeParams` before tool execution. Upstream-aligned constant.
  */
 export declare const CODE_EXECUTION_TOOLS: ReadonlySet<string>;

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

@@ -50,7 +50,7 @@ export declare abstract class Graph<T extends t.BaseGraphState = t.BaseGraphStat
     hookRegistry?: import('@/hooks').HookRegistry;
     /**
      * Optional tool-output reference registry threaded down from Run
-     * (PR #114). When set, every ToolNode built by this graph
+     * (upstream PR #114). When set, every ToolNode built by this graph
      * stores successful outputs here and resolves `{{tool<i>turn<n>}}`
      * placeholders in args before invoking the tool.
      *
@@ -61,7 +61,7 @@ export declare abstract class Graph<T extends t.BaseGraphState = t.BaseGraphStat
      */
     toolOutputRegistry?: import('@/tools/toolOutputReferences').ToolOutputReferenceRegistry;
     /**
-     * Run-scoped tool output reference configuration (PR #117).
+     * Run-scoped tool output reference configuration (upstream PR #117).
      * When `enabled` is true, the graph lazily allocates a single
      * `ToolOutputReferenceRegistry` on first `getOrCreateToolOutputRegistry()`
      * call and shares it with every ToolNode the graph compiles, so

package/dist/types/graphs/phases/memoryFlushPhase.d.ts

@@ -1,7 +1,7 @@
 /**
  * Memory flush phase — trigger logic + reflection invocation.
  *
- * Ported from the reference implementation's post-turn flush handler. The agent is re-invoked
+ * Ported from upstream's post-turn flush handler. The agent is re-invoked
  * with a reflection system prompt and the `memory_append` tool unlocked;
  * it writes notes to its future self, then the graph returns to normal.
  *
@@ -29,7 +29,7 @@ export interface ShouldFlushInput {
 /**
  * Pure trigger function: fires when the current context is within
  * `softThreshold + reserveFloor` tokens of the model window. Matches
- * the standard formula.
+ * upstream's formula.
  */
 export declare function shouldFlushMemory(input: ShouldFlushInput): boolean;
 export interface RunFlushParams {

package/dist/types/hooks/HookRegistry.d.ts

@@ -10,7 +10,7 @@ import type { HookEvent, HookMatcher } from './types';
  *
  * ## Why `Map<sessionId, MatcherBucket>` and not `Record`
  *
- * Real consumers run thousands of parallel sessions in one Node process, and
+ * LibreChat runs thousands of parallel sessions in one Node process, and
  * hook registration happens inside hot paths (tool loading, agent spawning).
  * A `Record<sessionId, ...>` has to be spread on every insertion, which is
  * O(n) per call and O(n²) total for a batch of parallel registrations. A

package/dist/types/hooks/matchers.d.ts

@@ -50,7 +50,7 @@ export declare const MAX_CACHE_SIZE = 256;
  * This catches the common forms but not all. Ambiguous-alternation ReDoS
  * like `(a|a)+` is not detected. Pathologically long patterns are also
  * caught by {@link MAX_PATTERN_LENGTH}. Hosts that accept user-supplied
- * patterns must still validate standard.
+ * patterns must still validate upstream.
  */
 export declare function hasNestedQuantifier(pattern: string): boolean;
 /**
@@ -84,7 +84,7 @@ export declare function hasNestedQuantifier(pattern: string): boolean;
  *    never re-enter the regex compiler.
  *
  * These are a floor, not a ceiling. Hosts that accept user-supplied
- * patterns should still validate standard. The design report §3.8 routes
+ * patterns should still validate upstream. The design report §3.8 routes
  * persistable hooks through a host-side compiler before they reach this
  * module.
  */

package/dist/types/hooks/types.d.ts

@@ -5,7 +5,7 @@ import type { BaseMessage } from '@langchain/core/messages';
  * These mirror the subset of Claude Code's event surface that makes sense
  * for a library context (no filesystem/CLI-specific events). See
  * `docs/hooks-design-report.md` §3.2 for the mapping to existing
- * `@illuma-ai/agents` emission points.
+ * `@librechat/agents` emission points.
  */
 export declare const HOOK_EVENTS: readonly ["RunStart", "UserPromptSubmit", "PreToolUse", "PostToolUse", "PostToolUseFailure", "PermissionDenied", "SubagentStart", "SubagentStop", "Stop", "StopFailure", "PreCompact", "PostCompact"];
 export type HookEvent = (typeof HOOK_EVENTS)[number];

package/dist/types/index.d.ts

@@ -35,7 +35,6 @@ export * from './nodes';
 export * from './common';
 export * from './utils';
 export type * from './types';
-export * from './langchain';
 export { CustomOpenAIClient } from './llm/openai';
 export { ChatOpenRouter } from './llm/openrouter';
 export type { OpenRouterReasoning, OpenRouterReasoningEffort, ChatOpenRouterCallOptions, } from './llm/openrouter';

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

@@ -41,65 +41,18 @@ import type { ChatBedrockConverseInput } from '@langchain/aws';
  * @see https://docs.aws.amazon.com/bedrock/latest/userguide/service-tiers-inference.html
  */
 export type ServiceTierType = 'priority' | 'default' | 'flex' | 'reserved';
-/**
- * Tool cachePoint allocation strategy.
- *
- *   - 'single':  one cachePoint at the END of the tools array (whole array
- *                cached as one unit). Lightest budget use (1 cachePoint).
- *   - 'split':   split tools into groups via `toolGroupSelector`. Each
- *                non-empty group gets its own cachePoint. Use when groups
- *                have different volatility (e.g. stable core tools vs
- *                volatile MCP tools). Costs more cachePoint budget.
- *   - 'none':    no cachePoint on tools array. Use when tool definitions
- *                change every request anyway.
- */
-export type ToolCacheStrategy = 'single' | 'split' | 'none';
-/**
- * Group selector for `toolCacheStrategy: 'split'`. Receives the tool name
- * and returns a stable group key — tools with the same key are grouped
- * together. Group order in the output array follows first-encounter order.
- */
-export type ToolGroupSelector = (toolName: string) => string;
-/**
- * Default group selector — puts all tools in a single group named 'core'.
- * Equivalent to 'single' strategy but explicit. Consumers override this
- * to enable per-source grouping (e.g. by inspecting tool-name substrings
- * to separate stable framework tools from volatile MCP-sourced tools).
- */
-export declare const DEFAULT_TOOL_GROUP_SELECTOR: ToolGroupSelector;
 /**
  * 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)
- * - toolCacheStrategy: How to allocate cachePoints across tools array
- * - toolGroupSelector: Group key resolver for the 'split' strategy
  */
 export interface IllumaBedrockConverseInput extends ChatBedrockConverseInput {
     /**
      * Enable Bedrock prompt caching for tool definitions.
-     * When true, adds cachePoint marker(s) to tools array per
-     * `toolCacheStrategy`. Defaults to 'single'.
+     * When true, adds cachePoint markers to tools array.
      */
     promptCache?: boolean;
-    /**
-     * Tool cachePoint allocation. Defaults to 'single' — one cachePoint at
-     * the end of the tools array. Set to 'split' (with `toolGroupSelector`)
-     * when different tool groups have different volatility.
-     */
-    toolCacheStrategy?: ToolCacheStrategy;
-    /**
-     * Group selector for 'split' strategy. Receives a tool name, returns
-     * a stable group key. Defaults to a one-group selector (equivalent
-     * to 'single').
-     */
-    toolGroupSelector?: ToolGroupSelector;
-    /**
-     * Additional model ID patterns to consider Bedrock-cache-supported.
-     * Defaults are in `src/llm/bedrock/cacheSupport.ts`. Use this when
-     * AWS adds a new model family before the next library release.
-     */
-    bedrockCacheModelPatterns?: readonly RegExp[];
     /**
      * Application Inference Profile ARN to use for the model.
      * For example, "arn:aws:bedrock:eu-west-1:123456789102:application-inference-profile/fm16bt65tzgx"
@@ -137,12 +90,6 @@ export declare class IllumaBedrockConverse extends ChatBedrockConverse {
     applicationInferenceProfile?: string;
     /** Service tier for model invocation */
     serviceTier?: ServiceTierType;
-    /** Tool cachePoint allocation strategy. */
-    toolCacheStrategy: ToolCacheStrategy;
-    /** Group selector for 'split' strategy. */
-    toolGroupSelector: ToolGroupSelector;
-    /** Optional consumer extensions to the cache-supported model allowlist. */
-    bedrockCacheModelPatterns?: readonly RegExp[];
     constructor(fields?: IllumaBedrockConverseInput);
     static lc_name(): string;
     /**

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

@@ -102,7 +102,7 @@ export interface XAIUsageMetadata extends OpenAIClient.Completions.CompletionUsa
     num_sources_used?: number;
 }
 export declare class ChatMoonshot extends ChatOpenAI {
-    static lc_name(): 'IllumaMoonshot';
+    static lc_name(): 'LibreChatMoonshot';
     protected _convertMessages(messages: BaseMessage[]): OpenAICompletionParam[];
     _generate(messages: BaseMessage[], options: this['ParsedCallOptions'], runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;
     protected _convertResponseToMessage(choice: OpenAIClient.Chat.Completions.ChatCompletion.Choice, data: OpenAIClient.Chat.Completions.ChatCompletion): AIMessage;

package/dist/types/memory/citations.d.ts

@@ -1,7 +1,7 @@
 /**
  * Citation decoration — Phase 2.
  *
- * Ported from a reference implementation `extensions/memory-core/src/tools.citations.ts`.
+ * Ported from upstream `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.
@@ -10,7 +10,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 the standard output format exactly while keeping the pg
+ * This matches upstream's output format exactly while keeping the pg
  * schema chunk-free.
  */
 export type MemoryCitationsMode = 'on' | 'off' | 'auto';
@@ -24,7 +24,7 @@ export interface CitationCandidate {
     citation?: string;
 }
 /**
- * Decorate each hit with a citation marker. Mirrors the standard behavior:
+ * Decorate each hit with a citation marker. Mirrors upstream's behavior:
  * appends `\n\nSource: <citation>` to the content and sets `citation`.
  * When `include=false`, clears any existing citation field.
  */
@@ -32,7 +32,7 @@ export declare function decorateCitations<T extends CitationCandidate>(hits: T[]
 /**
  * Whether citations should be emitted for this call.
  *
- * The reference implementation keys `auto` off the session type (direct/group/channel). In
+ * Upstream 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/types/memory/constants.d.ts

@@ -19,14 +19,14 @@ export declare const DEFAULT_MEMORY_SCHEMA = "public";
 export declare const MEMORY_PHASE_NORMAL = "normal";
 export declare const MEMORY_PHASE_FLUSHING = "memory_flushing";
 /**
- * Search defaults — aligned with the standard defaults.
+ * Search defaults — aligned with upstream's upstream defaults.
  *
  * Sources:
- * - `reference` → maxResults=6
- * - `reference` → maxInjectedChars=4000
+ * - `upstream reference` → maxResults=6
+ * - `upstream reference` → maxInjectedChars=4000
  *
- * Keeping these in lockstep with means the mandatory-recall tool
- * description, budget clamps, and eval corpora line up with the standard
+ * Keeping these in lockstep with upstream means the mandatory-recall tool
+ * description, budget clamps, and eval corpora line up with upstream's
  * tuning — we inherit their calibration instead of re-tuning from scratch.
  */
 export declare const DEFAULT_MAX_SEARCH_RESULTS = 6;
@@ -36,11 +36,11 @@ export declare const DEFAULT_MAX_INJECTED_CHARS = 4000;
 export declare const HYBRID_VECTOR_WEIGHT = 0.7;
 export declare const HYBRID_TEXT_WEIGHT = 0.3;
 /**
- * Phase 2 rerank defaults — ported from a reference implementation.
+ * Phase 2 rerank defaults — ported from upstream.
  *
  * Sources:
- * - `reference` → lambda=0.7
- * - `reference` → halfLifeDays=30
+ * - `upstream reference` → lambda=0.7
+ * - `upstream 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
@@ -53,11 +53,11 @@ export declare const DEFAULT_TEMPORAL_DECAY_HALF_LIFE_DAYS = 30;
 export declare const DEFAULT_RECALL_TRACKING_ENABLED = false;
 export declare const DEFAULT_CITATIONS_MODE: "auto";
 /**
- * Flush trigger margins (token counts) — aligned with standard.
+ * Flush trigger margins (token counts) — aligned with upstream upstream.
  *
  * Sources:
- * - `reference` → softThreshold=4000
- * - `reference` → reserveFloor=20000
+ * - `upstream reference` → softThreshold=4000
+ * - `upstream reference` → reserveFloor=20000
  */
 export declare const DEFAULT_FLUSH_SOFT_THRESHOLD_TOKENS = 4000;
 export declare const DEFAULT_FLUSH_RESERVE_FLOOR_TOKENS = 20000;
@@ -67,7 +67,7 @@ export declare 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 the standard flush-plan
+ * `memory_append` tool_calls it emits. Mirrors upstream's 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.
  */
@@ -82,21 +82,21 @@ export declare 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 a reference implementation `extensions/memory-core/src/tools.ts:186`.
+ * Ported VERBATIM from upstream `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 the standard
+ * compiled-wiki supplements — keeping the string identical means upstream's
  * eval corpora remain drop-in valid.
  */
 export declare const MEMORY_SEARCH_DESCRIPTION: string;
 /**
- * Ported VERBATIM from a reference implementation `extensions/memory-core/src/tools.ts:322`.
+ * Ported VERBATIM from upstream `extensions/memory-core/src/tools.ts:322`.
  */
 export declare const MEMORY_GET_DESCRIPTION: string;
 /**
  * `memory_append` tool description.
  *
  * Phase 1 historically wrote to a single date-keyed file
- * (`memory/YYYY-MM-DD.md`), ported verbatim from a reference implementation. That scheme
+ * (`memory/YYYY-MM-DD.md`), ported verbatim from upstream. 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
@@ -105,7 +105,7 @@ export declare const MEMORY_GET_DESCRIPTION: string;
 export declare const MEMORY_APPEND_DESCRIPTION: string;
 /**
  * Reply token that signals the flush turn produced no user-visible output.
- * Ported VERBATIM from a reference implementation `src/auto-reply/tokens.ts:4`.
+ * Ported VERBATIM from upstream `src/auto-reply/tokens.ts:4`.
  */
 export declare const SILENT_REPLY_TOKEN = "NO_REPLY";
 /**

package/dist/types/memory/mmr.d.ts

@@ -1,7 +1,7 @@
 /**
  * Maximal Marginal Relevance (MMR) re-ranking — Phase 2.
  *
- * Ported from a reference implementation `extensions/memory-core/src/memory/mmr.ts` with
+ * Ported from upstream `extensions/memory-core/src/memory/mmr.ts` with
  * minor adaptation for our `MemoryEntry` shape (content vs snippet, id vs
  * path+startLine). Behavior is identical: normalize scores, iteratively
  * pick the item that maximizes `λ * relevance - (1-λ) * max_similarity`
@@ -10,9 +10,9 @@
  * @see Carbonell & Goldstein, "The Use of MMR, Diversity-Based Reranking" (1998)
  */
 export interface MMRConfig {
-    /** Opt-in. Default is false. */
+    /** Opt-in. Upstream default is false. */
     enabled: boolean;
-    /** 0 = max diversity, 1 = max relevance. Default 0.7. */
+    /** 0 = max diversity, 1 = max relevance. Upstream default 0.7. */
     lambda: number;
 }
 export declare const DEFAULT_MMR_CONFIG: MMRConfig;

package/dist/types/memory/paths.d.ts

@@ -8,7 +8,7 @@
  *
  * ## Why a whitelist?
  *
- * Earlier historical designs used date-keyed files
+ * Earlier upstream-faithful designs used date-keyed files
  * (`memory/YYYY-MM-DD.md`), which have three problems for a persistent
  * multi-user agent:
  *

package/dist/types/memory/temporalDecay.d.ts

@@ -1,14 +1,14 @@
 /**
  * Temporal decay — Phase 2.
  *
- * Ported from a reference implementation `extensions/memory-core/src/memory/temporal-decay.ts`.
+ * Ported from upstream `extensions/memory-core/src/memory/temporal-decay.ts`.
  * Ages dated memory files (`memory/YYYY-MM-DD.md`) using exponential decay
  * `multiplier = exp(-ln(2) / halfLifeDays * ageInDays)`. At half-life, the
  * score is exactly halved.
  *
  * Evergreen files (MEMORY.md, memory/topics.md, any non-dated file inside
  * memory/) do NOT decay — they represent durable knowledge and should stay
- * hot regardless of age. This mirrors the standard `isEvergreenMemoryPath`.
+ * hot regardless of age. This mirrors upstream's `isEvergreenMemoryPath`.
  *
  * Since our pgvector rows carry `createdAt`, we don't need filesystem stat
  * fallback — the row timestamp is authoritative for any file without a

package/dist/types/memory/types.d.ts

@@ -1,7 +1,7 @@
 /**
  * Autonomous memory — core types.
  *
- * Ported from the reference implementation's memory-core pattern, adapted for Postgres + pgvector
+ * Ported from upstream's memory-core pattern, adapted for Postgres + pgvector
  * and shaped so a future graph-backend layer (Graphiti, Neo4j agent-memory, etc.)
  * can be added alongside the vector store without changing the tool contracts.
  *
@@ -75,7 +75,7 @@ export interface MemorySearchOptions {
     minScore?: number;
     /**
      * Phase 2 toggles — when the backend supports them. Each is independently
-     * opt-in; all false = Phase 1 behavior.
+     * opt-in; all false = upstream Phase 1 behavior.
      */
     mmr?: {
         enabled?: boolean;
@@ -144,7 +144,7 @@ export interface MemoryConfig {
     search?: {
         maxResults?: number;
         maxInjectedChars?: number;
-        /** Phase 2 — enable MMR reranking (defaults when true). */
+        /** Phase 2 — enable MMR reranking (upstream-aligned defaults when true). */
         mmr?: {
             enabled?: boolean;
             lambda?: number;

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

@@ -83,9 +83,6 @@ interface LangChainMessage {
  * @returns - The formatted LangChain message.
  */
 export declare const formatFromLangChain: (message: LangChainMessage) => Record<string, any>;
-interface FormatAgentMessagesOptions {
-    provider?: Providers;
-}
 /**
  * Groups content parts by agent and formats them with agent labels
  * This preprocesses multi-agent content to prevent identity confusion
@@ -110,10 +107,10 @@ export declare const labelContentByAgent: (contentParts: MessageContentComplex[]
  *   When SkillTool is invoked, the body is injected as a HumanMessage into LangGraph state
  *   but NOT persisted to conversation history. On follow-up runs the skill body is lost.
  *   Pass `skills` to reconstruct the HumanMessage at the right position after each skill
- *   ToolMessage. PRs #96 / #97.
+ *   ToolMessage. Upstream PRs #96 / #97.
  * @returns - Object containing formatted messages and updated indexTokenCountMap if provided.
  */
-export declare const formatAgentMessages: (payload: TPayload, indexTokenCountMap?: Record<number, number | undefined>, tools?: Set<string>, skills?: Map<string, string>, options?: FormatAgentMessagesOptions) => {
+export declare const formatAgentMessages: (payload: TPayload, indexTokenCountMap?: Record<number, number | undefined>, tools?: Set<string>, skills?: Map<string, string>) => {
     messages: Array<HumanMessage | AIMessage | SystemMessage | ToolMessage>;
     indexTokenCountMap?: Record<number, number>;
 };