#1 Persistent memory for AI coding agents based on real-world benchmarks
TypeScript agentmemoryagentsaiclaudeclaudecodecodexcopilotcursorgenaiharnesshermesmemoryompopenclawopencodepi
fix(release): close three v0.9.24 regressions before v0.9.25
Rohit Ghumareaa386b788457
diff --git a/src/functions/replay.ts b/src/functions/replay.tsindex 25ccc439..e44ca8cc 100644--- a/src/functions/replay.ts+++ b/src/functions/replay.ts@@ -406,7 +406,17 @@ export function registerReplayFunctions(sdk: ISdk, kv: StateKV): void {if (!existing.firstPrompt && firstPrompt) {existing.firstPrompt = firstPrompt;}- await kv.set(KV.sessions, existing.id, existing);+ // #775: re-key on parsed.sessionId, not existing.id. Older+ // session rows may be missing the `id` field; existing.id+ // would then be undefined, JSON.stringify would drop the+ // `key` from the state::set payload, and the engine would+ // reject the call with `missing field \`key\``. Because the+ // rejection aborts the whole import handler, a single+ // legacy row killed the entire batch. parsed.sessionId is+ // always populated (parseJsonlText has a three-level+ // fallback) and is what we just used to read the row.+ if (!existing.id) existing.id = parsed.sessionId;+ await kv.set(KV.sessions, parsed.sessionId, existing);} else {const session: Session = {id: parsed.sessionId,diff --git a/src/functions/summarize.ts b/src/functions/summarize.tsindex 80b29a09..4c501ca8 100644--- a/src/functions/summarize.ts+++ b/src/functions/summarize.ts@@ -184,13 +184,33 @@ async function produceSummaryXml(return { response, mode: "chunked", chunks: chunks.length, skipped };}+// #783: many LLMs (DeepSeek, GPT variants, some Anthropic responses)+// wrap structured XML in markdown code fences or add conversational+// text before/after. Strip those wrappers before the tag regex so a+// well-formed summary doesn't get silently dropped as parse_failed.+function stripXmlWrappers(raw: string): string {+ if (!raw) return "";+ let cleaned = raw.trim();+ // ```xml ... ``` or ``` ... ``` fences (anywhere in the payload).+ cleaned = cleaned.replace(/```\s*xml\s*\n?/gi, "");+ cleaned = cleaned.replace(/```/g, "");+ cleaned = cleaned.trim();+ // If preamble / postamble surrounds the XML root, peel it off.+ const rootMatch = cleaned.match(+ /(<[a-zA-Z_][a-zA-Z0-9_-]*>[\s\S]*<\/[a-zA-Z_][a-zA-Z0-9_-]*>)/,+ );+ if (rootMatch && rootMatch[1]) return rootMatch[1].trim();+ return cleaned;+}+function parseSummaryXml(xml: string,sessionId: string,project: string,obsCount: number,): SessionSummary | null {- const title = getXmlTag(xml, "title");+ const cleaned = stripXmlWrappers(xml);+ const title = getXmlTag(cleaned, "title");if (!title) return null;return {@@ -198,10 +218,10 @@ function parseSummaryXml(project,createdAt: new Date().toISOString(),title,- narrative: getXmlTag(xml, "narrative"),- keyDecisions: getXmlChildren(xml, "decisions", "decision"),- filesModified: getXmlChildren(xml, "files", "file"),- concepts: getXmlChildren(xml, "concepts", "concept"),+ narrative: getXmlTag(cleaned, "narrative"),+ keyDecisions: getXmlChildren(cleaned, "decisions", "decision"),+ filesModified: getXmlChildren(cleaned, "files", "file"),+ concepts: getXmlChildren(cleaned, "concepts", "concept"),observationCount: obsCount,};}@@ -253,41 +273,59 @@ export function registerSummarizeFunction(}try {- const { response, mode, chunks } = await produceSummaryXml(- provider,- compressed,- sessionId,- session.project,- );+ // #783: chunk-level produceSummaryXml retries internally, but+ // the final merge used to parse once and bail. Wrap the+ // produce-and-parse pair in the same 2-attempt loop so a+ // markdown-wrapped or otherwise wrapped response gets a+ // second roll-of-the-dice instead of dropping the summary.+ let summary: SessionSummary | null = null;+ let response = "";+ let mode = "single";+ let chunks = 1;+ for (let attempt = 1; attempt <= 2; attempt++) {+ const produced = await produceSummaryXml(+ provider,+ compressed,+ sessionId,+ session.project,+ );+ response = produced.response;+ mode = produced.mode;+ chunks = produced.chunks;+ if (!response || !response.trim()) {+ logger.warn("Empty provider response on summarize", {+ sessionId,+ provider: provider.name,+ mode,+ chunks,+ observationCount: compressed.length,+ attempt,+ });+ continue;+ }+ summary = parseSummaryXml(+ response,+ sessionId,+ session.project,+ compressed.length,+ );+ if (summary) break;+ logger.warn("Failed to parse summary XML", { sessionId, attempt });+ }+if (!response || !response.trim()) {const latencyMs = Date.now() - startMs;if (metricsStore) {await metricsStore.record("mem::summarize", latencyMs, false);}- logger.warn("Empty provider response on summarize", {- sessionId,- provider: provider.name,- mode,- chunks,- observationCount: compressed.length,- });return { success: false, error: "empty_provider_response" };}- const summary = parseSummaryXml(- response,- sessionId,- session.project,- compressed.length,- );if (!summary) {const latencyMs = Date.now() - startMs;if (metricsStore) {await metricsStore.record("mem::summarize", latencyMs, false);}- logger.warn("Failed to parse summary XML", {- sessionId,- });return { success: false, error: "parse_failed" };}diff --git a/src/providers/index.ts b/src/providers/index.tsindex 5de6807c..0ec3feba 100644--- a/src/providers/index.ts+++ b/src/providers/index.ts@@ -25,6 +25,35 @@ function requireEnvVar(key: string): string {return value;}+// #778: fallback providers used to inherit the primary provider's+// model name (e.g. fallback Gemini was called with `gpt-4o-mini`),+// 404'd every call, and tripped the circuit breaker — making+// FALLBACK_PROVIDERS actively worse than no fallback. Each provider+// must resolve its OWN env-driven default model. Mirrors the resolution+// in detectProvider() so primary + fallback agree on what each+// provider's default model is.+function defaultModelFor(providerType: ProviderConfig["provider"]): string {+ switch (providerType) {+ case "openai":+ return getEnvVar("OPENAI_MODEL") || "gpt-4o-mini";+ case "anthropic":+ return getEnvVar("ANTHROPIC_MODEL") || "claude-sonnet-4-20250514";+ case "gemini":+ return getEnvVar("GEMINI_MODEL") || "gemini-2.5-flash";+ case "openrouter":+ return (+ getEnvVar("OPENROUTER_MODEL") || "anthropic/claude-sonnet-4-20250514"+ );+ case "minimax":+ return getEnvVar("MINIMAX_MODEL") || "MiniMax-M2.7";+ case "agent-sdk":+ return "claude-sonnet-4-20250514";+ case "noop":+ default:+ return "noop";+ }+}+export function createProvider(config: ProviderConfig): ResilientProvider {return new ResilientProvider(createBaseProvider(config));}@@ -41,9 +70,14 @@ export function createFallbackProvider(for (const providerType of fallbackConfig.providers) {if (providerType === config.provider) continue;try {+ // #778: resolve the fallback's OWN default model (or its env+ // override) rather than copying config.model from the primary.+ // Without this, FALLBACK_PROVIDERS=gemini on an OpenAI primary+ // would call Gemini with `gpt-4o-mini`, get a 404 every time,+ // and trip the circuit breaker.const fbConfig: ProviderConfig = {provider: providerType,- model: config.model,+ model: defaultModelFor(providerType),maxTokens: config.maxTokens,};providers.push(createBaseProvider(fbConfig));diff --git a/test/fallback-model-resolution.test.ts b/test/fallback-model-resolution.test.tsnew file mode 100644index 00000000..91a82116--- /dev/null+++ b/test/fallback-model-resolution.test.ts@@ -0,0 +1,190 @@+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";++// #778: fallback providers used to inherit the primary provider's+// model name and 404 on every call. Each fallback must resolve its+// own env-driven default model.++const captured: Array<{ provider: string; model: string }> = [];++vi.mock("../src/providers/openai.js", () => ({+ OpenAIProvider: class {+ name = "openai";+ constructor(_key: string, model: string) {+ captured.push({ provider: "openai", model });+ }+ async compress() {+ return "";+ }+ async summarize() {+ return "";+ }+ },+}));++vi.mock("../src/providers/openrouter.js", () => ({+ OpenRouterProvider: class {+ name = "openrouter";+ constructor(_key: string, model: string, _max: number, url?: string) {+ captured.push({+ provider: url?.includes("googleapis") ? "gemini" : "openrouter",+ model,+ });+ }+ async compress() {+ return "";+ }+ async summarize() {+ return "";+ }+ },+}));++vi.mock("../src/providers/anthropic.js", () => ({+ AnthropicProvider: class {+ name = "anthropic";+ constructor(_key: string, model: string) {+ captured.push({ provider: "anthropic", model });+ }+ async compress() {+ return "";+ }+ async summarize() {+ return "";+ }+ },+}));++vi.mock("../src/providers/minimax.js", () => ({+ MinimaxProvider: class {+ name = "minimax";+ constructor(_key: string, model: string) {+ captured.push({ provider: "minimax", model });+ }+ async compress() {+ return "";+ }+ async summarize() {+ return "";+ }+ },+}));++import { createFallbackProvider } from "../src/providers/index.js";+import type { ProviderConfig, FallbackConfig } from "../src/types.js";++describe("Fallback provider model resolution (#778)", () => {+ const savedEnv: Record<string, string | undefined> = {};+ const envKeys = [+ "OPENAI_API_KEY",+ "OPENAI_MODEL",+ "GEMINI_API_KEY",+ "GEMINI_MODEL",+ "GOOGLE_API_KEY",+ "ANTHROPIC_API_KEY",+ "ANTHROPIC_MODEL",+ "OPENROUTER_API_KEY",+ "OPENROUTER_MODEL",+ "MINIMAX_API_KEY",+ "MINIMAX_MODEL",+ ];++ beforeEach(() => {+ captured.length = 0;+ for (const k of envKeys) {+ savedEnv[k] = process.env[k];+ delete process.env[k];+ }+ });++ afterEach(() => {+ for (const k of envKeys) {+ if (savedEnv[k] === undefined) delete process.env[k];+ else process.env[k] = savedEnv[k];+ }+ });++ it("primary OpenAI + fallback Gemini: Gemini is built with GEMINI_MODEL, NOT the primary's model", () => {+ process.env.OPENAI_API_KEY = "sk-openai";+ process.env.GEMINI_API_KEY = "gemini-key";+ process.env.GEMINI_MODEL = "gemini-2.5-flash";++ const primary: ProviderConfig = {+ provider: "openai",+ model: "gpt-4o-mini",+ maxTokens: 4096,+ };+ const fallback: FallbackConfig = { providers: ["gemini"] };++ createFallbackProvider(primary, fallback);++ const openaiCall = captured.find((c) => c.provider === "openai");+ const geminiCall = captured.find((c) => c.provider === "gemini");+ expect(openaiCall?.model).toBe("gpt-4o-mini");+ expect(geminiCall?.model).toBe("gemini-2.5-flash");+ expect(geminiCall?.model).not.toBe("gpt-4o-mini");+ });++ it("Gemini fallback uses the documented default when GEMINI_MODEL is unset", () => {+ process.env.OPENAI_API_KEY = "sk-openai";+ process.env.GEMINI_API_KEY = "gemini-key";++ createFallbackProvider(+ { provider: "openai", model: "gpt-4o-mini", maxTokens: 4096 },+ { providers: ["gemini"] },+ );++ const geminiCall = captured.find((c) => c.provider === "gemini");+ expect(geminiCall?.model).toBe("gemini-2.5-flash");+ });++ it("primary Anthropic + fallback OpenAI + Minimax: each fallback uses its own default", () => {+ process.env.ANTHROPIC_API_KEY = "anth-key";+ process.env.OPENAI_API_KEY = "openai-key";+ process.env.OPENAI_MODEL = "gpt-5";+ process.env.MINIMAX_API_KEY = "mini-key";++ createFallbackProvider(+ {+ provider: "anthropic",+ model: "claude-sonnet-4-20250514",+ maxTokens: 4096,+ },+ { providers: ["openai", "minimax"] },+ );++ const openai = captured.find((c) => c.provider === "openai");+ const minimax = captured.find((c) => c.provider === "minimax");+ expect(openai?.model).toBe("gpt-5");+ expect(minimax?.model).toBe("MiniMax-M2.7");+ // Neither inherits the Anthropic model name.+ expect(openai?.model).not.toBe("claude-sonnet-4-20250514");+ expect(minimax?.model).not.toBe("claude-sonnet-4-20250514");+ });++ it("env override on the fallback provider's MODEL var wins over the default", () => {+ process.env.OPENAI_API_KEY = "sk";+ process.env.GEMINI_API_KEY = "gk";+ process.env.GEMINI_MODEL = "gemini-2.5-pro";++ createFallbackProvider(+ { provider: "openai", model: "gpt-4o-mini", maxTokens: 4096 },+ { providers: ["gemini"] },+ );++ expect(captured.find((c) => c.provider === "gemini")?.model).toBe(+ "gemini-2.5-pro",+ );+ });++ it("fallback that matches the primary provider is skipped (no duplicate)", () => {+ process.env.OPENAI_API_KEY = "sk";++ createFallbackProvider(+ { provider: "openai", model: "gpt-4o-mini", maxTokens: 4096 },+ { providers: ["openai", "gemini"] },+ );++ const openaiCalls = captured.filter((c) => c.provider === "openai");+ expect(openaiCalls.length).toBe(1);+ });+});diff --git a/test/replay-import-key.test.ts b/test/replay-import-key.test.tsnew file mode 100644index 00000000..9a4c6467--- /dev/null+++ b/test/replay-import-key.test.ts@@ -0,0 +1,154 @@+import { describe, it, expect, beforeEach, vi } from "vitest";+import { mkdtempSync, writeFileSync, rmSync } from "node:fs";+import { tmpdir } from "node:os";+import { join } from "node:path";++vi.mock("../src/logger.js", () => ({+ logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },+}));++import { registerReplayFunctions } from "../src/functions/replay.js";+import { KV } from "../src/state/schema.js";++function mockKV() {+ const store = new Map<string, Map<string, unknown>>();+ const setCalls: Array<{ scope: string; key: string | undefined; value: any }> = [];+ return {+ get: async <T>(scope: string, key: string): Promise<T | null> =>+ (store.get(scope)?.get(key) as T) ?? null,+ set: async <T>(scope: string, key: string, value: T): Promise<T> => {+ setCalls.push({ scope, key, value });+ if (!store.has(scope)) store.set(scope, new Map());+ // Mirror the engine: a state::set with key=undefined fails. We+ // surface this via setCalls so the test can assert key !== undefined.+ if (key === undefined) {+ throw new Error("missing field `key`");+ }+ store.get(scope)!.set(key, value);+ return value;+ },+ delete: async (scope: string, key: string) => {+ store.get(scope)?.delete(key);+ },+ list: async <T>(scope: string): Promise<T[]> =>+ Array.from(store.get(scope)?.values() ?? []) as T[],+ getSetCalls: () => setCalls,+ };+}++function mockSdk(kv: ReturnType<typeof mockKV>) {+ const fns = new Map<string, Function>();+ return {+ registerFunction: (id: string, handler: Function) => fns.set(id, handler),+ registerTrigger: () => {},+ trigger: async (+ idOrInput: string | { function_id: string; payload?: unknown },+ data?: unknown,+ ) => {+ const id =+ typeof idOrInput === "string" ? idOrInput : idOrInput.function_id;+ const payload =+ typeof idOrInput === "string" ? data : (idOrInput as any).payload;+ const fn = fns.get(id);+ if (!fn) return { success: true };+ return fn(payload);+ },+ _kv: kv,+ } as any;+}++describe("import-jsonl re-key on parsed.sessionId (#775)", () => {+ let tmpRoot: string;++ beforeEach(() => {+ tmpRoot = mkdtempSync(join(tmpdir(), "replay-import-key-"));+ });++ function writeFixture(sessionId: string, ts = "2026-04-17T10:00:00.000Z") {+ const dir = join(tmpRoot, "proj");+ rmSync(dir, { recursive: true, force: true });+ require("node:fs").mkdirSync(dir, { recursive: true });+ const lines = [+ JSON.stringify({+ type: "user",+ uuid: "u1",+ sessionId,+ timestamp: ts,+ cwd: tmpRoot,+ message: {+ role: "user",+ content: [{ type: "text", text: "hello" }],+ },+ }),+ JSON.stringify({+ type: "assistant",+ uuid: "a1",+ sessionId,+ timestamp: ts,+ message: {+ role: "assistant",+ content: [{ type: "text", text: "world" }],+ },+ }),+ ];+ writeFileSync(join(dir, `${sessionId}.jsonl`), lines.join("\n") + "\n");+ }++ it("re-imports a session whose stored row is missing the `id` field without aborting the batch", async () => {+ writeFixture("sess-no-id");+ const kv = mockKV();+ const sdk = mockSdk(kv);+ registerReplayFunctions(sdk, kv as never);++ // Seed an existing session row that is MISSING `id` — the+ // pre-fix code would re-key on `existing.id` (undefined) and+ // throw `missing field \`key\``, aborting the whole import.+ await kv.set(KV.sessions, "sess-no-id", {+ project: "proj",+ cwd: tmpRoot,+ startedAt: "2026-04-17T09:00:00Z",+ endedAt: "2026-04-17T09:30:00Z",+ status: "completed",+ observationCount: 2,+ tags: [],+ });++ const result = (await sdk.trigger("mem::replay::import-jsonl", {+ path: tmpRoot,+ })) as { success: boolean; imported?: number; error?: string };++ expect(result.success).toBe(true);+ expect(result.imported).toBe(1);++ const undefinedKeyWrites = kv+ .getSetCalls()+ .filter((c) => c.scope === KV.sessions && c.key === undefined);+ expect(undefinedKeyWrites.length).toBe(0);++ const sessionWrites = kv+ .getSetCalls()+ .filter((c) => c.scope === KV.sessions && c.key === "sess-no-id");+ expect(sessionWrites.length).toBeGreaterThan(0);+ // The handler also backfills the missing id field so future reads+ // are well-formed.+ expect((sessionWrites.at(-1)!.value as any).id).toBe("sess-no-id");+ });++ it("fresh import (no existing row) still writes session keyed by parsed.sessionId", async () => {+ writeFixture("sess-fresh");+ const kv = mockKV();+ const sdk = mockSdk(kv);+ registerReplayFunctions(sdk, kv as never);++ const result = (await sdk.trigger("mem::replay::import-jsonl", {+ path: tmpRoot,+ })) as { success: boolean; imported?: number };++ expect(result.success).toBe(true);+ expect(result.imported).toBe(1);+ const sessionWrites = kv+ .getSetCalls()+ .filter((c) => c.scope === KV.sessions && c.key === "sess-fresh");+ expect(sessionWrites.length).toBe(1);+ });+});diff --git a/test/summarize.test.ts b/test/summarize.test.tsindex 03aa1926..4723da87 100644--- a/test/summarize.test.ts+++ b/test/summarize.test.ts@@ -414,4 +414,69 @@ describe("mem::summarize chunking", () => {// Reduce is a single call so doesn't bump it.expect(maxInflight).toBe(2);});++ // #783: markdown-wrapped XML used to silently fail parsing because+ // the tag regex looked for <title> in the raw payload. stripXmlWrappers+ // now peels ```xml ... ``` fences and conversational pre/postamble+ // before the regex runs.+ it("parses a summary even when the LLM wraps XML in markdown fences", async () => {+ const wrappedXml = "Here's the summary:\n```xml\n" + summaryXml({+ title: "wrapped",+ narrative: "n",+ decisions: ["d1"],+ files: ["src/a.ts"],+ concepts: ["c1"],+ }) + "\n```\nLet me know if you need anything else.";+ const provider = makeProvider([wrappedXml]);+ const { handler, kv } = await setupHandler({+ sessionId: "ses_md",+ obsCount: 1,+ provider,+ });++ const result: any = await handler({ sessionId: "ses_md" });++ expect(result.success).toBe(true);+ expect(result.summary.title).toBe("wrapped");+ const stored = await kv.get("summaries", "ses_md");+ expect((stored as any).title).toBe("wrapped");+ });++ it("retries the final summarize once on first-attempt parse failure", async () => {+ // First call returns garbage (no <title>), second returns valid XML.+ // The chunk-level retry is bypassed for a 1-obs session (no chunking),+ // so this exercises the new final-summarize retry path.+ const provider = makeProvider([+ "not xml, just a sentence with no tags",+ summaryXml({ title: "second-attempt" }),+ ]);+ const { handler } = await setupHandler({+ sessionId: "ses_retry",+ obsCount: 1,+ provider,+ });++ const result: any = await handler({ sessionId: "ses_retry" });++ expect(result.success).toBe(true);+ expect(result.summary.title).toBe("second-attempt");+ expect((provider as any).calls.length).toBeGreaterThanOrEqual(2);+ });++ it("returns parse_failed only after both attempts fail", async () => {+ const provider = makeProvider([+ "garbage one",+ "garbage two",+ ]);+ const { handler } = await setupHandler({+ sessionId: "ses_fail",+ obsCount: 1,+ provider,+ });++ const result: any = await handler({ sessionId: "ses_fail" });++ expect(result.success).toBe(false);+ expect(result.error).toBe("parse_failed");+ });});