@dory-agentic/dory-agentic-sdk 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Dory Agentic
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,331 @@
+<p align="center">
+  <strong>Dory Agentic SDK</strong><br/>
+  <em>Long-running agents that never forget the plot.</em>
+</p>
+
+<p align="center">
+  <code>@dory-agentic/dory-agentic-sdk</code>
+</p>
+
+---
+
+## The story of a session that would not end
+
+Imagine you pair with an agent on a real project. Not a five-message demo, but a **long session**. You explore a repo, run tools, fix tests, argue about architecture, ship a patch, then ask a question that depends on something you said **two hours ago**.
+
+Most agent stacks treat context like a fixed-size backpack. Every new turn adds weight. Eventually something has to fall out: old instructions, a failing test log, the variable name you agreed on in message twelve. The model does not get angry. It simply **stops seeing** what mattered.
+
+**Dory Agentic SDK** exists for that moment.
+
+We built **Long-Form Session (LFS)**, a virtual memory layer that sits between your agent loop and the model. The full conversation still lives in a session store, but **what the model sees on each call is curated dynamically**: expanded when there is room, compressed when pressure rises, and restorable when the agent needs the exact words again.
+
+You keep the long story. The model keeps a window it can actually think inside.
+
+### Proof at million-token scale
+
+On **AgencyBench V2** (GAIR/AgencyBench, ACL 2026), six scenarios were run with **~1M tokens** of agent history each (Backend and Code domains, `gemini-2.5-flash-lite`). Native Gemini hit **context truncation** on every run. With LFS v4.6:
+
+| Metric | Native Gemini | LFS v4.6 |
+|--------|---------------|----------|
+| Avg rubric score | 93.7 / 100 | **99.7 / 100** (+6.0) |
+| Avg latency | 25.6s | **19.0s** (~26% faster) |
+| Success rate | 6 / 6 | 6 / 6 |
+| Tokens per call (typical) | ~1.42M (truncated) | ~720K (managed) |
+
+Standout case: **Code scenario 3** scored **80/100** natively vs **100/100** with LFS (+20), after **524 parity swaps** and a **memory reflection** that hydrated **9 archived chunks** back into active context. Backend and Code category averages moved from **96.3** and **91.0** to **99.3** and **100.0** respectively.
+
+That is the story in numbers: the session stays long, the window stays honest, and the agent can still find the needle.
+
+---
+
+## The long session problem
+
+After dozens of turns, three forces collide:
+
+1. **Volume**: code, tool output, and reasoning traces pile up faster than anyone summarizes them.
+2. **A hard ceiling**: every model has a context limit; you cannot paste infinity into one call.
+3. **Silent loss**: naive truncation drops the wrong messages: not always the oldest, not always the least important.
+
+![The long session problem: chat timeline grows while the context window fills to 100%](docs/images/infographic-01-the-problem.png)
+
+That is the gap we address. Not by pretending the window is bigger, but by **managing it like memory**.
+
+---
+
+## What changes with LFS
+
+| Without dynamic context | With Dory Agentic SDK |
+|-------------------------|------------------------|
+| One growing blob sent every call | A **session store** plus a **prepared view** per step |
+| Old turns vanish unpredictably | Low-utility chunks **archive** with labeled placeholders |
+| Agent cannot recover detail | **`remind`** tool hydrates exact text when needed |
+| Same policy at turn 3 and turn 300 | **Preflight routing**: light path when calm, full MMU when pressured |
+
+![Before and after: lost context vs organized active and archived memory](docs/images/infographic-03-before-after.png)
+
+### Benefits for builders
+
+- **Hours-long sessions**: coding agents, support bots, research assistants that accumulate real history.
+- **Dynamic context window**: fill ratio is monitored every model round; eviction tracks relevance, recency, and agent credit scores, not arbitrary cutoffs.
+- **Tool-loop native**: built on the AI SDK `ToolLoopAgent`; LFS runs in `prepareStep` before each inference, so every tool call sees a fresh, budgeted prompt.
+- **Production-minded**: path-safe skill loading, MCP lifecycle disposal, SSRF guards, session cache bounds.
+- **Two lanes**: `standard` for baseline comparison; `optimized` for the full memory manager.
+
+---
+
+## How the agent scores messages (and what gets forgotten)
+
+LFS does not delete history. It **ranks** it every turn so the least useful material leaves the active window first, while the full session remains in storage.
+
+![Scoring and long-term memory: utility, forgetScore, and archive path](docs/images/infographic-04-scoring-and-long-memory.png)
+
+### Step 1: Chunk and index
+
+Large user turns and tool output are split into **chunks**. Each chunk is embedded in a lightweight vector index so the current user query can retrieve semantically related pieces.
+
+### Step 2: Utility score (what to keep in focus)
+
+For each chunk, LFS computes **utility** from the current query:
+
+```
+U = β · S_rel + (1 − β) · W_agent
+```
+
+| Symbol | Meaning |
+|--------|---------|
+| **S_rel** | Semantic similarity between the chunk and the active query (vector retrieval) |
+| **W_agent** | Agent-assigned credit weight (what the model marked as important via the scoring manifest) |
+| **β** | Blend factor (default 0.5): balance retrieval vs agent judgment |
+
+**forgetScore** is derived as `1 − U`. Low forgetScore means “keep near the model.” High forgetScore means “safe to archive.”
+
+### Step 3: Temporal decay (what drifts toward archive)
+
+Even strong chunks age unless the agent keeps using them:
+
+- Each turn, **decay** increases forgetScore for conversational messages (mass-aware: larger messages decay faster under pressure).
+- **CODE_ASSET** chunks get a short **shield** when referenced within the last few turns, then fade exponentially as the task moves on.
+- **TOOL_LOG** chunks are penalized first under pressure (noisy logs leave before core instructions).
+- **Hydrated** chunks (brought back via `remind` or reflection) get a **grace period** with forgetScore pinned to 0.
+
+When forgetScore reaches **1.0**, the message is a candidate for **displacement**: content moves to **long-term memory** and the active window shows a compact, labeled placeholder.
+
+### Step 4: Parity swap into long-term memory
+
+When projected tokens exceed the **memory cap** (default **70%** of `contextMax`, tunable from 50% to 99%):
+
+1. Chunks are sorted by utility (lowest first).
+2. Lowest-utility **active** chunks are marked `isArchived` and copied to **`longTermMemory`**.
+3. The model still sees **where** something went (ids, summaries, manifest), not a silent hole.
+4. The agent can call **`remind`** or trigger a **reflection** to pull exact text back (AgencyBench run: 9 chunks hydrated in one Code scenario).
+
+**Credit budget** scales with window size: under pressure the model receives a bounded number of scoring credits so it must declare what it relied on, which feeds **W_agent** on later turns.
+
+---
+
+## How it works (every model call)
+
+Think of each turn as a **flight check**:
+
+1. **Merge** new messages into the session.
+2. **Preflight**: if projected tokens stay below ~50% of the window, take the fast **PASS_THRU** lane; otherwise engage **ELASTIC_SWAP** and the memory manager.
+3. **Chunk** large user content and index it for similarity search.
+4. **Score and swap**: parity swap ranks chunks by utility (semantic match + agent weights + decay); the least useful leave the window first.
+5. **Budget credits**: under pressure, the model receives a scoring budget and manifest metadata so it cites what it actually used.
+6. **Format**: only then does the prompt go to the model, wrapped, labeled, and honest about what is archived.
+
+![LFS flow: session store → preflight → chunk → vector match → parity swap → dynamic context](docs/images/infographic-02-lfs-flow.png)
+
+```mermaid
+flowchart LR
+  subgraph store [Session]
+    History[fullHistory]
+    LTM[longTermMemory]
+    Weights[agentWeights]
+  end
+
+  subgraph prepare [prepareStep on every tool call]
+    Router[preflightRouter]
+    Chunk[chunkManager]
+    Vector[vectorDb]
+    Parity[paritySwapper]
+    Engine[memoryEngine]
+    Format[formatForModel]
+  end
+
+  History --> Router
+  Router --> Chunk --> Vector --> Parity --> Engine --> Format
+  Parity --> LTM
+  Format --> Model[(Language model)]
+```
+
+The agent loop (tools, streaming, cancellation) stays in the AI SDK. **LFS only decides what the model reads.**
+
+---
+
+## A day in the life (narrative walkthrough)
+
+**Turn 1 to 5: Plenty of space.**  
+Preflight returns `PASS_THRU`. The model sees the conversation almost as-is. LFS is quiet; you pay almost no overhead.
+
+**Turn 40: A fat log arrives.**  
+Tool output pushes projected tokens past the threshold. LFS switches to `ELASTIC_SWAP`, chunks the new material, and starts scoring older messages. Anything irrelevant drifts toward archive summaries: still named, still addressable, no longer eating tokens.
+
+**Turn 41: The agent needs the exact error line.**  
+It calls `remind` with a message or chunk id. The SDK pulls the raw text back from long-term storage into active context for that step. Surgical, not a full replay of history.
+
+**Turn 200: Still the same session id.**  
+`createLfsAgent` and `LfsContextAdapter` share one session store. Memory cap fraction (default **70%**, tunable **50% to 99%**) tells LFS how aggressively to keep the window below the physical limit before the provider truncates.
+
+That is the innovation: **context as a managed resource**, not a static string.
+
+---
+
+## Install
+
+```bash
+npm install @dory-agentic/dory-agentic-sdk
+```
+
+Monorepo / local development:
+
+```bash
+npm install file:../dory-agentic-sdk
+```
+
+```json
+{
+  "dependencies": {
+    "@dory-agentic/dory-agentic-sdk": "file:../dory-agentic-sdk"
+  }
+}
+```
+
+---
+
+## Quick start
+
+### Full agent (tool loop + LFS)
+
+```typescript
+import { createLfsAgent, createOllamaProvider } from "@dory-agentic/dory-agentic-sdk";
+
+const ollama = createOllamaProvider();
+const model = ollama("qwen2.5-coder:7b");
+
+const agent = await createLfsAgent({
+  sessionId: "project-alpha",
+  lane: "optimized",
+  model,
+  contextMax: 32768,
+  memoryCapFraction: 0.7,
+});
+
+// Use agent.toolLoopAgent with your AI SDK patterns, then:
+await agent.dispose();
+```
+
+### Prepare context only (bring your own loop)
+
+```typescript
+import { LfsContextAdapter } from "@dory-agentic/dory-agentic-sdk";
+
+const adapter = new LfsContextAdapter();
+const prepared = await adapter.prepareStep({
+  sessionId: "project-alpha",
+  lane: "optimized",
+  incomingMessages: history,
+  replaceSessionHistory: true,
+  contextMax: 32768,
+  memoryCapFraction: 0.7,
+  useRemindTool: true,
+});
+
+// prepared.messagesForModel → send to your model
+// prepared.isMmuActive, prepared.executionLane → observability
+```
+
+### One-shot helper
+
+```typescript
+import { runLfsTurn } from "@dory-agentic/dory-agentic-sdk";
+
+const result = await runLfsTurn({
+  sessionId: "bench-1",
+  lane: "optimized",
+  incomingMessages: messages,
+  replaceSessionHistory: true,
+  contextMax: 8192,
+});
+```
+
+---
+
+## Core concepts
+
+| Concept | Meaning |
+|---------|---------|
+| **Session store** | Canonical history, archived chunks, forget scores, agent weights |
+| **Utility / forgetScore** | Rank for retention; archive when pressure forces lowest-U chunks out |
+| **PASS_THRU** | Low pressure; minimal memory management |
+| **ELASTIC_SWAP** | High pressure; chunking, parity swap, credit budget active |
+| **Memory cap fraction** | How full LFS allows the window to get before aggressive eviction (50% to 99%) |
+| **longTermMemory** | Archived chunks keyed by id; placeholders stay in the active manifest |
+| **remind** | Tool to hydrate archived content back into active context |
+| **Lanes** | `standard` (baseline) vs `optimized` (full LFS) |
+
+---
+
+## Configuration
+
+| Variable | Purpose |
+|----------|---------|
+| `OLLAMA_BASE_URL` | Base URL for Ollama integration tests |
+| `DORY_AGENTIC_SKILLS_ROOT` | Allowed directory root for `skillLoader` |
+| `DORY_AGENTIC_MCP_FETCH_ALLOWLIST` | Comma-separated host allowlist for fetch MCP URLs |
+| `MCP_FETCH_URL_ALLOWLIST` | Alias for the above |
+
+---
+
+## Development
+
+```bash
+npm install
+npm run typecheck
+npm run test:unit      # fast, no network
+npm run test:ollama    # optional; needs local Ollama
+npm run build
+```
+
+---
+
+## Architecture (repository layout)
+
+```
+src/
+  agent/          createLfsAgent, runLfsTurn, ToolLoopAgent wiring
+  lfs/            preflight, chunking, vector index, parity swap, memory engine
+  history/        manifest formatting for the model
+  tools/          remind, skillLoader, registry
+  mcp/            MCP client helpers
+  providers/      Ollama and provider registry
+```
+
+---
+
+## Related packages
+
+- **`@dory-agentic/dory-agentic-sdk`** (this repo): LFS virtual memory for AI SDK agent loops.
+- **`@dorycode-ai/sdk`**: separate HTTP client for the DoryCode server.
+
+---
+
+## License
+
+MIT. See [package.json](package.json).
+
+---
+
+<p align="center">
+  <sub>Built for agents that outlive the context window.</sub>
+</p>

package/dist/agent/createLfsAgent.d.ts

@@ -0,0 +1,27 @@
+import type { LanguageModel } from "ai";
+import { LfsContextAdapter } from "../lfs/contextAdapter";
+import type { LfsLane } from "../lfs/types";
+import { type ToolRegistryResult } from "../tools/registry";
+import type { SkillLoaderOptions } from "../tools/skillLoader";
+import type { SessionStoreState } from "../lfs/types";
+import type { McpClientOptions } from "../mcp/client";
+type CreateLfsAgentParams = {
+    sessionId: string;
+    lane: LfsLane;
+    model: LanguageModel;
+    contextMax: number;
+    memoryCapFraction?: number;
+    benchmarkSuite?: boolean;
+    mcp?: McpClientOptions;
+    skillLoader?: SkillLoaderOptions;
+};
+export type CreateLfsAgentResult = {
+    adapter: LfsContextAdapter;
+    session: SessionStoreState;
+    tools: ToolRegistryResult["tools"];
+    toolLoopAgent: unknown;
+    dispose: () => Promise<void>;
+};
+export declare function createLfsAgent(params: CreateLfsAgentParams): Promise<CreateLfsAgentResult>;
+export {};
+//# sourceMappingURL=createLfsAgent.d.ts.map

package/dist/agent/createLfsAgent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createLfsAgent.d.ts","sourceRoot":"","sources":["../../src/agent/createLfsAgent.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,IAAI,CAAC;AACxC,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAC1D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAC5C,OAAO,EAAsB,KAAK,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAChF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAE/D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AACtD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAGtD,KAAK,oBAAoB,GAAG;IAC1B,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,OAAO,CAAC;IACd,KAAK,EAAE,aAAa,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,GAAG,CAAC,EAAE,gBAAgB,CAAC;IACvB,WAAW,CAAC,EAAE,kBAAkB,CAAC;CAClC,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG;IACjC,OAAO,EAAE,iBAAiB,CAAC;IAC3B,OAAO,EAAE,iBAAiB,CAAC;IAC3B,KAAK,EAAE,kBAAkB,CAAC,OAAO,CAAC,CAAC;IACnC,aAAa,EAAE,OAAO,CAAC;IACvB,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC9B,CAAC;AAEF,wBAAsB,cAAc,CAAC,MAAM,EAAE,oBAAoB,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAiDhG"}

package/dist/agent/createLfsAgent.js

@@ -0,0 +1,51 @@
+import { LfsContextAdapter } from "../lfs/contextAdapter";
+import { createToolRegistry } from "../tools/registry";
+import { getOrCreateSessionState } from "../lfs/sessionStore";
+import { TOOL_LOOP_DEFAULTS } from "./loopConfig";
+export async function createLfsAgent(params) {
+    const adapter = new LfsContextAdapter();
+    const session = getOrCreateSessionState({
+        sessionId: params.sessionId,
+        contextMax: params.contextMax,
+        memoryCapFraction: params.memoryCapFraction,
+    });
+    const registry = await createToolRegistry({
+        session,
+        mcp: params.mcp,
+        skillLoader: params.skillLoader,
+    });
+    const aiModule = await import("ai");
+    const ToolLoopAgentCtor = aiModule
+        .ToolLoopAgent;
+    if (!ToolLoopAgentCtor) {
+        await registry.dispose();
+        throw new Error("ToolLoopAgent is unavailable in installed ai SDK version");
+    }
+    const toolLoopAgent = new ToolLoopAgentCtor({
+        model: params.model,
+        tools: registry.tools,
+        ...TOOL_LOOP_DEFAULTS,
+        prepareStep: async ({ messages, stepNumber }) => {
+            const prepared = await adapter.prepareStep({
+                sessionId: params.sessionId,
+                lane: params.lane,
+                incomingMessages: messages,
+                contextMax: params.contextMax,
+                memoryCapFraction: params.memoryCapFraction,
+                benchmarkSuite: params.benchmarkSuite,
+                stepNumber,
+            });
+            return {
+                messages: prepared.messagesForModel,
+                system: prepared.systemBlocks.join("\n\n"),
+            };
+        },
+    });
+    return {
+        adapter,
+        session,
+        tools: registry.tools,
+        toolLoopAgent,
+        dispose: registry.dispose,
+    };
+}

package/dist/agent/loopConfig.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Dory Agentic SDK intentionally uses the AI SDK ToolLoopAgent defaults.
+ * No custom stopWhen is set here by design.
+ */
+export declare const TOOL_LOOP_DEFAULTS: Readonly<{}>;
+//# sourceMappingURL=loopConfig.d.ts.map

package/dist/agent/loopConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loopConfig.d.ts","sourceRoot":"","sources":["../../src/agent/loopConfig.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,eAAO,MAAM,kBAAkB,cAAoB,CAAC"}

package/dist/agent/loopConfig.js

@@ -0,0 +1,5 @@
+/**
+ * Dory Agentic SDK intentionally uses the AI SDK ToolLoopAgent defaults.
+ * No custom stopWhen is set here by design.
+ */
+export const TOOL_LOOP_DEFAULTS = Object.freeze({});

package/dist/agent/runLfsTurn.d.ts

@@ -0,0 +1,10 @@
+import type { LanguageModel } from "ai";
+import type { PrepareStepInput, PrepareStepOutput } from "../lfs/types";
+import type { AdaptiveMessage } from "../lfs/tokenCounter";
+export type RunLfsTurnParams = Omit<PrepareStepInput, "incomingMessages"> & {
+    incomingMessages: AdaptiveMessage[];
+    model?: LanguageModel;
+};
+/** Prepare one LFS turn (messages + system blocks) without starting a tool loop. */
+export declare function runLfsTurn(params: RunLfsTurnParams): Promise<PrepareStepOutput>;
+//# sourceMappingURL=runLfsTurn.d.ts.map

package/dist/agent/runLfsTurn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runLfsTurn.d.ts","sourceRoot":"","sources":["../../src/agent/runLfsTurn.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,IAAI,CAAC;AAExC,OAAO,KAAK,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AACxE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAE3D,MAAM,MAAM,gBAAgB,GAAG,IAAI,CAAC,gBAAgB,EAAE,kBAAkB,CAAC,GAAG;IAC1E,gBAAgB,EAAE,eAAe,EAAE,CAAC;IACpC,KAAK,CAAC,EAAE,aAAa,CAAC;CACvB,CAAC;AAEF,oFAAoF;AACpF,wBAAsB,UAAU,CAAC,MAAM,EAAE,gBAAgB,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAiBrF"}

package/dist/agent/runLfsTurn.js

@@ -0,0 +1,20 @@
+import { LfsContextAdapter } from "../lfs/contextAdapter";
+/** Prepare one LFS turn (messages + system blocks) without starting a tool loop. */
+export async function runLfsTurn(params) {
+    const adapter = new LfsContextAdapter();
+    return adapter.prepareStep({
+        sessionId: params.sessionId,
+        lane: params.lane,
+        incomingMessages: params.incomingMessages,
+        contextMax: params.contextMax,
+        memoryCapFraction: params.memoryCapFraction,
+        benchmarkSuite: params.benchmarkSuite,
+        stepNumber: params.stepNumber,
+        query: params.query,
+        turnIndex: params.turnIndex,
+        agentWeights: params.agentWeights,
+        hydrationBeacon: params.hydrationBeacon,
+        enableReflection: params.enableReflection,
+        useRemindTool: params.useRemindTool,
+    });
+}

package/dist/history/dorycodeAdapter.d.ts

@@ -0,0 +1,16 @@
+import type { LfsMessage } from "../lfs/types";
+export type DoryCodeMessageV2Like = {
+    id: string;
+    role: "user" | "assistant" | "system" | "tool";
+    parts?: Array<{
+        type?: string;
+        text?: string;
+    }>;
+    content?: string;
+};
+/**
+ * Thin bridge module for future DoryCode MessageV2 integration.
+ * This intentionally keeps a shallow mapping only.
+ */
+export declare function fromDoryCodeMessageV2(message: DoryCodeMessageV2Like): LfsMessage;
+//# sourceMappingURL=dorycodeAdapter.d.ts.map

package/dist/history/dorycodeAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dorycodeAdapter.d.ts","sourceRoot":"","sources":["../../src/history/dorycodeAdapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE/C,MAAM,MAAM,qBAAqB,GAAG;IAClC,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,GAAG,WAAW,GAAG,QAAQ,GAAG,MAAM,CAAC;IAC/C,KAAK,CAAC,EAAE,KAAK,CAAC;QAAE,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAChD,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,qBAAqB,GAAG,UAAU,CAehF"}

package/dist/history/dorycodeAdapter.js

@@ -0,0 +1,18 @@
+/**
+ * Thin bridge module for future DoryCode MessageV2 integration.
+ * This intentionally keeps a shallow mapping only.
+ */
+export function fromDoryCodeMessageV2(message) {
+    const textFromParts = message.parts
+        ?.map((part) => (part.type === "text" || !part.type ? part.text ?? "" : ""))
+        .join("")
+        .trim() ?? "";
+    const content = message.content ?? textFromParts;
+    return {
+        id: message.id,
+        role: message.role,
+        content,
+        tokenCount: Math.max(1, Math.ceil(content.length / 4)),
+        isArchived: false,
+    };
+}

package/dist/history/formatForModel.d.ts

@@ -0,0 +1,19 @@
+import type { LfsLane } from "../lfs/types";
+import type { AdaptiveMessage } from "../lfs/tokenCounter";
+export declare function formatForModelMessages(params: {
+    history: AdaptiveMessage[];
+    systemPrompt: string;
+    lane: LfsLane;
+    budget?: number;
+    remindClause?: string;
+    isMmuActive?: boolean;
+}): Array<{
+    role: string;
+    content: string;
+}>;
+export declare function buildLfsMetadataSystemBlock(params: {
+    history: AdaptiveMessage[];
+    budget: number;
+    remindClause: string;
+}): string;
+//# sourceMappingURL=formatForModel.d.ts.map

package/dist/history/formatForModel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatForModel.d.ts","sourceRoot":"","sources":["../../src/history/formatForModel.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAC5C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAI3D,wBAAgB,sBAAsB,CAAC,MAAM,EAAE;IAC7C,OAAO,EAAE,eAAe,EAAE,CAAC;IAC3B,YAAY,EAAE,MAAM,CAAC;IACrB,IAAI,EAAE,OAAO,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB,GAAG,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC,CAO3C;AAED,wBAAgB,2BAA2B,CAAC,MAAM,EAAE;IAClD,OAAO,EAAE,eAAe,EAAE,CAAC;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,MAAM,CAAC;CACtB,GAAG,MAAM,CAWT"}

package/dist/history/formatForModel.js

@@ -0,0 +1,22 @@
+import { formatHistoryForModel as formatHistoryForModelFull } from "./messageManifest";
+import { buildRelevanceScoringInstructions } from "../lfs/memoryParser";
+export function formatForModelMessages(params) {
+    return formatHistoryForModelFull(params.history, params.systemPrompt, {
+        lane: params.lane,
+        budget: params.budget,
+        remindClause: params.remindClause,
+        isMmuActive: params.isMmuActive,
+    });
+}
+export function buildLfsMetadataSystemBlock(params) {
+    const scoringInstructions = buildRelevanceScoringInstructions({
+        budget: params.budget,
+        history: params.history,
+    });
+    return `[🚨 SYSTEM MEMORY METADATA & SCORING RULES]
+Active Credit Budget: ${params.budget} credits for this turn.
+
+${scoringInstructions}
+
+${params.remindClause}`;
+}

package/dist/history/lanes.d.ts

@@ -0,0 +1,3 @@
+import type { LfsLane } from "../lfs/types";
+export declare function isOptimizedLane(lane: LfsLane): boolean;
+//# sourceMappingURL=lanes.d.ts.map

package/dist/history/lanes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lanes.d.ts","sourceRoot":"","sources":["../../src/history/lanes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAE5C,wBAAgB,eAAe,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CAEtD"}

package/dist/history/lanes.js

@@ -0,0 +1,3 @@
+export function isOptimizedLane(lane) {
+    return lane === "optimized";
+}

package/dist/history/messageManifest.d.ts

@@ -0,0 +1,45 @@
+import type { AdaptiveMessage } from "../lfs/tokenCounter";
+import type { LfsLane } from "../lfs/types";
+/** Parse msg_01 / msg_1 / msg1 → 1. Returns null if not a msg_N id. */
+export declare function parseMsgNumber(id: string): number | null;
+/** User/assistant turns eligible for credit_allocation (excludes traces, tools, archived). */
+export declare function isScorableMessage(m: AdaptiveMessage): boolean;
+export type MessageManifestKind = 'conversation' | 'tool' | 'trace' | 'archived' | 'system';
+export type MessageManifestEntry = {
+    id: string;
+    role: string;
+    kind: MessageManifestKind;
+    /** 1-based index in the history array (oldest message = 1). Matches API send order. */
+    positionInHistory: number;
+    scorable: boolean;
+    /** 1-based index among scorable user/assistant only (oldest scorable = 1). */
+    conversationalIndex?: number;
+};
+export declare function classifyMessageKind(m: AdaptiveMessage): MessageManifestKind;
+/** Build manifest in strict history array order (oldest → newest). */
+export declare function buildMessageManifest(history: AdaptiveMessage[]): MessageManifestEntry[];
+export declare function collectScorableMessageIds(history: AdaptiveMessage[]): string[];
+/** Map msg number → canonical id (msg_01). One number must not map to two ids. */
+export declare function buildMsgNumberToIdMap(ids: Iterable<string>): Map<number, string>;
+export declare function resolveMessageId(rawId: string, activeIds: Set<string>, numberMap: Map<number, string>): string | null;
+export declare function formatMessageForApi(m: AdaptiveMessage, entry: MessageManifestEntry, totalScorable: number, isMmuActive?: boolean): {
+    role: string;
+    content: string;
+};
+export declare function formatHistoryForModel(history: AdaptiveMessage[], systemPrompt: string, opts?: {
+    lane?: LfsLane;
+    budget?: number;
+    remindClause?: string;
+    isMmuActive?: boolean;
+}): {
+    role: string;
+    content: string;
+}[];
+/** Agentic loop: history only (system prompt added separately). */
+export declare function formatAgenticHistoryForModel(history: AdaptiveMessage[]): {
+    role: string;
+    content: string;
+}[];
+/** Prompt block listing scorable IDs in the same order as the model sees them (oldest first). */
+export declare function formatScorableIdListForPrompt(history: AdaptiveMessage[]): string;
+//# sourceMappingURL=messageManifest.d.ts.map

package/dist/history/messageManifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"messageManifest.d.ts","sourceRoot":"","sources":["../../src/history/messageManifest.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAE3D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAE5C,uEAAuE;AACvE,wBAAgB,cAAc,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAKxD;AAED,8FAA8F;AAC9F,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,eAAe,GAAG,OAAO,CAI7D;AAED,MAAM,MAAM,mBAAmB,GAC3B,cAAc,GACd,MAAM,GACN,OAAO,GACP,UAAU,GACV,QAAQ,CAAC;AAEb,MAAM,MAAM,oBAAoB,GAAG;IACjC,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,mBAAmB,CAAC;IAC1B,uFAAuF;IACvF,iBAAiB,EAAE,MAAM,CAAC;IAC1B,QAAQ,EAAE,OAAO,CAAC;IAClB,8EAA8E;IAC9E,mBAAmB,CAAC,EAAE,MAAM,CAAC;CAC9B,CAAC;AAEF,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,eAAe,GAAG,mBAAmB,CAM3E;AAED,sEAAsE;AACtE,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,eAAe,EAAE,GAAG,oBAAoB,EAAE,CAcvF;AAED,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,eAAe,EAAE,GAAG,MAAM,EAAE,CAI9E;AAED,kFAAkF;AAClF,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,QAAQ,CAAC,MAAM,CAAC,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAUhF;AAED,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,GAAG,CAAC,MAAM,CAAC,EACtB,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAC7B,MAAM,GAAG,IAAI,CAKf;AACD,wBAAgB,mBAAmB,CACjC,CAAC,EAAE,eAAe,EAClB,KAAK,EAAE,oBAAoB,EAC3B,aAAa,EAAE,MAAM,EACrB,WAAW,CAAC,EAAE,OAAO,GACpB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAmCnC;AAED,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,eAAe,EAAE,EAC1B,YAAY,EAAE,MAAM,EACpB,IAAI,CAAC,EAAE;IACL,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB,GACA;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,EAAE,CA4GrC;AAED,mEAAmE;AACnE,wBAAgB,4BAA4B,CAC1C,OAAO,EAAE,eAAe,EAAE,GACzB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,EAAE,CAIrC;AAED,iGAAiG;AACjG,wBAAgB,6BAA6B,CAAC,OAAO,EAAE,eAAe,EAAE,GAAG,MAAM,CA8BhF"}