auto-model-router 0.2.13 → 0.2.14

package/.omp-plugin/marketplace.json

@@ -7,14 +7,14 @@
   },
   "metadata": {
     "description": "auto-model-router: a local cost/complexity-aware model router for Oh My Pi, backed by OpenRouter",
-    "version": "0.2.13",
+    "version": "0.2.14",
     "pluginRoot": "."
   },
   "plugins": [
     {
       "name": "auto-model-router",
       "description": "Local cost/complexity-aware model router for Oh My Pi, backed by OpenRouter. Runs in-process, routes per turn by price and task complexity, with budget caps, mid-stream escalation, and cache-aware hysteresis.",
-      "version": "0.2.13",
+      "version": "0.2.14",
       "author": {
         "name": "drewappling",
         "email": "drewappling@gmail.com"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "auto-model-router",
-  "version": "0.2.13",
+  "version": "0.2.14",
   "private": false,
   "description": "Local cost/complexity-aware model router for Oh My Pi, backed by OpenRouter",
   "type": "module",

package/src/config/defaults.ts

@@ -161,6 +161,15 @@ export const DEFAULT_CONFIG: RouterConfig = {
 		// faster than the server reassembles buys nothing but cache misses.
 		maxStalenessMs: 900_000,
 		maxBlockChars: 24_000,
+		// Bound what agentdox SELECTS, rather than letting the block grow and then
+		// slicing it at `maxBlockChars`. Byte truncation cuts an entry mid-sentence
+		// and is blind to relevance; a limit lets the server rank first. Left
+		// unbounded, this scope reached 15 memory entries = 23.5k chars (~5.9k
+		// tokens) injected into every turn, against a 24k cap it was about to hit.
+		memoryLimit: 8,
+		// Session messages are cheap today but grow once recordTurns is on, and
+		// they feed straight back into the next assembly.
+		sessionLimit: 6,
 		recordTurns: true,
 		maxQueue: 64,
 	},

package/src/config/schema.ts

@@ -138,6 +138,8 @@ const context = z.strictObject({
 	timeoutMs: z.number().int().positive().optional(),
 	maxStalenessMs: z.number().int().nonnegative().optional(),
 	maxBlockChars: z.number().int().positive().optional(),
+	memoryLimit: z.number().int().positive().optional(),
+	sessionLimit: z.number().int().nonnegative().optional(),
 	recordTurns: z.boolean().optional(),
 	maxQueue: z.number().int().positive().optional(),
 });

package/src/config/types.ts

@@ -372,6 +372,10 @@ export interface ContextConfig {
 	maxStalenessMs: number;
 	/** Hard cap on injected block size, characters. */
 	maxBlockChars: number;
+	/** Max memory entries agentdox may select for the block. */
+	memoryLimit: number;
+	/** Max recent session messages agentdox may select for the block. */
+	sessionLimit: number;
 	/** Write settled turns back to agentdox sessions, tagged with the served model. */
 	recordTurns: boolean;
 	/** Bound on queued write-backs; excess turns are dropped, never buffered unbounded. */

package/src/context/agentdox.ts

@@ -15,13 +15,19 @@ export interface AgentDoxClientOptions {
 	log: Logger;
 }
 
+/** Bounds on what agentdox may select for one block. */
+export interface AssembleLimits {
+	memoryLimit: number;
+	sessionLimit: number;
+}
+
 export interface AgentDoxClient {
 	/**
 	 * Assembles a context slice for `scope`, biased by `query`. Falls back to
 	 * the server's pre-assembled baseline when assembly is unavailable (older
 	 * server, or no query-relevant content).
 	 */
-	assemble(scope: string, query: string): Promise<string | null>;
+	assemble(scope: string, query: string, limits: AssembleLimits): Promise<string | null>;
 	createSession(scope: string, title: string): Promise<string | null>;
 	append(sessionId: string, role: "user" | "assistant", content: string, refs: string[]): Promise<boolean>;
 }
@@ -75,8 +81,15 @@ export function createAgentDoxClient(opts: AgentDoxClientOptions): AgentDoxClien
 	};
 
 	return {
-		async assemble(scope, query) {
-			const res = await request("POST", "/context/assemble", { scope, query });
+		async assemble(scope, query, limits) {
+			// camelCase: the REST endpoint ignores snake_case limit keys entirely,
+			// which silently reads as "unbounded".
+			const res = await request("POST", "/context/assemble", {
+				scope,
+				query,
+				memoryLimit: limits.memoryLimit,
+				sessionLimit: limits.sessionLimit,
+			});
 			if (res !== null && res.status === 200) {
 				const prompt = promptOf(res.json);
 				if (prompt !== null) return prompt;

package/src/context/bridge.ts

@@ -30,6 +30,13 @@ export interface BridgeOptions {
 	maxStalenessMs: number;
 	/** Hard cap on injected block size; a runaway context must not dominate the prompt. */
 	maxBlockChars: number;
+	/**
+	 * Bounds on what agentdox SELECTS. Preferred over `maxBlockChars`, which can
+	 * only slice bytes: the server ranks by relevance, so a limit drops the least
+	 * useful entry instead of severing whatever straddles the cap.
+	 */
+	memoryLimit: number;
+	sessionLimit: number;
 	/** Record settled turns back into agentdox sessions. */
 	recordTurns: boolean;
 	/** Bound on queued write-backs; excess is dropped rather than grown unbounded. */
@@ -73,7 +80,7 @@ function appendFragment(prior: string, next: string): string {
 }
 
 export function createContextBridge(opts: BridgeOptions): ContextBridge {
-	const { client, store, log, maxStalenessMs, maxBlockChars, recordTurns, maxQueue } = opts;
+	const { client, store, log, maxStalenessMs, maxBlockChars, memoryLimit, sessionLimit, recordTurns, maxQueue } = opts;
 
 	// Serialized write-back queue. Session appends for one conversation must
 	// stay ordered, and agentdox is a local service — one worker is plenty.
@@ -111,7 +118,7 @@ export function createContextBridge(opts: BridgeOptions): ContextBridge {
 				return { ...pinned, fetchedAtMs: input.pinnedFetchedAtMs };
 			}
 
-			const raw = await client.assemble(input.scope, input.query);
+			const raw = await client.assemble(input.scope, input.query, { memoryLimit, sessionLimit });
 			if (raw === null) {
 				// agentdox unreachable or empty. Keep serving the pinned block if we
 				// have one: stale shared context beats none, and re-using it also

package/src/context/index.ts

@@ -27,6 +27,8 @@ export function createBridgeFromConfig(cfg: RouterConfig, db: Database): Context
 		log,
 		maxStalenessMs: c.maxStalenessMs,
 		maxBlockChars: c.maxBlockChars,
+		memoryLimit: c.memoryLimit,
+		sessionLimit: c.sessionLimit,
 		recordTurns: c.recordTurns,
 		maxQueue: c.maxQueue,
 	});

package/test/context-bridge.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, test } from "bun:test";
 
-import type { AgentDoxClient } from "../src/context/agentdox.ts";
+import type { AgentDoxClient, AssembleLimits } from "../src/context/agentdox.ts";
 import { createContextBridge } from "../src/context/bridge.ts";
 import { createContextStore } from "../src/context/store.ts";
 import type { ContextResolveInput, TurnRecord } from "../src/context/types.ts";
@@ -15,16 +15,19 @@ interface FakeClient extends AgentDoxClient {
 	appended: { sessionId: string; role: string; content: string; refs: string[] }[];
 	sessionsCreated: number;
 	prompt: string;
+	lastLimits: AssembleLimits | null;
 }
 
 function mkClient(prompt = "MEMORY: player digs in 3/4 top-down"): FakeClient {
 	const c: FakeClient = {
 		assembleCalls: 0,
+		lastLimits: null,
 		appended: [],
 		sessionsCreated: 0,
 		prompt,
-		async assemble() {
+		async assemble(_scope, _query, limits) {
 			c.assembleCalls++;
+			c.lastLimits = limits;
 			return c.prompt;
 		},
 		async createSession() {
@@ -49,6 +52,8 @@ function mkBridge(client: AgentDoxClient, over: Partial<BridgeOpts> = {}) {
 		log,
 		maxStalenessMs: 900_000,
 		maxBlockChars: 24_000,
+		memoryLimit: 8,
+		sessionLimit: 6,
 		recordTurns: true,
 		maxQueue: 64,
 		...over,
@@ -89,6 +94,22 @@ describe("context bridge refresh policy", () => {
 		}
 	});
 
+	test("assembly is bounded, so the block cannot grow until bytes get severed", async () => {
+		// The block reached 23.5k chars (~5.9k tokens, 15 memory entries) against a
+		// 24k maxBlockChars cap, at which point renderBlock slices mid-entry. Byte
+		// truncation is blind to relevance, so the server must be told to rank and
+		// select instead. The REST endpoint ignores snake_case limit keys, which
+		// silently reads as unbounded — hence pinning that the limits are passed.
+		const client = mkClient();
+		const { bridge, db } = mkBridge(client, { memoryLimit: 5, sessionLimit: 2 });
+		try {
+			await bridge.resolve(input());
+			expect(client.lastLimits).toEqual({ memoryLimit: 5, sessionLimit: 2 });
+		} finally {
+			db.close();
+		}
+	});
+
 	test("refreshes when the model switches, because the cache is already forfeit", async () => {
 		const client = mkClient();
 		const { bridge, db } = mkBridge(client);
@@ -217,6 +238,8 @@ describe("context bridge refresh policy", () => {
 				log,
 				maxStalenessMs: 900_000,
 				maxBlockChars: 24_000,
+				memoryLimit: 8,
+				sessionLimit: 6,
 				recordTurns: true,
 				maxQueue: 64,
 			};

package/test/failover.test.ts

@@ -69,7 +69,7 @@ function mkConfig(escalation: Partial<EscalationConfig> = {}): RouterConfig {
 		hysteresis: { holdTurns: 2, holdTurnsAfterEscalation: 4, switchMargin: 1.5, cacheWarmTtlMs: 600_000, maxDowngradePerTurn: 1 },
 		exploration: { enabled: false, rates: {}, stickyPolicy: "never", holdTurns: { enabled: false, values: [2, 3, 4] } },
 		cache: { injectBreakpoints: true, maxBreakpoints: 4, minPromptTokens: 1024, milestoneTokens: 20_000 },
-		context: { enabled: false, baseUrl: "", token: "", defaultScope: "", timeoutMs: 3_000, maxStalenessMs: 900_000, maxBlockChars: 24_000, recordTurns: false, maxQueue: 64 },
+		context: { enabled: false, baseUrl: "", token: "", defaultScope: "", timeoutMs: 3_000, maxStalenessMs: 900_000, maxBlockChars: 24_000, memoryLimit: 8, sessionLimit: 6, recordTurns: false, maxQueue: 64 },
 		compaction: { enabled: false, budgetTokens: 40_000, fitToWindow: true, protectRecentTurns: 4, maxToolResultBytes: 4_096, keepHeadBytes: 512, keepTailBytes: 512, elideSupersededReads: true, collapseDuplicateResults: true },
 		budget: { onExceeded: "downgrade" },
 		profiles: [],

package/test/turn.test.ts

@@ -70,7 +70,7 @@ function mkConfig(escalation: Partial<EscalationConfig> = {}): RouterConfig {
 		hysteresis: { holdTurns: 2, holdTurnsAfterEscalation: 4, switchMargin: 1.5, cacheWarmTtlMs: 600_000, maxDowngradePerTurn: 1 },
 		exploration: { enabled: false, rates: {}, stickyPolicy: "never", holdTurns: { enabled: false, values: [2, 3, 4] } },
 		cache: { injectBreakpoints: true, maxBreakpoints: 4, minPromptTokens: 1024, milestoneTokens: 20_000 },
-		context: { enabled: false, baseUrl: "", token: "", defaultScope: "", timeoutMs: 3_000, maxStalenessMs: 900_000, maxBlockChars: 24_000, recordTurns: false, maxQueue: 64 },
+		context: { enabled: false, baseUrl: "", token: "", defaultScope: "", timeoutMs: 3_000, maxStalenessMs: 900_000, maxBlockChars: 24_000, memoryLimit: 8, sessionLimit: 6, recordTurns: false, maxQueue: 64 },
 		compaction: { enabled: false, budgetTokens: 40_000, fitToWindow: true, protectRecentTurns: 4, maxToolResultBytes: 4_096, keepHeadBytes: 512, keepTailBytes: 512, elideSupersededReads: true, collapseDuplicateResults: true },
 		budget: { onExceeded: "downgrade" },
 		profiles: [],