Address review: validate strategy output inside the failure path, default once in maybeCompact, reuse moduleSourceRefSchema, resolve relative imports in rule 54, distinct compaction recall in the fixture, document event model id

Signed-off-by: Rui Conti <ruiconti@gmail.com>

Author: ruiconti

docs/concepts/compaction-strategies.md

@@ -25,10 +25,12 @@ eve measures the next request, decides when compaction can run, and owns everyth
 | `shouldCompact(facts)`  | Whether the next request needs compacting, from the numbers eve measured. |
 | `compact(history, ctx)` | The messages that replace `history`.                                      |
 
-`facts` holds `inputTokens`, `requestEnvelopeTokens`, `threshold`, `recentWindowSize` and `reason`. A user-requested compaction (`reason: "manual"`) runs whatever `shouldCompact` returns. `history` is the conversation without memory records; eve places recalled memory ahead of the result, so a strategy never sees or reorders it. A user message you return needs a `kind`; build one with `createCompactionUserMessage(content)` from `eve/compaction`, for example to mark a checkpoint.
+`facts` holds `inputTokens`, `requestEnvelopeTokens`, `threshold`, `recentWindowSize` and `reason`. `shouldCompact` decides automatic compaction only: a user-requested compaction (`reason: "manual"`) runs `compact` without calling it. `history` is the conversation without memory records; eve places recalled memory ahead of the result, so a strategy never sees or reorders it. A user message you return needs a `kind`; build one with `createCompactionUserMessage(content)` from `eve/compaction`, for example to mark a checkpoint.
 
 `ctx` adds `summarize({ messages, system })`, which runs the compaction model and bills the session, `estimateTokens(messages)`, and, when the turn can be cancelled, an `abortSignal`. A strategy that never summarizes makes no model call.
 
+The `modelId` on `compaction.requested` and `compaction.completed` is the id of the configured compaction model (`compaction.model`, or the agent's model when none is set), whether or not the strategy summarizes. It is not the id `summarize` resolved.
+
 ## Failure
 
 Throw `CompactionOverLimitError` (exported from `eve/compaction`) when no history the strategy could return fits. Any thrown error fails the compaction the way a failed summary does.

e2e/fixtures/agent-compaction-strategy/agent/agent.ts

@@ -12,6 +12,9 @@ const model = mockModel({
         visible.includes("record evidence 0") ? "OLD_HISTORY_KEPT" : undefined,
         visible.includes("Summary of our conversation so far:") ? "SUMMARY_WRITTEN" : undefined,
         visible.split("PROFILE_VALUE=RECALLED").length === 2 ? undefined : "MEMORY_NOT_RECALLED_ONCE",
+        visible.split("PROFILE_RECALLED_AFTER_COMPACTION=YES").length === 2
+          ? undefined
+          : "COMPACTION_RECALL_MISSING",
       ].filter((issue) => issue !== undefined);
       return issues.length === 0
         ? "CUSTOM_STRATEGY_OK"

e2e/fixtures/agent-compaction-strategy/agent/memory/profile.ts

@@ -9,7 +9,11 @@ export default defineMemory({
         return { messages: [{ content: "PROFILE_VALUE=RECALLED", id: "profile" }] };
       },
       async "compaction.completed"() {
-        return { messages: [{ content: "PROFILE_VALUE=RECALLED", id: "profile" }] };
+        return {
+          messages: [
+            { content: "PROFILE_RECALLED_AFTER_COMPACTION=YES", id: "profile-compaction" },
+          ],
+        };
       },
     },
   },

packages/eve/.generated

@@ -0,0 +1 @@
+../../../eve-fix/packages/eve/.generated

packages/eve/node_modules

@@ -0,0 +1 @@
+../../../eve-fix/packages/eve/node_modules

packages/eve/src/compiler/manifest.ts

@@ -920,15 +920,6 @@ const compiledDynamicToolDefinitionSchema: z.ZodType<CompiledDynamicToolDefiniti
   })
   .strict();
 
-const compiledCompactionDefinitionSchema: z.ZodType<CompiledCompactionDefinition> = z
-  .object({
-    exportName: z.string().optional(),
-    logicalPath: z.string(),
-    sourceId: z.string(),
-    sourceKind: z.literal("module"),
-  })
-  .strict();
-
 const compiledMemoryDefinitionSchema: z.ZodType<CompiledMemoryDefinition> = z
   .object({
     description: z.string().optional(),
@@ -1016,7 +1007,7 @@ const compiledAgentResourceFields = {
   extensionMounts: z.array(compiledExtensionMountSchema).default([]),
   hooks: z.array(compiledHookDefinitionSchema),
   memories: z.array(compiledMemoryDefinitionSchema).default([]),
-  compaction: compiledCompactionDefinitionSchema.nullable().default(null),
+  compaction: moduleSourceRefSchema.nullable().default(null),
   sandbox: compiledSandboxDefinitionSchema,
   sandboxWorkspaces: z.array(compiledSandboxWorkspaceSchema),
   schedules: z.array(compiledScheduleDefinitionSchema),
@@ -1124,7 +1115,7 @@ export const compiledAgentManifestSchema = z
     dynamicTools: z.array(compiledDynamicToolDefinitionSchema).default([]),
     hooks: z.array(compiledHookDefinitionSchema),
     memories: z.array(compiledMemoryDefinitionSchema).default([]),
-    compaction: compiledCompactionDefinitionSchema.nullable().default(null),
+    compaction: moduleSourceRefSchema.nullable().default(null),
     kind: z.literal(COMPILED_AGENT_MANIFEST_KIND),
     remoteAgents: z.array(compiledRemoteAgentNodeSchema),
     sandbox: compiledSandboxDefinitionSchema,

packages/eve/src/harness/compaction/default-strategy.ts

@@ -57,6 +57,7 @@ async function compactWith(
   compactionStrategy?: CompactionStrategy,
   options: {
     readonly compactionModelReference?: { readonly id: string };
+    readonly events?: { readonly type: string; readonly data?: unknown }[];
     readonly resolveModel?: (reference: { readonly id: string }) => Promise<MockLanguageModelV3>;
   } = {},
 ) {
@@ -79,7 +80,9 @@ async function compactWith(
   return createToolLoopHarness({
     compactOnly: true,
     compactionStrategy,
-    handleEvent: async () => {},
+    handleEvent: async (event) => {
+      options.events?.push(event as { type: string; data?: unknown });
+    },
     resolveModel: options.resolveModel ?? (async () => model),
     tools: new Map(),
   })(session, {});
@@ -207,6 +210,54 @@ describe("compaction strategy", () => {
     expect(result.session.history).toHaveLength(2);
   });
 
+  it("names the configured compaction model on its events, whether or not the strategy summarizes", async () => {
+    const turnModel = new MockLanguageModelV3({ doStream: async () => summaryStream() });
+    const strategy: CompactionStrategy = {
+      compact: async (history) => history.slice(-2),
+      shouldCompact: () => false,
+    };
+    const configured: { type: string; data?: unknown }[] = [];
+    const fallback: { type: string; data?: unknown }[] = [];
+
+    await compactWith(turnModel, strategy, {
+      compactionModelReference: { id: "other-model" },
+      events: configured,
+      resolveModel: async () => turnModel,
+    });
+    await compactWith(turnModel, strategy, { events: fallback });
+
+    const modelIds = (events: { type: string; data?: unknown }[]) =>
+      events
+        .filter((event) => event.type.startsWith("compaction."))
+        .map((event) => [event.type, (event.data as { modelId?: string } | undefined)?.modelId]);
+    expect(modelIds(configured)).toEqual([
+      ["compaction.requested", "other-model"],
+      ["compaction.completed", "other-model"],
+    ]);
+    expect(modelIds(fallback)).toEqual([
+      ["compaction.requested", "summary-model"],
+      ["compaction.completed", "summary-model"],
+    ]);
+  });
+
+  it("treats an invalid strategy result as a compaction failure that still counts the summary call", async () => {
+    const strategy: CompactionStrategy = {
+      compact: async (history, context) => {
+        await context.summarize({ messages: [...history], system: "Summarize." });
+        return [{ content: "no kind", role: "user" }] as never;
+      },
+      shouldCompact: () => false,
+    };
+
+    const result = await compactWith(
+      new MockLanguageModelV3({ doStream: async () => summaryStream() }),
+      strategy,
+    );
+
+    expect(result.session.history).toHaveLength(3);
+    expect(getTurnUsageState(result.session.state)?.session).toMatchObject({ inputTokens: 120 });
+  });
+
   it("makes no model call when the strategy keeps the history without a summary", async () => {
     const doStream = vi.fn<MockLanguageModelV3["doStream"]>(async () => summaryStream());
 

packages/eve/src/harness/compaction/step.integration.test.ts

@@ -32,7 +32,7 @@ import type {
   CompactionStrategy,
 } from "#harness/compaction/strategy.js";
 import { estimateTokens } from "#harness/token-estimate.js";
-import { defaultCompactionStrategy } from "#harness/compaction/default-strategy.js";
+import { fixedTail } from "#harness/compaction/strategies/fixed-tail/index.js";
 import { contextStorage } from "#context/container.js";
 import {
   createCompactionCompletedEvent,
@@ -97,7 +97,7 @@ export async function compactHistory(step: Step): Promise<StepResult> {
         resolveModel: config.resolveModel,
         runtimeIdentity: config.runtimeIdentity,
         session: step.session,
-        strategy: config.compactionStrategy ?? defaultCompactionStrategy,
+        strategy: config.compactionStrategy,
         telemetry: step.instrumentation?.telemetry(),
         traceContextHeaders: step.instrumentation?.gatewayTraceContextHeaders,
       });
@@ -155,7 +155,7 @@ export async function maybeCompact(input: {
   readonly resolveModel: ToolLoopHarnessConfig["resolveModel"];
   readonly runtimeIdentity?: ToolLoopHarnessConfig["runtimeIdentity"];
   readonly session: HarnessSession;
-  readonly strategy: CompactionStrategy;
+  readonly strategy?: CompactionStrategy;
   readonly telemetry?: TelemetryOptions;
   readonly traceContextHeaders?: () => Record<string, string> | undefined;
 }): Promise<{
@@ -166,6 +166,7 @@ export async function maybeCompact(input: {
   readonly session: HarnessSession;
 }> {
   const { emissionState, publish } = input;
+  const strategy = input.strategy ?? fixedTail();
   let messages = input.messages;
   let session = input.session;
   const promptMessages = input.promptMessages ?? messages;
@@ -186,8 +187,7 @@ export async function maybeCompact(input: {
     threshold: session.compaction.threshold,
   };
   const needsSummary =
-    input.force === true ||
-    (projectedPromptMessages.length > 0 && input.strategy.shouldCompact(facts));
+    input.force === true || (projectedPromptMessages.length > 0 && strategy.shouldCompact(facts));
   const needsMemoryCanonicalization = shouldCanonicalizeMemory(messages);
 
   if (!needsSummary && !needsMemoryCanonicalization) {
@@ -260,7 +260,7 @@ export async function maybeCompact(input: {
     input.historyProjector?.({ messages: canonical.ordinary, state: session.state }) ??
       canonical.ordinary,
   );
-  let compacted: readonly ModelMessage[] = ordinary;
+  let compacted: HarnessModelMessage[] | undefined;
   let failure: { readonly error: unknown } | undefined;
   try {
     if (needsSummary) {
@@ -270,7 +270,8 @@ export async function maybeCompact(input: {
         estimateTokens,
         summarize,
       };
-      compacted = await input.strategy.compact([...ordinary], context);
+      const result = await strategy.compact([...ordinary], context);
+      compacted = validateHarnessModelMessages([...canonical.memory, ...result]);
     }
   } catch (error) {
     failure = { error };
@@ -284,7 +285,7 @@ export async function maybeCompact(input: {
   if (failure !== undefined) {
     return { compacted: false, failure, messages: input.messages, session };
   }
-  messages = validateHarnessModelMessages([...canonical.memory, ...compacted]);
+  messages = compacted ?? validateHarnessModelMessages([...canonical.memory, ...ordinary]);
 
   {
     const ctx = contextStorage.getStore();

packages/eve/src/harness/compaction/step.ts

@@ -53,7 +53,6 @@ import { requireSessionModelReference, type StepResult } from "#harness/types.js
 import type { InstrumentationAttempt } from "#instrumentation/runtime.js";
 import { createLogger, logError } from "#internal/logging.js";
 import { CompactionOverLimitError } from "#harness/compaction/over-limit-error.js";
-import { defaultCompactionStrategy } from "#harness/compaction/default-strategy.js";
 import { maybeCompact } from "#harness/compaction/step.js";
 import { reportCompactionFailure } from "./failure.js";
 import { buildGatewayAttributionHeaders, withGatewayTraceContext } from "./model.js";
@@ -288,7 +287,7 @@ export class ModelCaller {
         resolveModel: config.resolveModel,
         runtimeIdentity: config.runtimeIdentity,
         session: step.session,
-        strategy: config.compactionStrategy ?? defaultCompactionStrategy,
+        strategy: config.compactionStrategy,
         telemetry: step.instrumentation?.telemetry(),
         traceContextHeaders: step.instrumentation?.gatewayTraceContextHeaders,
       });