saeeol 1.3.0 → 1.4.0

package/test/saeeol/session-processor-network-offline.test.ts

@@ -0,0 +1,204 @@
+import { NodeFileSystem } from "@effect/platform-node"
+import { describe, expect, spyOn } from "bun:test"
+import { Context, Effect, Layer } from "effect"
+import * as Stream from "effect/Stream"
+import path from "path"
+import { Agent as AgentSvc } from "../../src/agent/agent"
+import { Bus } from "../../src/bus"
+import { Config } from "../../src/config/config"
+import { Permission } from "../../src/permission"
+import { Plugin } from "../../src/plugin"
+import type { Provider } from "../../src/provider/provider"
+import { ModelID, ProviderID } from "../../src/provider/schema"
+import { Session } from "../../src/session/session"
+import { LLM } from "../../src/session/llm"
+import { MessageV2 } from "../../src/session/message-v2"
+import { SessionNetwork } from "../../src/session/network"
+import { SessionProcessor } from "../../src/session/processor"
+import { MessageID, PartID, SessionID } from "../../src/session/schema"
+import { SessionStatus } from "../../src/session/status"
+import { SessionSummary } from "../../src/session/summary"
+import { Snapshot } from "../../src/snapshot"
+import * as Log from "@saeeol/core/util/log"
+import * as CrossSpawnSpawner from "@saeeol/core/cross-spawn-spawner"
+import { provideTmpdirInstance } from "../fixture/fixture"
+import { testEffect } from "../lib/effect"
+
+Log.init({ print: false })
+
+const ref = {
+  providerID: ProviderID.make("test"),
+  modelID: ModelID.make("test-model"),
+}
+
+type Script = Stream.Stream<LLM.Event, unknown>
+
+class TestLLM extends Context.Service<
+  TestLLM,
+  {
+    readonly push: (stream: Script) => Effect.Effect<void>
+  }
+>()("@test/OfflineLLM") {}
+
+function model(): Provider.Model {
+  return {
+    id: "test-model",
+    providerID: "test",
+    name: "Test",
+    limit: { context: 128000, output: 4096 },
+    cost: { input: 0, output: 0, cache: { read: 0, write: 0 } },
+    capabilities: {
+      toolcall: true,
+      attachment: false,
+      reasoning: false,
+      temperature: true,
+      input: { text: true, image: false, audio: false, video: false },
+      output: { text: true, image: false, audio: false, video: false },
+    },
+    api: { npm: "@ai-sdk/openai" },
+    options: {},
+  } as Provider.Model
+}
+
+function usage() {
+  return {
+    inputTokens: 10,
+    outputTokens: 5,
+    totalTokens: 15,
+  }
+}
+
+const llm = Layer.unwrap(
+  Effect.gen(function* () {
+    const queue: Script[] = []
+    const push = (item: Script) => {
+      queue.push(item)
+      return Effect.void
+    }
+    return Layer.mergeAll(
+      Layer.succeed(
+        LLM.Service,
+        LLM.Service.of({
+          stream: () => {
+            const item = queue.shift() ?? Stream.empty
+            return item
+          },
+          raw: () => Effect.die("raw not implemented in TestLLM"),
+        }),
+      ),
+      Layer.succeed(TestLLM, TestLLM.of({ push })),
+    )
+  }),
+)
+
+const status = SessionStatus.layer.pipe(Layer.provideMerge(Bus.layer))
+const infra = Layer.mergeAll(NodeFileSystem.layer, CrossSpawnSpawner.defaultLayer)
+const deps = Layer.mergeAll(
+  Session.defaultLayer,
+  Snapshot.defaultLayer,
+  AgentSvc.defaultLayer,
+  Permission.defaultLayer,
+  Plugin.defaultLayer,
+  Config.defaultLayer,
+  SessionSummary.defaultLayer,
+  status,
+  llm,
+).pipe(Layer.provideMerge(infra))
+const env = SessionProcessor.layer.pipe(Layer.provideMerge(deps))
+
+const it = testEffect(env)
+
+describe("session processor network offline", () => {
+  it.effect("enters offline state for provider connection message", () =>
+    provideTmpdirInstance(
+      (dir) =>
+        Effect.gen(function* () {
+          const test = yield* TestLLM
+          const processors = yield* SessionProcessor.Service
+          const session = yield* Session.Service
+
+          const err = new Error("Unable to connect. Is the computer able to access the url?")
+
+          // First call: network error via Stream.fail; second call: success
+          yield* test.push(Stream.fail(err))
+          yield* test.push(
+            Stream.make(
+              { type: "start" } as LLM.Event,
+              { type: "start-step" } as LLM.Event,
+              {
+                type: "finish-step",
+                finishReason: "stop",
+                usage: usage(),
+                providerMetadata: undefined,
+              } as LLM.Event,
+              { type: "finish" } as LLM.Event,
+            ),
+          )
+
+          // Auto-reply to network reconnect request
+          const offAsk = Bus.subscribe(SessionNetwork.Event.Asked, (event) => {
+            void SessionNetwork.reply({ requestID: event.properties.id })
+          })
+          const ask = spyOn(SessionNetwork, "ask")
+
+          const chat = yield* session.create({})
+          const parent = yield* session.updateMessage({
+            id: MessageID.ascending(),
+            role: "user",
+            sessionID: chat.id,
+            agent: "code",
+            model: ref,
+            time: { created: Date.now() },
+          })
+          const msg: MessageV2.Assistant = {
+            id: MessageID.ascending(),
+            role: "assistant",
+            sessionID: chat.id,
+            parentID: parent.id,
+            mode: "code",
+            agent: "code",
+            path: { cwd: path.resolve(dir), root: path.resolve(dir) },
+            cost: 0,
+            tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+            modelID: ref.modelID,
+            providerID: ref.providerID,
+            time: { created: Date.now() },
+          }
+          yield* session.updateMessage(msg)
+
+          const mdl = model()
+          const handle = yield* processors.create({
+            assistantMessage: msg,
+            sessionID: chat.id,
+            model: mdl,
+          })
+
+          const input: LLM.StreamInput = {
+            user: parent as MessageV2.User,
+            sessionID: chat.id,
+            model: mdl,
+            agent: { name: "code", mode: "primary", permission: [], options: {} } as any,
+            system: [],
+            messages: [],
+            tools: {},
+          }
+
+          try {
+            const result = yield* handle.process(input)
+            expect(result).toBe("continue")
+            expect(ask).toHaveBeenCalledTimes(1)
+            // Verify the offline handler was invoked with the correct message
+            const call = ask.mock.calls[0]
+            expect(call[0]).toMatchObject({
+              sessionID: chat.id,
+              message: err.message,
+            })
+          } finally {
+            offAsk()
+            ask.mockRestore()
+          }
+        }),
+      { git: true },
+    ),
+  )
+})

package/test/saeeol/session-processor-retry-limit.test.ts

@@ -0,0 +1,238 @@
+// Set env before any imports that transitively load flag.ts (e.g. LLM, SessionRetry).
+// This MUST happen before static imports, but ES module imports are hoisted.
+// So we set it here and use mock.module + dynamic imports for modules that
+// transitively load flag.ts to ensure the env is captured at load time.
+process.env.SAEEOL_SESSION_RETRY_LIMIT = "2"
+
+import { NodeFileSystem } from "@effect/platform-node"
+import { afterEach, describe, expect, spyOn } from "bun:test"
+import { APICallError } from "ai"
+import { Context, Effect, Layer } from "effect"
+import * as Stream from "effect/Stream"
+import path from "path"
+import { Agent as AgentSvc } from "../../src/agent/agent"
+import { Bus } from "../../src/bus"
+import { Config } from "../../src/config/config"
+import { Permission } from "../../src/permission"
+import { Plugin } from "../../src/plugin"
+import type { Provider } from "../../src/provider/provider"
+import { ModelID, ProviderID } from "../../src/provider/schema"
+import { Session } from "../../src/session/session"
+import { LLM } from "../../src/session/llm"
+import { MessageV2 } from "../../src/session/message-v2"
+import { SessionProcessor } from "../../src/session/processor"
+import { SessionRetry } from "../../src/session/retry"
+import { MessageID, PartID, SessionID } from "../../src/session/schema"
+import { SessionStatus } from "../../src/session/status"
+import { SessionSummary } from "../../src/session/summary"
+import { Snapshot } from "../../src/snapshot"
+import * as Log from "@saeeol/core/util/log"
+import * as CrossSpawnSpawner from "@saeeol/core/cross-spawn-spawner"
+import { provideTmpdirInstance } from "../fixture/fixture"
+import { testEffect } from "../lib/effect"
+
+Log.init({ print: false })
+
+const ref = {
+  providerID: ProviderID.make("test"),
+  modelID: ModelID.make("test-model"),
+}
+
+type Script = Stream.Stream<LLM.Event, unknown>
+
+class TestLLM extends Context.Service<
+  TestLLM,
+  {
+    readonly push: (stream: Script) => Effect.Effect<void>
+    readonly calls: Effect.Effect<number>
+  }
+>()("@test/RetryLimitLLM") {}
+
+function model(): Provider.Model {
+  return {
+    id: "test-model",
+    providerID: "test",
+    name: "Test",
+    limit: { context: 128000, output: 4096 },
+    cost: { input: 0, output: 0, cache: { read: 0, write: 0 } },
+    capabilities: {
+      toolcall: true,
+      attachment: false,
+      reasoning: false,
+      temperature: true,
+      input: { text: true, image: false, audio: false, video: false },
+      output: { text: true, image: false, audio: false, video: false },
+    },
+    api: { npm: "@ai-sdk/openai" },
+    options: {},
+  } as Provider.Model
+}
+
+function retryable429() {
+  return new APICallError({
+    message: "429 status code (no body)",
+    url: "https://api.openai.com/v1/chat/completions",
+    requestBodyValues: {},
+    statusCode: 429,
+    responseHeaders: { "content-type": "application/json" },
+    isRetryable: true,
+  })
+}
+
+const llm = Layer.unwrap(
+  Effect.gen(function* () {
+    const queue: Script[] = []
+    let calls = 0
+    const push = (item: Script) => {
+      queue.push(item)
+      return Effect.void
+    }
+    return Layer.mergeAll(
+      Layer.succeed(
+        LLM.Service,
+        LLM.Service.of({
+          stream: () => {
+            calls += 1
+            const item = queue.shift() ?? Stream.fail(new Error("unexpected extra llm call"))
+            return item
+          },
+          raw: () => Effect.die("raw not implemented in TestLLM"),
+        }),
+      ),
+      Layer.succeed(TestLLM, TestLLM.of({ push, calls: Effect.sync(() => calls) })),
+    )
+  }),
+)
+
+const status = SessionStatus.layer.pipe(Layer.provideMerge(Bus.layer))
+const infra = Layer.mergeAll(NodeFileSystem.layer, CrossSpawnSpawner.defaultLayer)
+const deps = Layer.mergeAll(
+  Session.defaultLayer,
+  Snapshot.defaultLayer,
+  AgentSvc.defaultLayer,
+  Permission.defaultLayer,
+  Plugin.defaultLayer,
+  Config.defaultLayer,
+  SessionSummary.defaultLayer,
+  status,
+  llm,
+).pipe(Layer.provideMerge(infra))
+const env = SessionProcessor.layer.pipe(Layer.provideMerge(deps))
+
+const it = testEffect(env)
+
+afterEach(() => {
+  delete process.env.SAEEOL_SESSION_RETRY_LIMIT
+})
+
+describe("session processor retry limit", () => {
+  it.live(
+    "stops after two retries with the normalized retryable error",
+    () =>
+      provideTmpdirInstance(
+        (dir) =>
+          Effect.gen(function* () {
+process.env.SAEEOL_SESSION_RETRY_LIMIT = "2"
+            const test = yield* TestLLM
+            const processors = yield* SessionProcessor.Service
+            const session = yield* Session.Service
+
+            // 3 retryable 429 errors + sentinel (should not be reached)
+            yield* test.push(Stream.fail(retryable429()))
+            yield* test.push(Stream.fail(retryable429()))
+            yield* test.push(Stream.fail(retryable429()))
+            yield* test.push(Stream.fail(new Error("unexpected extra llm call")))
+
+            const delay = spyOn(SessionRetry, "delay").mockReturnValue(0)
+
+            const chat = yield* session.create({})
+            const parent = yield* session.updateMessage({
+              id: MessageID.ascending(),
+              role: "user",
+              sessionID: chat.id,
+              agent: "code",
+              model: ref,
+              time: { created: Date.now() },
+            })
+            const msg: MessageV2.Assistant = {
+              id: MessageID.ascending(),
+              role: "assistant",
+              sessionID: chat.id,
+              parentID: parent.id,
+              mode: "code",
+              agent: "code",
+              path: { cwd: path.resolve(dir), root: path.resolve(dir) },
+              cost: 0,
+              tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+              modelID: ref.modelID,
+              providerID: ref.providerID,
+              time: { created: Date.now() },
+            }
+            yield* session.updateMessage(msg)
+
+            const mdl = model()
+            const handle = yield* processors.create({
+              assistantMessage: msg,
+              sessionID: chat.id,
+              model: mdl,
+            })
+
+            const input: LLM.StreamInput = {
+              user: parent as MessageV2.User,
+              sessionID: chat.id,
+              model: mdl,
+              agent: { name: "code", mode: "primary", permission: [], options: {} } as any,
+              system: [],
+              messages: [],
+              tools: {},
+            }
+
+            const expected = MessageV2.fromError(retryable429(), { providerID: ProviderID.make("test") })
+            try {
+              const result = yield* handle.process(input)
+              const calls = yield* test.calls
+
+              expect(result).toBe("stop")
+              expect(calls).toBe(3)
+              expect(handle.message.error).toStrictEqual(expected)
+            } finally {
+              delay.mockRestore()
+            }
+          }),
+        { git: true },
+      ),
+    15000,
+  )
+
+  it.effect("only positive integers enable the limit", () =>
+    Effect.promise(async () => {
+      const { Flag } = await import("@saeeol/core/flag/flag")
+
+      delete process.env.SAEEOL_SESSION_RETRY_LIMIT
+      expect(Flag.SAEEOL_SESSION_RETRY_LIMIT).toBeUndefined()
+
+      process.env.SAEEOL_SESSION_RETRY_LIMIT = "0"
+      expect(Flag.SAEEOL_SESSION_RETRY_LIMIT).toBeUndefined()
+
+      process.env.SAEEOL_SESSION_RETRY_LIMIT = "-1"
+      expect(Flag.SAEEOL_SESSION_RETRY_LIMIT).toBeUndefined()
+
+      process.env.SAEEOL_SESSION_RETRY_LIMIT = "abc"
+      expect(Flag.SAEEOL_SESSION_RETRY_LIMIT).toBeUndefined()
+
+      process.env.SAEEOL_SESSION_RETRY_LIMIT = "2"
+      expect(Flag.SAEEOL_SESSION_RETRY_LIMIT).toBe(2)
+    }),
+  )
+
+  it.effect("reads env at access time (dynamic getter)", () =>
+    Effect.promise(async () => {
+      const { Flag } = await import("@saeeol/core/flag/flag")
+      delete process.env.SAEEOL_SESSION_RETRY_LIMIT
+      expect(Flag.SAEEOL_SESSION_RETRY_LIMIT).toBeUndefined()
+      process.env.SAEEOL_SESSION_RETRY_LIMIT = "5"
+      expect(Flag.SAEEOL_SESSION_RETRY_LIMIT).toBe(5)
+      delete process.env.SAEEOL_SESSION_RETRY_LIMIT
+    }),
+  )
+})

package/test/saeeol/session-processor-review-telemetry.test.ts

@@ -0,0 +1,82 @@
+import { describe, expect, test } from "bun:test"
+import { SaeeolSessionProcessor } from "../../src/overlay/session/processor"
+import type { MessageV2 } from "../../src/session/message-v2"
+
+const REVIEW_COMMANDS = ["review", "local-review", "local-review-uncommitted"] as const
+
+const expected = (command: (typeof REVIEW_COMMANDS)[number]) => ({
+  mode: "review" as const,
+  feature: "code_reviews" as const,
+  command,
+})
+
+describe("SaeeolSessionProcessor.reviewTelemetry", () => {
+  for (const command of REVIEW_COMMANDS) {
+    test(`returns telemetry for ${command}`, () => {
+      expect(SaeeolSessionProcessor.reviewTelemetry(command)).toEqual(expected(command))
+    })
+  }
+
+  test("returns undefined for an unrelated command", () => {
+    expect(SaeeolSessionProcessor.reviewTelemetry("init")).toBeUndefined()
+  })
+
+  test("returns undefined for an undefined command", () => {
+    expect(SaeeolSessionProcessor.reviewTelemetry(undefined)).toBeUndefined()
+  })
+})
+
+describe("SaeeolSessionProcessor.markReviewTelemetry", () => {
+  for (const command of REVIEW_COMMANDS) {
+    test(`stamps text parts with telemetry for ${command}`, () => {
+      const parts: Array<{ type: string; metadata?: Record<string, unknown> }> = [
+        { type: "text", metadata: { existing: "keep" } },
+        { type: "file" },
+        { type: "text" },
+      ]
+      const tel = SaeeolSessionProcessor.markReviewTelemetry(parts, command)
+      expect(tel).toEqual(expected(command))
+      expect(parts[0].metadata).toEqual({ existing: "keep", ...expected(command) })
+      expect(parts[1].metadata).toBeUndefined()
+      expect(parts[2].metadata).toEqual({ ...expected(command) })
+    })
+  }
+
+  test("does nothing for an unrelated command", () => {
+    const parts: Array<{ type: string; metadata?: Record<string, unknown> }> = [{ type: "text" }]
+    expect(SaeeolSessionProcessor.markReviewTelemetry(parts, "init")).toBeUndefined()
+    expect(parts[0].metadata).toBeUndefined()
+  })
+
+  test("does nothing for an undefined command", () => {
+    const parts: Array<{ type: string; metadata?: Record<string, unknown> }> = [{ type: "text" }]
+    expect(SaeeolSessionProcessor.markReviewTelemetry(parts, undefined)).toBeUndefined()
+    expect(parts[0].metadata).toBeUndefined()
+  })
+})
+
+describe("SaeeolSessionProcessor.extractReviewTelemetry", () => {
+  for (const command of REVIEW_COMMANDS) {
+    test(`recovers ${command} telemetry from marked text parts`, () => {
+      const parts: Array<{ type: string; metadata?: Record<string, unknown> }> = [{ type: "text" }]
+      SaeeolSessionProcessor.markReviewTelemetry(parts, command)
+      const round = SaeeolSessionProcessor.extractReviewTelemetry(parts as unknown as MessageV2.Part[])
+      expect(round).toEqual(expected(command))
+    })
+  }
+
+  test("returns undefined when parts have no review metadata", () => {
+    const parts: Array<{ type: string; metadata?: Record<string, unknown> }> = [
+      { type: "text" },
+      { type: "text", metadata: { foo: "bar" } },
+    ]
+    expect(SaeeolSessionProcessor.extractReviewTelemetry(parts as unknown as MessageV2.Part[])).toBeUndefined()
+  })
+
+  test("returns undefined when command in metadata is unknown", () => {
+    const parts: Array<{ type: string; metadata?: Record<string, unknown> }> = [
+      { type: "text", metadata: { mode: "review", feature: "code_reviews", command: "unknown" } },
+    ]
+    expect(SaeeolSessionProcessor.extractReviewTelemetry(parts as unknown as MessageV2.Part[])).toBeUndefined()
+  })
+})