saeeol 1.3.0 → 1.4.0

package/test/saeeol/compaction-payload-recovery.test.ts

@@ -0,0 +1,406 @@
+import { afterEach, describe, expect, mock, test } from "bun:test"
+import { APICallError } from "ai"
+import { Effect, Layer, ManagedRuntime } from "effect"
+import * as Stream from "effect/Stream"
+import { Agent } from "../../src/agent/agent"
+import { Bus } from "../../src/bus"
+import { Config } from "../../src/config/config"
+import { SaeeolCompactionPayloadRecovery } from "../../src/overlay/session/compaction-payload-recovery"
+import { Permission } from "../../src/permission"
+import { Plugin } from "../../src/plugin"
+import { Instance } from "../../src/project/instance"
+import { ModelID, ProviderID } from "../../src/provider/schema"
+import { Snapshot } from "../../src/snapshot"
+import { LLM } from "../../src/session/llm"
+import { MessageV2 } from "../../src/session/message-v2"
+import * as SessionProcessorModule from "../../src/session/processor"
+import { Session as SessionNs } from "../../src/session/session"
+import { MessageID, PartID, SessionID } from "../../src/session/schema"
+import { SessionCompaction } from "../../src/session/compaction"
+import { SessionStatus } from "../../src/session/status"
+import { SessionSummary } from "../../src/session/summary"
+import { ProviderTest } from "../fake/provider"
+import { tmpdir } from "../fixture/fixture"
+
+const sessionID = SessionID.make("ses_payload_recovery")
+const userID = MessageID.ascending()
+const assistantID = MessageID.ascending()
+const providerID = ProviderID.make("test")
+const modelID = ModelID.make("test-model")
+
+const ref = {
+  providerID,
+  modelID,
+}
+
+function run<A, E>(fx: Effect.Effect<A, E, SessionNs.Service>) {
+  return Effect.runPromise(fx.pipe(Effect.provide(SessionNs.defaultLayer)))
+}
+
+const svc = {
+  create(input?: SessionNs.CreateInput) {
+    return run(SessionNs.Service.use((svc) => svc.create(input)))
+  },
+  messages(input: Parameters<SessionNs.Interface["messages"]>[0]) {
+    return run(SessionNs.Service.use((svc) => svc.messages(input)))
+  },
+  updateMessage<T extends MessageV2.Info>(msg: T) {
+    return run(SessionNs.Service.use((svc) => svc.updateMessage(msg)))
+  },
+  updatePart<T extends MessageV2.Part>(part: T) {
+    return run(SessionNs.Service.use((svc) => svc.updatePart(part)))
+  },
+}
+
+const summary = Layer.succeed(
+  SessionSummary.Service,
+  SessionSummary.Service.of({
+    summarize: () => Effect.void,
+    diff: () => Effect.succeed([]),
+    computeDiff: () => Effect.succeed([]),
+  }),
+)
+
+function base(id: MessageID) {
+  return {
+    id: PartID.ascending(),
+    messageID: id,
+    sessionID,
+  }
+}
+
+async function user(sessionID: SessionID, text: string) {
+  const msg = await svc.updateMessage({
+    id: MessageID.ascending(),
+    role: "user",
+    sessionID,
+    agent: "build",
+    model: ref,
+    time: { created: Date.now() },
+  })
+  await svc.updatePart({
+    id: PartID.ascending(),
+    messageID: msg.id,
+    sessionID,
+    type: "text",
+    text,
+  })
+  return msg
+}
+
+async function assistant(sessionID: SessionID, parentID: MessageID, root: string) {
+  const msg: MessageV2.Assistant = {
+    id: MessageID.ascending(),
+    role: "assistant",
+    sessionID,
+    mode: "build",
+    agent: "build",
+    path: { cwd: root, root },
+    cost: 0,
+    tokens: { output: 0, input: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+    modelID,
+    providerID,
+    parentID,
+    time: { created: Date.now() },
+    finish: "end_turn",
+  }
+  await svc.updateMessage(msg)
+  return msg
+}
+
+function llm() {
+  const queue: Array<
+    Stream.Stream<LLM.Event, unknown> | ((input: LLM.StreamInput) => Stream.Stream<LLM.Event, unknown>)
+  > = []
+
+  return {
+    push(stream: Stream.Stream<LLM.Event, unknown> | ((input: LLM.StreamInput) => Stream.Stream<LLM.Event, unknown>)) {
+      queue.push(stream)
+    },
+    layer: Layer.succeed(
+      LLM.Service,
+      LLM.Service.of({
+        stream: (input) => {
+          const item = queue.shift() ?? Stream.empty
+          const stream = typeof item === "function" ? item(input) : item
+          return stream.pipe(Stream.mapEffect((event) => Effect.succeed(event)))
+        },
+        raw: () => Effect.die("raw not implemented in test LLM"),
+      }),
+    ),
+  }
+}
+
+function reply(
+  text: string,
+  capture?: (input: LLM.StreamInput) => void,
+): (input: LLM.StreamInput) => Stream.Stream<LLM.Event, unknown> {
+  return (input) => {
+    capture?.(input)
+    return Stream.make(
+      { type: "start" } as LLM.Event,
+      { type: "text-start", id: "txt-0" } as LLM.Event,
+      { type: "text-delta", id: "txt-0", delta: text, text } as LLM.Event,
+      { type: "text-end", id: "txt-0" } as LLM.Event,
+      {
+        type: "finish-step",
+        finishReason: "stop",
+        rawFinishReason: "stop",
+        response: { id: "res", modelId: "test-model", timestamp: new Date() },
+        providerMetadata: undefined,
+        usage: {
+          inputTokens: 1,
+          outputTokens: 1,
+          totalTokens: 2,
+          inputTokenDetails: { noCacheTokens: undefined, cacheReadTokens: undefined, cacheWriteTokens: undefined },
+          outputTokenDetails: { textTokens: undefined, reasoningTokens: undefined },
+        },
+      } as LLM.Event,
+      {
+        type: "finish",
+        finishReason: "stop",
+        rawFinishReason: "stop",
+        totalUsage: {
+          inputTokens: 1,
+          outputTokens: 1,
+          totalTokens: 2,
+          inputTokenDetails: { noCacheTokens: undefined, cacheReadTokens: undefined, cacheWriteTokens: undefined },
+          outputTokenDetails: { textTokens: undefined, reasoningTokens: undefined },
+        },
+      } as LLM.Event,
+    )
+  }
+}
+
+function runtime(layer: Layer.Layer<LLM.Service>, config = Config.defaultLayer) {
+  const bus = Bus.layer
+  const status = SessionStatus.layer.pipe(Layer.provide(bus))
+  const processor = SessionProcessorModule.SessionProcessor.layer.pipe(Layer.provide(summary))
+  const model = ProviderTest.model({ providerID, id: modelID, limit: { context: 100_000, output: 32_000 } })
+  return ManagedRuntime.make(
+    Layer.mergeAll(SessionCompaction.layer.pipe(Layer.provide(processor)), processor, bus, status).pipe(
+      Layer.provide(ProviderTest.fake({ model }).layer),
+      Layer.provide(SessionNs.defaultLayer),
+      Layer.provide(Snapshot.defaultLayer),
+      Layer.provide(layer),
+      Layer.provide(Permission.defaultLayer),
+      Layer.provide(Agent.defaultLayer),
+      Layer.provide(Plugin.defaultLayer),
+      Layer.provide(status),
+      Layer.provide(bus),
+      Layer.provide(config),
+    ),
+  )
+}
+
+afterEach(() => {
+  mock.restore()
+})
+
+describe("SaeeolCompactionPayloadRecovery", () => {
+  test("detects Saeeol gateway payload-size errors", () => {
+    const error = new MessageV2.ContextOverflowError({
+      message: "Request Entity Too Large",
+      responseBody: "Request Entity Too Large\n\nFUNCTION_PAYLOAD_TOO_LARGE",
+    }).toObject()
+
+    expect(SaeeolCompactionPayloadRecovery.matches(error)).toBe(true)
+  })
+
+  test("strips media and marks completed tool outputs compacted", async () => {
+    const user: MessageV2.WithParts = {
+      info: {
+        id: userID,
+        role: "user",
+        sessionID,
+        agent: "build",
+        model: { providerID, modelID },
+        time: { created: Date.now() },
+      },
+      parts: [
+        {
+          ...base(userID),
+          type: "file",
+          mime: "image/png",
+          filename: "screen.png",
+          url: "data:image/png;base64,abc",
+        },
+      ],
+    }
+    const tool: MessageV2.ToolPart = {
+      ...base(assistantID),
+      type: "tool",
+      callID: "call-1",
+      tool: "bash",
+      state: {
+        status: "completed",
+        input: {},
+        output: "large output",
+        title: "Bash",
+        metadata: {},
+        time: { start: Date.now(), end: Date.now() },
+      },
+    }
+    const assistant: MessageV2.WithParts = {
+      info: {
+        id: assistantID,
+        role: "assistant",
+        parentID: userID,
+        sessionID,
+        mode: "build",
+        agent: "build",
+        path: { cwd: "/tmp", root: "/tmp" },
+        cost: 0,
+        tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+        modelID,
+        providerID,
+        time: { created: Date.now() },
+      },
+      parts: [tool],
+    }
+    const updated: MessageV2.Part[] = []
+
+    await Effect.runPromise(
+      SaeeolCompactionPayloadRecovery.strip({
+        messages: [user, assistant],
+        update: (part) => Effect.sync(() => updated.push(part)).pipe(Effect.as(part)),
+      }),
+    )
+
+    expect(updated).toHaveLength(2)
+    expect(updated[0]).toMatchObject({
+      type: "text",
+      text: "[Attached image/png: screen.png]",
+    })
+    expect(updated[1]?.type).toBe("tool")
+    if (updated[1]?.type === "tool" && updated[1].state.status === "completed") {
+      expect(updated[1].state.time.compacted).toBeNumber()
+    }
+  })
+
+  test("retries compaction without media and tool outputs after payload-size failure", async () => {
+    await using tmp = await tmpdir({ git: true })
+    const stub = llm()
+    const captures: string[] = []
+    stub.push((input) => {
+      captures.push(JSON.stringify(input.messages))
+      return Stream.make({ type: "start" } as LLM.Event).pipe(
+        Stream.concat(
+          Stream.fail(
+            new APICallError({
+              message: "Request Entity Too Large",
+              url: "https://api.saeeol.ai/api/openrouter/responses",
+              requestBodyValues: {},
+              statusCode: 413,
+              responseHeaders: { "content-type": "text/plain" },
+              responseBody: "Request Entity Too Large\n\nFUNCTION_PAYLOAD_TOO_LARGE",
+              isRetryable: false,
+            }),
+          ),
+        ),
+      )
+    })
+    stub.push(
+      reply("summary", (input) => {
+        captures.push(JSON.stringify(input.messages))
+      }),
+    )
+
+    await Instance.provide({
+      directory: tmp.path,
+      fn: async () => {
+        const session = await svc.create({})
+        const old = await user(session.id, "old image turn")
+        await svc.updatePart({
+          id: PartID.ascending(),
+          messageID: old.id,
+          sessionID: session.id,
+          type: "file",
+          mime: "image/png",
+          filename: "old.png",
+          url: `data:image/png;base64,${"a".repeat(8_000)}`,
+        })
+        const oldReply = await assistant(session.id, old.id, tmp.path)
+        await svc.updatePart({
+          id: PartID.ascending(),
+          messageID: oldReply.id,
+          sessionID: session.id,
+          type: "tool",
+          callID: crypto.randomUUID(),
+          tool: "bash",
+          state: {
+            status: "completed",
+            input: {},
+            output: "old output".repeat(10_000),
+            title: "old",
+            metadata: {},
+            time: { start: Date.now(), end: Date.now() },
+          },
+        })
+        await user(session.id, "latest turn")
+        const keep = await user(session.id, "preserved tail turn")
+        const keepReply = await assistant(session.id, keep.id, tmp.path)
+        await svc.updatePart({
+          id: PartID.ascending(),
+          messageID: keepReply.id,
+          sessionID: session.id,
+          type: "tool",
+          callID: crypto.randomUUID(),
+          tool: "bash",
+          state: {
+            status: "completed",
+            input: {},
+            output: "keep output",
+            title: "keep",
+            metadata: {},
+            time: { start: Date.now(), end: Date.now() },
+          },
+        })
+        await SessionCompaction.create({
+          sessionID: session.id,
+          agent: "build",
+          model: ref,
+          auto: false,
+        })
+
+        const rt = runtime(stub.layer, Config.defaultLayer)
+        try {
+          const msgs = await svc.messages({ sessionID: session.id })
+          const parent = msgs.at(-1)?.info.id
+          expect(parent).toBeTruthy()
+          const result = await rt.runPromise(
+            SessionCompaction.Service.use((svc) =>
+              svc.process({
+                parentID: parent!,
+                messages: msgs,
+                sessionID: session.id,
+                auto: false,
+              }),
+            ),
+          )
+
+          expect(result).toBe("continue")
+          expect(captures).toHaveLength(2)
+          expect(captures[0]).toContain("Attached image/png: old.png")
+          expect(captures[0]).toContain("old output")
+          expect(captures[0]).not.toContain("keep output")
+          expect(captures[1]).not.toContain("data:image/png;base64")
+          expect(captures[1]).not.toContain("old output")
+          expect(captures[1]).not.toContain("keep output")
+          expect(captures[1]).toContain("Attached image/png: old.png")
+          expect(captures[1]).toContain("Old tool result content cleared")
+          const tools = (await svc.messages({ sessionID: session.id }))
+            .flatMap((msg) => msg.parts)
+            .filter((part): part is MessageV2.ToolPart => part.type === "tool")
+          expect(tools).toHaveLength(2)
+          expect(tools[0]?.type).toBe("tool")
+          if (tools[0]?.state.status === "completed") expect(tools[0].state.time.compacted).toBeNumber()
+          expect(tools[1]?.type).toBe("tool")
+          if (tools[1]?.state.status === "completed") expect(tools[1].state.time.compacted).toBeUndefined()
+        } finally {
+          await rt.dispose()
+        }
+      },
+    })
+  })
+})

package/test/saeeol/compaction-preservation-audit.test.ts

@@ -0,0 +1,122 @@
+// Tests for the preservation audit logic in SaeeolCompactionChunks.
+// Verifies that file paths, commands, and error strings from the original
+// conversation are detected and their presence in the summary is measured.
+
+import { describe, expect, test } from "bun:test"
+
+// Duplicate the audit logic for unit testing.
+// In production this lives inside compaction-chunks.ts as a private function.
+const PRESERVATION_PATTERNS = [
+  /(?:\/[\w.-]+){2,}/g,
+  /(?:\\[\w.-]+){2,}/g,
+  /\b\w*error\w*[\s:]+[^\n]{5,80}/gi,
+  /\b(?:npm|bun|pnpm|npx|git|docker)\s+\S+/g,
+]
+
+function extractEntities(text: string): Set<string> {
+  const entities = new Set<string>()
+  for (const pattern of PRESERVATION_PATTERNS) {
+    const matches = text.match(pattern)
+    if (matches) for (const m of matches) entities.add(m.trim())
+  }
+  return entities
+}
+
+function auditPreservation(original: string, summary: string) {
+  const originalEntities = extractEntities(original)
+  if (originalEntities.size === 0) return { total: 0, preserved: 0, missing: [] as string[] }
+  const preserved: string[] = []
+  const missing: string[] = []
+  for (const entity of originalEntities) {
+    if (summary.toLowerCase().includes(entity.toLowerCase().slice(0, 40))) {
+      preserved.push(entity)
+    } else {
+      missing.push(entity)
+    }
+  }
+  return { total: originalEntities.size, preserved: preserved.length, missing: missing.slice(0, 10) }
+}
+
+describe("compaction preservation audit", () => {
+  test("detects Unix file paths from original", () => {
+    const original = "I edited /src/components/App.tsx and /src/utils/helpers.ts"
+    const entities = extractEntities(original)
+    expect(entities.has("/src/components/App.tsx")).toBe(true)
+    expect(entities.has("/src/utils/helpers.ts")).toBe(true)
+  })
+
+  test("detects Windows file paths from original", () => {
+    const original = "Modified src\\components\\App.tsx and lib\\utils\\index.js"
+    const entities = extractEntities(original)
+    expect(entities.size).toBeGreaterThan(0)
+  })
+
+  test("detects commands from original", () => {
+    const original = "Run npm install and git commit -m 'fix'"
+    const entities = extractEntities(original)
+    expect(entities.has("npm install")).toBe(true)
+    expect(entities.has("git commit")).toBe(true)
+  })
+
+  test("detects error messages from original", () => {
+    const original = "TypeError: Cannot read properties of undefined (reading 'map')"
+    const entities = extractEntities(original)
+    expect(entities.size).toBeGreaterThan(0)
+  })
+
+  test("reports preserved when summary contains the path", () => {
+    const original = "Edited /src/components/App.tsx to fix the bug"
+    const summary = "Fixed bug in /src/components/App.tsx"
+    const result = auditPreservation(original, summary)
+    expect(result.total).toBeGreaterThan(0)
+    expect(result.preserved).toBe(result.total)
+    expect(result.missing).toHaveLength(0)
+  })
+
+  test("reports missing when summary drops the path", () => {
+    const original = "Edited /src/components/App.tsx and /src/utils/helpers.ts"
+    const summary = "Fixed bug in the component"
+    const result = auditPreservation(original, summary)
+    expect(result.total).toBeGreaterThan(0)
+    expect(result.preserved).toBe(0)
+    expect(result.missing.length).toBeGreaterThan(0)
+  })
+
+  test("handles empty original gracefully", () => {
+    const result = auditPreservation("", "some summary")
+    expect(result.total).toBe(0)
+    expect(result.preserved).toBe(0)
+    expect(result.missing).toHaveLength(0)
+  })
+
+  test("handles empty summary gracefully", () => {
+    const original = "Run npm install to fix /src/index.ts"
+    const result = auditPreservation(original, "")
+    expect(result.total).toBeGreaterThan(0)
+    expect(result.preserved).toBe(0)
+    expect(result.missing.length).toBeGreaterThan(0)
+  })
+
+  test("partial preservation is reported correctly", () => {
+    const original = "npm install, bun test, and git push after editing /src/app.tsx"
+    const summary = "Ran npm install, edited /src/app.tsx"
+    const result = auditPreservation(original, summary)
+    expect(result.total).toBeGreaterThan(1)
+    expect(result.preserved).toBeGreaterThan(0)
+    expect(result.preserved).toBeLessThan(result.total)
+  })
+
+  test("case-insensitive matching for paths", () => {
+    const original = "Edited /src/Components/App.tsx"
+    const summary = "Fixed bug in /src/components/app.tsx"
+    const result = auditPreservation(original, summary)
+    expect(result.preserved).toBeGreaterThan(0)
+  })
+
+  test("limits missing list to 10 entries", () => {
+    const paths = Array.from({ length: 20 }, (_, i) => `/src/file${i}.ts`)
+    const original = paths.join(", ")
+    const result = auditPreservation(original, "nothing relevant")
+    expect(result.missing.length).toBeLessThanOrEqual(10)
+  })
+})