@dory-agentic/dory-agentic-sdk 0.2.0

package/dist/history/messageManifest.js

@@ -0,0 +1,231 @@
+import { buildRelevanceScoringInstructions } from "../lfs/memoryParser";
+/** Parse msg_01 / msg_1 / msg1 → 1. Returns null if not a msg_N id. */
+export function parseMsgNumber(id) {
+    const m = id.match(/^msg_?0*(\d+)$/i);
+    if (!m)
+        return null;
+    const n = parseInt(m[1], 10);
+    return Number.isFinite(n) && n > 0 ? n : null;
+}
+/** User/assistant turns eligible for credit_allocation (excludes traces, tools, archived). */
+export function isScorableMessage(m) {
+    if (m.isArchived || m.role === 'system' || m.role === 'tool' || !m.id)
+        return false;
+    if (m.stepKind === 'thought' || m.stepKind === 'memory')
+        return false;
+    return m.role === 'user' || m.role === 'assistant';
+}
+export function classifyMessageKind(m) {
+    if (m.isArchived)
+        return 'archived';
+    if (m.role === 'system')
+        return 'system';
+    if (m.role === 'tool')
+        return 'tool';
+    if (m.stepKind === 'thought' || m.stepKind === 'memory')
+        return 'trace';
+    return 'conversation';
+}
+/** Build manifest in strict history array order (oldest → newest). */
+export function buildMessageManifest(history) {
+    let conversationalIndex = 0;
+    return history.map((m, i) => {
+        const scorable = isScorableMessage(m);
+        if (scorable)
+            conversationalIndex += 1;
+        return {
+            id: m.id || `unknown_${i}`,
+            role: m.role,
+            kind: classifyMessageKind(m),
+            positionInHistory: i + 1,
+            scorable,
+            conversationalIndex: scorable ? conversationalIndex : undefined,
+        };
+    });
+}
+export function collectScorableMessageIds(history) {
+    return buildMessageManifest(history)
+        .filter((e) => e.scorable)
+        .map((e) => e.id);
+}
+/** Map msg number → canonical id (msg_01). One number must not map to two ids. */
+export function buildMsgNumberToIdMap(ids) {
+    const map = new Map();
+    for (const id of ids) {
+        const n = parseMsgNumber(id);
+        if (n == null)
+            continue;
+        if (!map.has(n)) {
+            map.set(n, id);
+        }
+    }
+    return map;
+}
+export function resolveMessageId(rawId, activeIds, numberMap) {
+    if (activeIds.has(rawId))
+        return rawId;
+    const n = parseMsgNumber(rawId);
+    if (n != null && numberMap.has(n))
+        return numberMap.get(n);
+    return null;
+}
+export function formatMessageForApi(m, entry, totalScorable, isMmuActive) {
+    if (isMmuActive === false) {
+        return { role: m.role, content: m.content };
+    }
+    if (entry.kind === 'archived' || entry.kind === 'system') {
+        return { role: m.role, content: m.content };
+    }
+    if (entry.kind === 'tool') {
+        return {
+            role: 'user',
+            content: `[Tool result ID: ${entry.id} | history position #${entry.positionInHistory} | not scorable]\n\n` +
+                m.content,
+        };
+    }
+    if (entry.kind === 'trace') {
+        const stepTag = m.agenticStep ? ` | agentic step ${m.agenticStep}` : '';
+        return {
+            role: m.role,
+            content: `[Internal trace ID: ${entry.id} | history #${entry.positionInHistory}${stepTag} | not scorable]\n\n` +
+                m.content,
+        };
+    }
+    const convIdx = entry.conversationalIndex ?? '?';
+    return {
+        role: m.role,
+        content: `[Message ID: ${entry.id} | conversation #${convIdx} of ${totalScorable} | history #${entry.positionInHistory} | ${entry.role} | oldest→newest order]\n\n` +
+            m.content,
+    };
+}
+export function formatHistoryForModel(history, systemPrompt, opts) {
+    const manifest = buildMessageManifest(history);
+    const totalScorable = manifest.filter((e) => e.scorable).length;
+    const apiMsgs = history.map((m, i) => formatMessageForApi(m, manifest[i], totalScorable, opts?.isMmuActive));
+    const mergedMsgs = [];
+    let currentArchivedRange = null;
+    for (let i = 0; i < apiMsgs.length; i++) {
+        const msg = apiMsgs[i];
+        const isArchivedPill = history[i].isArchived;
+        if (isArchivedPill && opts?.lane === 'optimized') {
+            const id = history[i].id;
+            // Use clean summary text, stripping remind instructions from it
+            const summary = (history[i].archiveSummary || history[i].content)
+                .replace(/⚡ SWAPPED TO DISK SUMMARY: /, '')
+                .replace(/\. \[Available via tool: remind\(id: '[^']+'\)\]/, '');
+            if (!currentArchivedRange) {
+                currentArchivedRange = { startId: id, endId: id, items: [{ id, summary }] };
+            }
+            else {
+                currentArchivedRange.endId = id;
+                currentArchivedRange.items.push({ id, summary });
+            }
+        }
+        else {
+            if (currentArchivedRange) {
+                const rangeText = currentArchivedRange.startId === currentArchivedRange.endId
+                    ? currentArchivedRange.startId
+                    : `${currentArchivedRange.startId}-${currentArchivedRange.endId}`;
+                let contextText = '';
+                const totalItems = currentArchivedRange.items.length;
+                if (totalItems <= 8) {
+                    contextText = currentArchivedRange.items.map(item => `${item.id}: ${item.summary}`).join('; ');
+                }
+                else {
+                    const olderCount = totalItems - 8;
+                    const olderStart = currentArchivedRange.items[0].id;
+                    const olderEnd = currentArchivedRange.items[totalItems - 9].id;
+                    const olderSummary = `${olderStart}-${olderEnd}: ${olderCount} messages archived (infrastructure, coding, and tests setup)`;
+                    const recentText = currentArchivedRange.items.slice(totalItems - 8).map(item => `${item.id}: ${item.summary}`).join('; ');
+                    contextText = `${olderSummary}; ${recentText}`;
+                }
+                const content = `[📁 Archived Block ${rangeText} | Context: ${contextText} | Available via tool: remind(messageId)]`;
+                mergedMsgs.push({ role: 'system', content });
+                currentArchivedRange = null;
+            }
+            mergedMsgs.push(msg);
+        }
+    }
+    if (currentArchivedRange) {
+        const rangeText = currentArchivedRange.startId === currentArchivedRange.endId
+            ? currentArchivedRange.startId
+            : `${currentArchivedRange.startId}-${currentArchivedRange.endId}`;
+        let contextText = '';
+        const totalItems = currentArchivedRange.items.length;
+        if (totalItems <= 8) {
+            contextText = currentArchivedRange.items.map(item => `${item.id}: ${item.summary}`).join('; ');
+        }
+        else {
+            const olderCount = totalItems - 8;
+            const olderStart = currentArchivedRange.items[0].id;
+            const olderEnd = currentArchivedRange.items[totalItems - 9].id;
+            const olderSummary = `${olderStart}-${olderEnd}: ${olderCount} messages archived (infrastructure, coding, and tests setup)`;
+            const recentText = currentArchivedRange.items.slice(totalItems - 8).map(item => `${item.id}: ${item.summary}`).join('; ');
+            contextText = `${olderSummary}; ${recentText}`;
+        }
+        const content = `[📁 Archived Block ${rangeText} | Context: ${contextText} | Available via tool: remind(messageId)]`;
+        mergedMsgs.push({ role: 'system', content });
+    }
+    const result = [
+        { role: 'system', content: systemPrompt },
+        ...mergedMsgs,
+    ];
+    if (opts?.lane === 'optimized' && opts.isMmuActive !== false) {
+        const budget = opts.budget ?? 0;
+        const remindClause = opts.remindClause ?? 'Do NOT call tools unless archived disk summaries are present and insufficient.';
+        const scoringInstructions = buildRelevanceScoringInstructions({
+            budget,
+            history,
+        });
+        const metaContent = `[🚨 SYSTEM MEMORY METADATA & SCORING RULES]
+Active Credit Budget: ${budget} credits for this turn.
+
+${scoringInstructions}
+
+${remindClause}`;
+        if (result.length > 0) {
+            const lastMsg = result[result.length - 1];
+            if (lastMsg.role === 'user') {
+                result.splice(result.length - 1, 0, { role: 'system', content: metaContent });
+            }
+            else {
+                result.push({ role: 'system', content: metaContent });
+            }
+        }
+    }
+    return result;
+}
+/** Agentic loop: history only (system prompt added separately). */
+export function formatAgenticHistoryForModel(history) {
+    const manifest = buildMessageManifest(history);
+    const totalScorable = manifest.filter((e) => e.scorable).length;
+    return history.map((m, i) => formatMessageForApi(m, manifest[i], totalScorable));
+}
+/** Prompt block listing scorable IDs in the same order as the model sees them (oldest first). */
+export function formatScorableIdListForPrompt(history) {
+    const hasChunks = history.some(m => m.chunks && m.chunks.length > 0);
+    if (hasChunks) {
+        const activeChunkIds = [];
+        for (const msg of history) {
+            if (msg.chunks) {
+                for (const chunk of msg.chunks) {
+                    if (!chunk.isArchived) {
+                        activeChunkIds.push(chunk.chunkId);
+                    }
+                }
+            }
+        }
+        if (activeChunkIds.length === 0) {
+            return '- (no active scorable chunks yet)';
+        }
+        return activeChunkIds.map(id => `- ${id}`).join('\n');
+    }
+    const manifest = buildMessageManifest(history);
+    const scorable = manifest.filter((e) => e.scorable);
+    if (scorable.length === 0) {
+        return '- (no scorable messages yet — use [Message ID: msg_xx] from conversation rows only)';
+    }
+    return scorable
+        .map((e) => `- ${e.id} | conversation #${e.conversationalIndex} of ${scorable.length} | history #${e.positionInHistory} | ${e.role}`)
+        .join('\n');
+}

package/dist/index.d.ts

@@ -0,0 +1,33 @@
+export { createLfsAgent } from "./agent/createLfsAgent";
+export type { CreateLfsAgentResult } from "./agent/createLfsAgent";
+export { TOOL_LOOP_DEFAULTS } from "./agent/loopConfig";
+export { runLfsTurn } from "./agent/runLfsTurn";
+export { LfsContextAdapter } from "./lfs/contextAdapter";
+export { LFS_CONFIG, LFS_MEMORY_CAP, clampMemoryCapFraction, effectiveMemoryCapFraction, } from "./lfs/config";
+export { resolveLfsRuntimeConfig, resolveLfsRuntimeWindow, clampMemoryPressureFraction, LFS_MEMORY_PRESSURE, } from "./lfs/runtimeConfig";
+export type { LfsRuntimeConfig } from "./lfs/runtimeConfig";
+export { getOrCreateSessionState, clearAllSessions, clearSession, configureSessionStore } from "./lfs/sessionStore";
+export { formatForModelMessages, buildLfsMetadataSystemBlock } from "./history/formatForModel";
+export { formatHistoryForModel } from "./history/messageManifest";
+export { fromDoryCodeMessageV2 } from "./history/dorycodeAdapter";
+export { createToolRegistry } from "./tools/registry";
+export type { ToolRegistryResult } from "./tools/registry";
+export { createRemindTool, buildLfsRemindClause, hydrateLfsTarget } from "./tools/remind";
+export { createSkillLoaderTool, loadSkillMarkdown } from "./tools/skillLoader";
+export type { SkillLoaderOptions } from "./tools/skillLoader";
+export { createAgentSdkProviderRegistry } from "./providers/registry";
+export { createOllamaProvider } from "./providers/ollama";
+export { deriveAdaptiveCoefficients, calculateDynamicMemoryCap } from "./lfs/adaptiveCoefficients";
+export { validateFetchUrl, getFetchUrlAllowlist, MCP_TOOL_RESULT_MAX_CHARS } from "./mcp/config";
+export type { McpClientOptions } from "./mcp/client";
+export { determineExecutionLane } from "./lfs/preflightRouter";
+export type { ExecutionLane, RouterTelemetry } from "./lfs/preflightRouter";
+export { executeParitySwap, compileSkeletalHistory, calculateUtility } from "./lfs/paritySwapper";
+export { chunkMessageTurn, calculateDynamicChunkSize, calculateDynamicFrameLimit, identifyContentType, } from "./lfs/chunkManager";
+export { clearVectorCache, upsertChunkVector, upsertVector, queryChunkVectorCache, queryVectorCache, setChunkArchiveStatus, generateLocalEmbedding, } from "./lfs/vectorDb";
+export type { ChunkRecord } from "./lfs/vectorDb";
+export { applyAgenticStepMemory, applyHydrationDisplacementDecay, applyUserSendDecay, calculateCreditBudget, calculateCreditBudgetV2, calculateTargetMemoryCap, findActiveTurnAnchorId, findPredecessorMessageId, getNormalizedPressure, getPressureRatio, initializeForgetScoresMidConversation, isConversationalMessage, suggestMemoryCapFraction, validateAndApplyCredits, } from "./lfs/memoryEngine";
+export type { MemoryCoefficients } from "./lfs/memoryEngine";
+export type { LfsMessage, LfsLane, MemoryChunk, SessionStoreState, PrepareStepInput, PrepareStepOutput, } from "./lfs/types";
+export type { AdaptiveMessage } from "./lfs/tokenCounter";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AACxD,YAAY,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AACnE,OAAO,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AACxD,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAChD,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,EACL,UAAU,EACV,cAAc,EACd,sBAAsB,EACtB,0BAA0B,GAC3B,MAAM,cAAc,CAAC;AACtB,OAAO,EACL,uBAAuB,EACvB,uBAAuB,EACvB,2BAA2B,EAC3B,mBAAmB,GACpB,MAAM,qBAAqB,CAAC;AAC7B,YAAY,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,EAAE,uBAAuB,EAAE,gBAAgB,EAAE,YAAY,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;AACpH,OAAO,EAAE,sBAAsB,EAAE,2BAA2B,EAAE,MAAM,0BAA0B,CAAC;AAC/F,OAAO,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AAClE,OAAO,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AAClE,OAAO,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AACtD,YAAY,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAC3D,OAAO,EAAE,gBAAgB,EAAE,oBAAoB,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAC1F,OAAO,EAAE,qBAAqB,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAC/E,YAAY,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAC9D,OAAO,EAAE,8BAA8B,EAAE,MAAM,sBAAsB,CAAC;AACtE,OAAO,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAC1D,OAAO,EAAE,0BAA0B,EAAE,yBAAyB,EAAE,MAAM,4BAA4B,CAAC;AACnG,OAAO,EAAE,gBAAgB,EAAE,oBAAoB,EAAE,yBAAyB,EAAE,MAAM,cAAc,CAAC;AACjG,YAAY,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AACrD,OAAO,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAC;AAC/D,YAAY,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAC5E,OAAO,EAAE,iBAAiB,EAAE,sBAAsB,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAClG,OAAO,EACL,gBAAgB,EAChB,yBAAyB,EACzB,0BAA0B,EAC1B,mBAAmB,GACpB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,gBAAgB,EAChB,iBAAiB,EACjB,YAAY,EACZ,qBAAqB,EACrB,gBAAgB,EAChB,qBAAqB,EACrB,sBAAsB,GACvB,MAAM,gBAAgB,CAAC;AACxB,YAAY,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAClD,OAAO,EACL,sBAAsB,EACtB,+BAA+B,EAC/B,kBAAkB,EAClB,qBAAqB,EACrB,uBAAuB,EACvB,wBAAwB,EACxB,sBAAsB,EACtB,wBAAwB,EACxB,qBAAqB,EACrB,gBAAgB,EAChB,qCAAqC,EACrC,uBAAuB,EACvB,wBAAwB,EACxB,uBAAuB,GACxB,MAAM,oBAAoB,CAAC;AAC5B,YAAY,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAC7D,YAAY,EACV,UAAU,EACV,OAAO,EACP,WAAW,EACX,iBAAiB,EACjB,gBAAgB,EAChB,iBAAiB,GAClB,MAAM,aAAa,CAAC;AACrB,YAAY,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/index.js

@@ -0,0 +1,22 @@
+export { createLfsAgent } from "./agent/createLfsAgent";
+export { TOOL_LOOP_DEFAULTS } from "./agent/loopConfig";
+export { runLfsTurn } from "./agent/runLfsTurn";
+export { LfsContextAdapter } from "./lfs/contextAdapter";
+export { LFS_CONFIG, LFS_MEMORY_CAP, clampMemoryCapFraction, effectiveMemoryCapFraction, } from "./lfs/config";
+export { resolveLfsRuntimeConfig, resolveLfsRuntimeWindow, clampMemoryPressureFraction, LFS_MEMORY_PRESSURE, } from "./lfs/runtimeConfig";
+export { getOrCreateSessionState, clearAllSessions, clearSession, configureSessionStore } from "./lfs/sessionStore";
+export { formatForModelMessages, buildLfsMetadataSystemBlock } from "./history/formatForModel";
+export { formatHistoryForModel } from "./history/messageManifest";
+export { fromDoryCodeMessageV2 } from "./history/dorycodeAdapter";
+export { createToolRegistry } from "./tools/registry";
+export { createRemindTool, buildLfsRemindClause, hydrateLfsTarget } from "./tools/remind";
+export { createSkillLoaderTool, loadSkillMarkdown } from "./tools/skillLoader";
+export { createAgentSdkProviderRegistry } from "./providers/registry";
+export { createOllamaProvider } from "./providers/ollama";
+export { deriveAdaptiveCoefficients, calculateDynamicMemoryCap } from "./lfs/adaptiveCoefficients";
+export { validateFetchUrl, getFetchUrlAllowlist, MCP_TOOL_RESULT_MAX_CHARS } from "./mcp/config";
+export { determineExecutionLane } from "./lfs/preflightRouter";
+export { executeParitySwap, compileSkeletalHistory, calculateUtility } from "./lfs/paritySwapper";
+export { chunkMessageTurn, calculateDynamicChunkSize, calculateDynamicFrameLimit, identifyContentType, } from "./lfs/chunkManager";
+export { clearVectorCache, upsertChunkVector, upsertVector, queryChunkVectorCache, queryVectorCache, setChunkArchiveStatus, generateLocalEmbedding, } from "./lfs/vectorDb";
+export { applyAgenticStepMemory, applyHydrationDisplacementDecay, applyUserSendDecay, calculateCreditBudget, calculateCreditBudgetV2, calculateTargetMemoryCap, findActiveTurnAnchorId, findPredecessorMessageId, getNormalizedPressure, getPressureRatio, initializeForgetScoresMidConversation, isConversationalMessage, suggestMemoryCapFraction, validateAndApplyCredits, } from "./lfs/memoryEngine";

package/dist/lfs/adaptiveCoefficients.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @deprecated Use suggestMemoryCapFraction for UI hints only.
+ */
+export declare function calculateDynamicMemoryCap(contextMax: number): number;
+export declare function deriveAdaptiveCoefficients(contextMax: number, options?: {
+    memoryCapFraction?: number;
+}): {
+    decayBaseline: number;
+    alpha: number;
+    cMax: number;
+    hardBufferCap: number;
+};
+//# sourceMappingURL=adaptiveCoefficients.d.ts.map

package/dist/lfs/adaptiveCoefficients.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adaptiveCoefficients.d.ts","sourceRoot":"","sources":["../../src/lfs/adaptiveCoefficients.ts"],"names":[],"mappings":"AAGA;;GAEG;AACH,wBAAgB,yBAAyB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAEpE;AAED,wBAAgB,0BAA0B,CACxC,UAAU,EAAE,MAAM,EAClB,OAAO,CAAC,EAAE;IAAE,iBAAiB,CAAC,EAAE,MAAM,CAAA;CAAE,GACvC;IACD,aAAa,EAAE,MAAM,CAAC;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,MAAM,CAAC;CACvB,CAOA"}

package/dist/lfs/adaptiveCoefficients.js

@@ -0,0 +1,16 @@
+import { effectiveMemoryCapFraction, LFS_MEMORY_CAP } from './config';
+import { suggestMemoryCapFraction } from './memoryEngine';
+/**
+ * @deprecated Use suggestMemoryCapFraction for UI hints only.
+ */
+export function calculateDynamicMemoryCap(contextMax) {
+    return suggestMemoryCapFraction(contextMax);
+}
+export function deriveAdaptiveCoefficients(contextMax, options) {
+    const decayBaseline = Math.min(0.35, Math.max(0.005, 1.2 / (contextMax / 800)));
+    const alpha = 0.35;
+    const cMax = Math.round(100 * Math.pow(contextMax / 4000, 0.55));
+    const uiCap = options?.memoryCapFraction ?? LFS_MEMORY_CAP.DEFAULT;
+    const hardBufferCap = effectiveMemoryCapFraction(uiCap);
+    return { decayBaseline, alpha, cMax, hardBufferCap };
+}

package/dist/lfs/attenuationCompiler.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Compiles a soft attenuation frame from text content.
+ * Extracts functions, classes, important variable assignments, keys, and specific configurations,
+ * formatted as "Schema: [entry1, entry2, ...]" restricted to a ~25 token budget.
+ *
+ * @param text          - Raw chunk content to summarise.
+ * @param maxFrameTokens - Token budget for the frame (default 25).
+ * @param stepIndex     - Optional positional sequence tag prepended as "[Step N] ".
+ *                        Deducted from the entry budget so the total never exceeds maxFrameTokens.
+ */
+export declare function compileAttenuationFrame(text: string, maxFrameTokens?: number, stepIndex?: number): string;
+/**
+ * Asynchronous compilation of attenuation frame.
+ */
+export declare function compileAttenuationFrameAsync(text: string, maxFrameTokens?: number, stepIndex?: number): Promise<string>;
+//# sourceMappingURL=attenuationCompiler.d.ts.map

package/dist/lfs/attenuationCompiler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attenuationCompiler.d.ts","sourceRoot":"","sources":["../../src/lfs/attenuationCompiler.ts"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,MAAM,EACZ,cAAc,SAAK,EACnB,SAAS,CAAC,EAAE,MAAM,GACjB,MAAM,CA0HR;AAED;;GAEG;AACH,wBAAsB,4BAA4B,CAChD,IAAI,EAAE,MAAM,EACZ,cAAc,SAAK,EACnB,SAAS,CAAC,EAAE,MAAM,GACjB,OAAO,CAAC,MAAM,CAAC,CAEjB"}

package/dist/lfs/attenuationCompiler.js

@@ -0,0 +1,123 @@
+import { estimateTextTokens } from './tokenCounter';
+/**
+ * Compiles a soft attenuation frame from text content.
+ * Extracts functions, classes, important variable assignments, keys, and specific configurations,
+ * formatted as "Schema: [entry1, entry2, ...]" restricted to a ~25 token budget.
+ *
+ * @param text          - Raw chunk content to summarise.
+ * @param maxFrameTokens - Token budget for the frame (default 25).
+ * @param stepIndex     - Optional positional sequence tag prepended as "[Step N] ".
+ *                        Deducted from the entry budget so the total never exceeds maxFrameTokens.
+ */
+export function compileAttenuationFrame(text, maxFrameTokens = 25, stepIndex) {
+    if (!text || !text.trim()) {
+        return 'Schema: []';
+    }
+    const lines = text.split('\n');
+    const entriesSet = new Set();
+    // Heuristic patterns
+    const classRegex = /class\s+([a-zA-Z0-9_]+)/;
+    const funcRegexes = [
+        /(?:async\s+)?function\s+([a-zA-Z0-9_]+)/,
+        /const\s+([a-zA-Z0-9_]+)\s*=\s*(?:\([^)]*\)|[a-zA-Z0-9_]+)\s*=>/,
+        /def\s+([a-zA-Z0-9_]+)/,
+        /fn\s+([a-zA-Z0-9_]+)/,
+        /func\s+([a-zA-Z0-9_]+)/
+    ];
+    const needleRegex = /\b(KEY_[A-Z0-9_]+)\b/;
+    const assignmentRegex = /\b([a-zA-Z_][a-zA-Z0-9_-]*)\s*=\s*(.+)/;
+    const flagRegex = /--([a-zA-Z0-9_-]+)=([a-zA-Z0-9_-]+)/;
+    // Specific patterns for benchmark needles
+    const otelRegex = /\b(otel\/opentelemetry-collector-contrib:[a-zA-Z0-9_.-]+)\b/;
+    const sentinelRegex = /\b([a-zA-Z0-9_.-]*sentinel[a-zA-Z0-9_.-]*:[0-9]+)\b/;
+    for (let line of lines) {
+        line = line.trim();
+        // Ignore pure comments
+        if (line.startsWith('//') || line.startsWith('#') || line.startsWith('/*') || line.startsWith('*')) {
+            continue;
+        }
+        // 1. Check for specific needles first (like KEY_X9Y2Z)
+        const needleMatch = line.match(needleRegex);
+        if (needleMatch) {
+            entriesSet.add(needleMatch[1]);
+        }
+        // 2. Check for OTEL or Redis sentinel strings
+        const otelMatch = line.match(otelRegex);
+        if (otelMatch) {
+            entriesSet.add(otelMatch[1]);
+        }
+        const sentinelMatch = line.match(sentinelRegex);
+        if (sentinelMatch) {
+            entriesSet.add(sentinelMatch[1]);
+        }
+        // 3. Check for command-line flags
+        const flagMatch = line.match(flagRegex);
+        if (flagMatch) {
+            entriesSet.add(`${flagMatch[1]}=${flagMatch[2]}`);
+        }
+        // 4. Check for classes
+        const classMatch = line.match(classRegex);
+        if (classMatch) {
+            entriesSet.add(`class ${classMatch[1]}`);
+        }
+        // 5. Check for functions
+        for (const reg of funcRegexes) {
+            const funcMatch = line.match(reg);
+            if (funcMatch) {
+                entriesSet.add(`fn ${funcMatch[1]}()`);
+                break;
+            }
+        }
+        // 6. Check for assignments (e.g. PG_POOL_SIZE = 120, x = y)
+        const assignMatch = line.match(assignmentRegex);
+        if (assignMatch) {
+            const lhs = assignMatch[1];
+            let rhs = assignMatch[2].trim();
+            // Remove trailing semicolon if present
+            if (rhs.endsWith(';')) {
+                rhs = rhs.slice(0, -1).trim();
+            }
+            // Check if RHS is a simple literal/value (no complex brackets, reasonably short)
+            const isSimpleRhs = rhs.length <= 40 &&
+                !rhs.includes('{') &&
+                !rhs.includes('}') &&
+                !rhs.includes('(') &&
+                !rhs.includes(')') &&
+                !rhs.includes('[') &&
+                !rhs.includes(']');
+            if (isSimpleRhs) {
+                // Strip quotes around strings
+                if ((rhs.startsWith("'") && rhs.endsWith("'")) || (rhs.startsWith('"') && rhs.endsWith('"'))) {
+                    rhs = rhs.slice(1, -1);
+                }
+                entriesSet.add(`${lhs}=${rhs}`);
+            }
+        }
+    }
+    const prefix = stepIndex != null ? `[Step ${stepIndex}] ` : '';
+    const prefixTokens = stepIndex != null ? estimateTextTokens(prefix) : 0;
+    const adjustedBudget = Math.max(5, maxFrameTokens - prefixTokens);
+    // Build the attenuation frame incrementally to stay within adjustedBudget tokens
+    const selectedEntries = [];
+    for (const entry of entriesSet) {
+        const candidateEntries = [...selectedEntries, entry];
+        const candidateFrame = `Schema: [${candidateEntries.join(', ')}]`;
+        const tokens = estimateTextTokens(candidateFrame);
+        if (tokens > adjustedBudget) {
+            // If adding this entry exceeds adjustedBudget tokens, we stop adding more
+            if (selectedEntries.length === 0) {
+                // Ensure we include at least one entry if possible, even if it barely exceeds adjustedBudget tokens
+                selectedEntries.push(entry);
+            }
+            break;
+        }
+        selectedEntries.push(entry);
+    }
+    return `${prefix}Schema: [${selectedEntries.join(', ')}]`;
+}
+/**
+ * Asynchronous compilation of attenuation frame.
+ */
+export async function compileAttenuationFrameAsync(text, maxFrameTokens = 25, stepIndex) {
+    return Promise.resolve(compileAttenuationFrame(text, maxFrameTokens, stepIndex));
+}

package/dist/lfs/chunkManager.d.ts

@@ -0,0 +1,6 @@
+import { MemoryChunk } from './tokenCounter';
+export declare function calculateDynamicChunkSize(contextMax: number): number;
+export declare function calculateDynamicFrameLimit(chunkTokens: number): number;
+export declare function chunkMessageTurn(messageId: string, rawContent: string, maxChunkTokens?: number, turnIndex?: number): MemoryChunk[];
+export declare function identifyContentType(content: string): 'code' | 'tool_log' | 'text';
+//# sourceMappingURL=chunkManager.d.ts.map

package/dist/lfs/chunkManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunkManager.d.ts","sourceRoot":"","sources":["../../src/lfs/chunkManager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAGjE,wBAAgB,yBAAyB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAMpE;AAED,wBAAgB,0BAA0B,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAGtE;AAED,wBAAgB,gBAAgB,CAC9B,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,cAAc,SAAM,EACpB,SAAS,SAAI,GACZ,WAAW,EAAE,CA+Ff;AAED,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,UAAU,GAAG,MAAM,CAsCjF"}

package/dist/lfs/chunkManager.js

@@ -0,0 +1,142 @@
+import { estimateTextTokens } from './tokenCounter';
+import { compileAttenuationFrame } from './attenuationCompiler';
+export function calculateDynamicChunkSize(contextMax) {
+    if (contextMax <= 10000)
+        return 400;
+    // Logarithmic scaling bound between 400 and 2048 tokens
+    const scaledSize = Math.floor(400 * (1 + Math.log(contextMax / 10000)));
+    return Math.min(Math.max(scaledSize, 400), 2048);
+}
+export function calculateDynamicFrameLimit(chunkTokens) {
+    const scaled = Math.round(25 + Math.max(0, chunkTokens - 400) * 0.0625);
+    return Math.min(Math.max(scaled, 25), 128);
+}
+export function chunkMessageTurn(messageId, rawContent, maxChunkTokens = 400, turnIndex = 0) {
+    if (!rawContent || !rawContent.trim()) {
+        return [];
+    }
+    // 1. Split content by code block starts to protect logic units from truncation
+    const rawSegments = rawContent.split(/(?=```)/g);
+    const segments = [];
+    // 2. Further split any segments that are excessively long to prevent token overflow
+    for (const seg of rawSegments) {
+        if (estimateTextTokens(seg) <= maxChunkTokens) {
+            segments.push(seg);
+        }
+        else {
+            // Split by newline to preserve line boundaries
+            const lines = seg.split('\n');
+            let currentSubSeg = '';
+            for (const line of lines) {
+                const lineWithNL = line + '\n';
+                if (estimateTextTokens(currentSubSeg + lineWithNL) <= maxChunkTokens) {
+                    currentSubSeg += lineWithNL;
+                }
+                else {
+                    if (currentSubSeg) {
+                        segments.push(currentSubSeg);
+                    }
+                    currentSubSeg = lineWithNL;
+                    // If a single line itself exceeds the max tokens, we slice it by words
+                    if (estimateTextTokens(currentSubSeg) > maxChunkTokens) {
+                        const words = currentSubSeg.split(/\s+/);
+                        let part = '';
+                        for (const word of words) {
+                            const proposed = part ? part + ' ' + word : word;
+                            if (estimateTextTokens(proposed) <= maxChunkTokens) {
+                                part = proposed;
+                            }
+                            else {
+                                if (part)
+                                    segments.push(part);
+                                part = word;
+                            }
+                        }
+                        currentSubSeg = part;
+                    }
+                }
+            }
+            if (currentSubSeg) {
+                segments.push(currentSubSeg);
+            }
+        }
+    }
+    // 3. Group consecutive segments up to maxChunkTokens
+    const chunks = [];
+    let chunkContent = '';
+    let chunkIndex = 0;
+    for (const seg of segments) {
+        const proposedContent = chunkContent ? chunkContent + '\n' + seg : seg;
+        if (estimateTextTokens(proposedContent) <= maxChunkTokens) {
+            chunkContent = proposedContent;
+        }
+        else {
+            if (chunkContent) {
+                const tokenCount = estimateTextTokens(chunkContent);
+                const frameLimit = calculateDynamicFrameLimit(tokenCount);
+                const chunkType = identifyContentType(chunkContent);
+                chunks.push({
+                    chunkId: `${messageId}_chunk_${chunkIndex++}`,
+                    parentMessageId: messageId,
+                    content: chunkContent,
+                    tokenCount,
+                    isArchived: false,
+                    attenuationFrame: compileAttenuationFrame(chunkContent, frameLimit),
+                    type: chunkType,
+                    lastReferencedTurn: turnIndex,
+                });
+            }
+            chunkContent = seg;
+        }
+    }
+    if (chunkContent) {
+        const tokenCount = estimateTextTokens(chunkContent);
+        const frameLimit = calculateDynamicFrameLimit(tokenCount);
+        const chunkType = identifyContentType(chunkContent);
+        chunks.push({
+            chunkId: `${messageId}_chunk_${chunkIndex++}`,
+            parentMessageId: messageId,
+            content: chunkContent,
+            tokenCount,
+            isArchived: false,
+            attenuationFrame: compileAttenuationFrame(chunkContent, frameLimit),
+            type: chunkType,
+            lastReferencedTurn: turnIndex,
+        });
+    }
+    return chunks;
+}
+export function identifyContentType(content) {
+    const contentLower = content.toLowerCase();
+    // Heuristics for terminal tool logs and build outputs
+    const logPatterns = [
+        /^\s*(?:\$ |> |npm |pnpm |yarn |pip |python3? |git |cargo |docker )/mi,
+        /\b(info|warning|warn|error|debug|trace|stderr|stdout)\b/i,
+        /error/i, // Catch TypeError, etc. without strict word boundaries
+        /\b(tests? passed|failed|assertions?|spec|test suite|coverage)\b/i,
+        /\bat\s+.*:[0-9]+:[0-9]+/i, // JS stack trace line
+        /traceback \(most recent call last\):/i, // Python traceback
+        /\b(untracked files:|changes not staged for commit:|changes to be committed:)\b/i, // Git status
+        /\b(package\.json|node_modules|pnpm-lock\.yaml|package-lock\.json)\b/i,
+        /\b(resolved |installed |fetched |downloaded |compiling |building |bundled )\b/i,
+    ];
+    let matches = 0;
+    for (const pattern of logPatterns) {
+        if (pattern.test(content)) {
+            matches++;
+        }
+    }
+    if (matches >= 2 || (matches >= 1 && contentLower.includes('stack_trace_line_dump'))) {
+        return 'tool_log';
+    }
+    // Heuristics for code files
+    const codePatterns = [
+        /\b(function|const|let|var|class|import|export|require|return|def|fn|impl|struct|enum|public|private)\b/,
+        /[\{\}\[\]\(\)=;:,\.\!\?\-\+\*\/&\|<>]/
+    ];
+    const isCode = codePatterns.every(p => p.test(content));
+    if (isCode && !contentLower.includes('terminal') && !contentLower.includes('command line')) {
+        return 'code';
+    }
+    return 'text';
+}

package/dist/lfs/config.d.ts

@@ -0,0 +1,23 @@
+export declare const LFS_CONFIG: {
+    BYPASS_THRESHOLD: number;
+    PREFLIGHT_PASS_THRU_THRESHOLD: number;
+    DECAY_BASELINE_FACTOR: number;
+    ALPHA_MASS_PENALTY: number;
+    /** When UI memory cap is 100%, effective eviction cap uses this fraction of contextMax. */
+    PHYSICAL_FIREBREAK: number;
+    NATIVE_CONTEXT_FRACTION: number;
+    LFS_API_SEND_FRACTION: number;
+    OUTPUT_RESERVE_FRACTION: number;
+    OUTPUT_RESERVE_FLOOR: number;
+    OUTPUT_RESERVE_CEILING: number;
+};
+export declare const LFS_MEMORY_CAP: {
+    readonly DEFAULT: 0.7;
+    readonly MIN: 0.5;
+    readonly MAX: 0.99;
+};
+export declare function clampMemoryCapFraction(fraction: number): number;
+/** UI 100% maps to PHYSICAL_FIREBREAK so provider wrappers never hit hard truncation. */
+export declare function effectiveMemoryCapFraction(uiFraction: number): number;
+export declare function computeOutputReserveTokens(contextMax: number): number;
+//# sourceMappingURL=config.d.ts.map

package/dist/lfs/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/lfs/config.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,UAAU;;;;;IAKrB,2FAA2F;;;;;;;CAO5F,CAAC;AAEF,eAAO,MAAM,cAAc;;;;CAIjB,CAAC;AAEX,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAE/D;AAED,yFAAyF;AACzF,wBAAgB,0BAA0B,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAOrE;AAED,wBAAgB,0BAA0B,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAMrE"}