@toolkit-cli/toolkode 1.3.7

package/test/session/retry.test.ts

@@ -0,0 +1,232 @@
+import { describe, expect, test } from "bun:test"
+import type { NamedError } from "@toolkit-cli/util/error"
+import { APICallError } from "ai"
+import { setTimeout as sleep } from "node:timers/promises"
+import { Effect, Schedule } from "effect"
+import { SessionRetry } from "../../src/session/retry"
+import { MessageV2 } from "../../src/session/message-v2"
+import { ProviderID } from "../../src/provider/schema"
+import { SessionID } from "../../src/session/schema"
+import { SessionStatus } from "../../src/session/status"
+import { Instance } from "../../src/project/instance"
+import { tmpdir } from "../fixture/fixture"
+
+const providerID = ProviderID.make("test")
+
+function apiError(headers?: Record<string, string>): MessageV2.APIError {
+  return new MessageV2.APIError({
+    message: "boom",
+    isRetryable: true,
+    responseHeaders: headers,
+  }).toObject() as MessageV2.APIError
+}
+
+function wrap(message: unknown): ReturnType<NamedError["toObject"]> {
+  return { data: { message } } as ReturnType<NamedError["toObject"]>
+}
+
+describe("session.retry.delay", () => {
+  test("caps delay at 30 seconds when headers missing", () => {
+    const error = apiError()
+    const delays = Array.from({ length: 10 }, (_, index) => SessionRetry.delay(index + 1, error))
+    expect(delays).toStrictEqual([2000, 4000, 8000, 16000, 30000, 30000, 30000, 30000, 30000, 30000])
+  })
+
+  test("prefers retry-after-ms when shorter than exponential", () => {
+    const error = apiError({ "retry-after-ms": "1500" })
+    expect(SessionRetry.delay(4, error)).toBe(1500)
+  })
+
+  test("uses retry-after seconds when reasonable", () => {
+    const error = apiError({ "retry-after": "30" })
+    expect(SessionRetry.delay(3, error)).toBe(30000)
+  })
+
+  test("accepts http-date retry-after values", () => {
+    const date = new Date(Date.now() + 20000).toUTCString()
+    const error = apiError({ "retry-after": date })
+    const d = SessionRetry.delay(1, error)
+    expect(d).toBeGreaterThanOrEqual(19000)
+    expect(d).toBeLessThanOrEqual(20000)
+  })
+
+  test("ignores invalid retry hints", () => {
+    const error = apiError({ "retry-after": "not-a-number" })
+    expect(SessionRetry.delay(1, error)).toBe(2000)
+  })
+
+  test("ignores malformed date retry hints", () => {
+    const error = apiError({ "retry-after": "Invalid Date String" })
+    expect(SessionRetry.delay(1, error)).toBe(2000)
+  })
+
+  test("ignores past date retry hints", () => {
+    const pastDate = new Date(Date.now() - 5000).toUTCString()
+    const error = apiError({ "retry-after": pastDate })
+    expect(SessionRetry.delay(1, error)).toBe(2000)
+  })
+
+  test("uses retry-after values even when exceeding 10 minutes with headers", () => {
+    const error = apiError({ "retry-after": "50" })
+    expect(SessionRetry.delay(1, error)).toBe(50000)
+
+    const longError = apiError({ "retry-after-ms": "700000" })
+    expect(SessionRetry.delay(1, longError)).toBe(700000)
+  })
+
+  test("caps oversized header delays to the runtime timer limit", () => {
+    const error = apiError({ "retry-after-ms": "999999999999" })
+    expect(SessionRetry.delay(1, error)).toBe(SessionRetry.RETRY_MAX_DELAY)
+  })
+
+  test("policy updates retry status and increments attempts", async () => {
+    await using tmp = await tmpdir()
+    await Instance.provide({
+      directory: tmp.path,
+      fn: async () => {
+        const sessionID = SessionID.make("session-retry-test")
+        const error = apiError({ "retry-after-ms": "0" })
+
+        await Effect.runPromise(
+          Effect.gen(function* () {
+            const step = yield* Schedule.toStepWithMetadata(
+              SessionRetry.policy({
+                parse: (err) => err as MessageV2.APIError,
+                set: (info) =>
+                  Effect.promise(() =>
+                    SessionStatus.set(sessionID, {
+                      type: "retry",
+                      attempt: info.attempt,
+                      message: info.message,
+                      next: info.next,
+                    }),
+                  ),
+              }),
+            )
+            yield* step(error)
+            yield* step(error)
+          }),
+        )
+
+        expect(await SessionStatus.get(sessionID)).toMatchObject({
+          type: "retry",
+          attempt: 2,
+          message: "boom",
+        })
+      },
+    })
+  })
+})
+
+describe("session.retry.retryable", () => {
+  test("maps too_many_requests json messages", () => {
+    const error = wrap(JSON.stringify({ type: "error", error: { type: "too_many_requests" } }))
+    expect(SessionRetry.retryable(error)).toBe("Too Many Requests")
+  })
+
+  test("maps overloaded provider codes", () => {
+    const error = wrap(JSON.stringify({ code: "resource_exhausted" }))
+    expect(SessionRetry.retryable(error)).toBe("Provider is overloaded")
+  })
+
+  test("does not retry unknown json messages", () => {
+    const error = wrap(JSON.stringify({ error: { message: "no_kv_space" } }))
+    expect(SessionRetry.retryable(error)).toBeUndefined()
+  })
+
+  test("does not throw on numeric error codes", () => {
+    const error = wrap(JSON.stringify({ type: "error", error: { code: 123 } }))
+    const result = SessionRetry.retryable(error)
+    expect(result).toBeUndefined()
+  })
+
+  test("returns undefined for non-json message", () => {
+    const error = wrap("not-json")
+    expect(SessionRetry.retryable(error)).toBeUndefined()
+  })
+
+  test("does not retry context overflow errors", () => {
+    const error = new MessageV2.ContextOverflowError({
+      message: "Input exceeds context window of this model",
+      responseBody: '{"error":{"code":"context_length_exceeded"}}',
+    }).toObject() as ReturnType<NamedError["toObject"]>
+
+    expect(SessionRetry.retryable(error)).toBeUndefined()
+  })
+
+  test("retries ZlibError decompression failures", () => {
+    const error = new MessageV2.APIError({
+      message: "Response decompression failed",
+      isRetryable: true,
+      metadata: { code: "ZlibError" },
+    }).toObject() as MessageV2.APIError
+
+    const retryable = SessionRetry.retryable(error)
+    expect(retryable).toBeDefined()
+    expect(retryable).toBe("Response decompression failed")
+  })
+})
+
+describe("session.message-v2.fromError", () => {
+  test.concurrent(
+    "converts ECONNRESET socket errors to retryable APIError",
+    async () => {
+      using server = Bun.serve({
+        port: 0,
+        idleTimeout: 8,
+        async fetch(req) {
+          return new Response(
+            new ReadableStream({
+              async pull(controller) {
+                controller.enqueue("Hello,")
+                await sleep(10000)
+                controller.enqueue(" World!")
+                controller.close()
+              },
+            }),
+            { headers: { "Content-Type": "text/plain" } },
+          )
+        },
+      })
+
+      const error = await fetch(new URL("/", server.url.origin))
+        .then((res) => res.text())
+        .catch((e) => e)
+
+      const result = MessageV2.fromError(error, { providerID })
+
+      expect(MessageV2.APIError.isInstance(result)).toBe(true)
+      expect((result as MessageV2.APIError).data.isRetryable).toBe(true)
+      expect((result as MessageV2.APIError).data.message).toBe("Connection reset by server")
+      expect((result as MessageV2.APIError).data.metadata?.code).toBe("ECONNRESET")
+      expect((result as MessageV2.APIError).data.metadata?.message).toInclude("socket connection")
+    },
+    15_000,
+  )
+
+  test("ECONNRESET socket error is retryable", () => {
+    const error = new MessageV2.APIError({
+      message: "Connection reset by server",
+      isRetryable: true,
+      metadata: { code: "ECONNRESET", message: "The socket connection was closed unexpectedly" },
+    }).toObject() as MessageV2.APIError
+
+    const retryable = SessionRetry.retryable(error)
+    expect(retryable).toBeDefined()
+    expect(retryable).toBe("Connection reset by server")
+  })
+
+  test("marks OpenAI 404 status codes as retryable", () => {
+    const error = new APICallError({
+      message: "boom",
+      url: "https://api.openai.com/v1/chat/completions",
+      requestBodyValues: {},
+      statusCode: 404,
+      responseHeaders: { "content-type": "application/json" },
+      responseBody: '{"error":"boom"}',
+      isRetryable: false,
+    })
+    const result = MessageV2.fromError(error, { providerID: ProviderID.make("openai") }) as MessageV2.APIError
+    expect(result.data.isRetryable).toBe(true)
+  })
+})

package/test/session/revert-compact.test.ts

@@ -0,0 +1,286 @@
+import { describe, expect, test, beforeEach, afterEach } from "bun:test"
+import path from "path"
+import { Session } from "../../src/session"
+import { ModelID, ProviderID } from "../../src/provider/schema"
+import { SessionRevert } from "../../src/session/revert"
+import { SessionCompaction } from "../../src/session/compaction"
+import { MessageV2 } from "../../src/session/message-v2"
+import { Log } from "../../src/util/log"
+import { Instance } from "../../src/project/instance"
+import { MessageID, PartID } from "../../src/session/schema"
+import { tmpdir } from "../fixture/fixture"
+
+const projectRoot = path.join(__dirname, "../..")
+Log.init({ print: false })
+
+describe("revert + compact workflow", () => {
+  test("should properly handle compact command after revert", async () => {
+    await using tmp = await tmpdir({ git: true })
+    await Instance.provide({
+      directory: tmp.path,
+      fn: async () => {
+        // Create a session
+        const session = await Session.create({})
+        const sessionID = session.id
+
+        // Create a user message
+        const userMsg1 = await Session.updateMessage({
+          id: MessageID.ascending(),
+          role: "user",
+          sessionID,
+          agent: "default",
+          model: {
+            providerID: ProviderID.make("openai"),
+            modelID: ModelID.make("gpt-4"),
+          },
+          time: {
+            created: Date.now(),
+          },
+        })
+
+        // Add a text part to the user message
+        await Session.updatePart({
+          id: PartID.ascending(),
+          messageID: userMsg1.id,
+          sessionID,
+          type: "text",
+          text: "Hello, please help me",
+        })
+
+        // Create an assistant response message
+        const assistantMsg1: MessageV2.Assistant = {
+          id: MessageID.ascending(),
+          role: "assistant",
+          sessionID,
+          mode: "default",
+          agent: "default",
+          path: {
+            cwd: tmp.path,
+            root: tmp.path,
+          },
+          cost: 0,
+          tokens: {
+            output: 0,
+            input: 0,
+            reasoning: 0,
+            cache: { read: 0, write: 0 },
+          },
+          modelID: ModelID.make("gpt-4"),
+          providerID: ProviderID.make("openai"),
+          parentID: userMsg1.id,
+          time: {
+            created: Date.now(),
+          },
+          finish: "end_turn",
+        }
+        await Session.updateMessage(assistantMsg1)
+
+        // Add a text part to the assistant message
+        await Session.updatePart({
+          id: PartID.ascending(),
+          messageID: assistantMsg1.id,
+          sessionID,
+          type: "text",
+          text: "Sure, I'll help you!",
+        })
+
+        // Create another user message
+        const userMsg2 = await Session.updateMessage({
+          id: MessageID.ascending(),
+          role: "user",
+          sessionID,
+          agent: "default",
+          model: {
+            providerID: ProviderID.make("openai"),
+            modelID: ModelID.make("gpt-4"),
+          },
+          time: {
+            created: Date.now(),
+          },
+        })
+
+        await Session.updatePart({
+          id: PartID.ascending(),
+          messageID: userMsg2.id,
+          sessionID,
+          type: "text",
+          text: "What's the capital of France?",
+        })
+
+        // Create another assistant response
+        const assistantMsg2: MessageV2.Assistant = {
+          id: MessageID.ascending(),
+          role: "assistant",
+          sessionID,
+          mode: "default",
+          agent: "default",
+          path: {
+            cwd: tmp.path,
+            root: tmp.path,
+          },
+          cost: 0,
+          tokens: {
+            output: 0,
+            input: 0,
+            reasoning: 0,
+            cache: { read: 0, write: 0 },
+          },
+          modelID: ModelID.make("gpt-4"),
+          providerID: ProviderID.make("openai"),
+          parentID: userMsg2.id,
+          time: {
+            created: Date.now(),
+          },
+          finish: "end_turn",
+        }
+        await Session.updateMessage(assistantMsg2)
+
+        await Session.updatePart({
+          id: PartID.ascending(),
+          messageID: assistantMsg2.id,
+          sessionID,
+          type: "text",
+          text: "The capital of France is Paris.",
+        })
+
+        // Verify messages before revert
+        let messages = await Session.messages({ sessionID })
+        expect(messages.length).toBe(4) // 2 user + 2 assistant messages
+        const messageIds = messages.map((m) => m.info.id)
+        expect(messageIds).toContain(userMsg1.id)
+        expect(messageIds).toContain(userMsg2.id)
+        expect(messageIds).toContain(assistantMsg1.id)
+        expect(messageIds).toContain(assistantMsg2.id)
+
+        // Revert the last user message (userMsg2)
+        await SessionRevert.revert({
+          sessionID,
+          messageID: userMsg2.id,
+        })
+
+        // Check that revert state is set
+        let sessionInfo = await Session.get(sessionID)
+        expect(sessionInfo.revert).toBeDefined()
+        const revertMessageID = sessionInfo.revert?.messageID
+        expect(revertMessageID).toBeDefined()
+
+        // Messages should still be in the list (not removed yet, just marked for revert)
+        messages = await Session.messages({ sessionID })
+        expect(messages.length).toBe(4)
+
+        // Now clean up the revert state (this is what the compact endpoint should do)
+        await SessionRevert.cleanup(sessionInfo)
+
+        // After cleanup, the reverted messages (those after the revert point) should be removed
+        messages = await Session.messages({ sessionID })
+        const remainingIds = messages.map((m) => m.info.id)
+        // The revert point is somewhere in the message chain, so we should have fewer messages
+        expect(messages.length).toBeLessThan(4)
+        // userMsg2 and assistantMsg2 should be removed (they come after the revert point)
+        expect(remainingIds).not.toContain(userMsg2.id)
+        expect(remainingIds).not.toContain(assistantMsg2.id)
+
+        // Revert state should be cleared
+        sessionInfo = await Session.get(sessionID)
+        expect(sessionInfo.revert).toBeUndefined()
+
+        // Clean up
+        await Session.remove(sessionID)
+      },
+    })
+  })
+
+  test("should properly clean up revert state before creating compaction message", async () => {
+    await using tmp = await tmpdir({ git: true })
+    await Instance.provide({
+      directory: tmp.path,
+      fn: async () => {
+        // Create a session
+        const session = await Session.create({})
+        const sessionID = session.id
+
+        // Create initial messages
+        const userMsg = await Session.updateMessage({
+          id: MessageID.ascending(),
+          role: "user",
+          sessionID,
+          agent: "default",
+          model: {
+            providerID: ProviderID.make("openai"),
+            modelID: ModelID.make("gpt-4"),
+          },
+          time: {
+            created: Date.now(),
+          },
+        })
+
+        await Session.updatePart({
+          id: PartID.ascending(),
+          messageID: userMsg.id,
+          sessionID,
+          type: "text",
+          text: "Hello",
+        })
+
+        const assistantMsg: MessageV2.Assistant = {
+          id: MessageID.ascending(),
+          role: "assistant",
+          sessionID,
+          mode: "default",
+          agent: "default",
+          path: {
+            cwd: tmp.path,
+            root: tmp.path,
+          },
+          cost: 0,
+          tokens: {
+            output: 0,
+            input: 0,
+            reasoning: 0,
+            cache: { read: 0, write: 0 },
+          },
+          modelID: ModelID.make("gpt-4"),
+          providerID: ProviderID.make("openai"),
+          parentID: userMsg.id,
+          time: {
+            created: Date.now(),
+          },
+          finish: "end_turn",
+        }
+        await Session.updateMessage(assistantMsg)
+
+        await Session.updatePart({
+          id: PartID.ascending(),
+          messageID: assistantMsg.id,
+          sessionID,
+          type: "text",
+          text: "Hi there!",
+        })
+
+        // Revert the user message
+        await SessionRevert.revert({
+          sessionID,
+          messageID: userMsg.id,
+        })
+
+        // Check that revert state is set
+        let sessionInfo = await Session.get(sessionID)
+        expect(sessionInfo.revert).toBeDefined()
+
+        // Simulate what the compact endpoint does: cleanup revert before creating compaction
+        await SessionRevert.cleanup(sessionInfo)
+
+        // Verify revert state is cleared
+        sessionInfo = await Session.get(sessionID)
+        expect(sessionInfo.revert).toBeUndefined()
+
+        // Verify messages are properly cleaned up
+        const messages = await Session.messages({ sessionID })
+        expect(messages.length).toBe(0) // All messages should be reverted
+
+        // Clean up
+        await Session.remove(sessionID)
+      },
+    })
+  })
+})

package/test/session/session.test.ts

@@ -0,0 +1,142 @@
+import { describe, expect, test } from "bun:test"
+import path from "path"
+import { Session } from "../../src/session"
+import { Bus } from "../../src/bus"
+import { Log } from "../../src/util/log"
+import { Instance } from "../../src/project/instance"
+import { MessageV2 } from "../../src/session/message-v2"
+import { MessageID, PartID } from "../../src/session/schema"
+
+const projectRoot = path.join(__dirname, "../..")
+Log.init({ print: false })
+
+describe("session.created event", () => {
+  test("should emit session.created event when session is created", async () => {
+    await Instance.provide({
+      directory: projectRoot,
+      fn: async () => {
+        let eventReceived = false
+        let receivedInfo: Session.Info | undefined
+
+        const unsub = Bus.subscribe(Session.Event.Created, (event) => {
+          eventReceived = true
+          receivedInfo = event.properties.info as Session.Info
+        })
+
+        const session = await Session.create({})
+
+        await new Promise((resolve) => setTimeout(resolve, 100))
+
+        unsub()
+
+        expect(eventReceived).toBe(true)
+        expect(receivedInfo).toBeDefined()
+        expect(receivedInfo?.id).toBe(session.id)
+        expect(receivedInfo?.projectID).toBe(session.projectID)
+        expect(receivedInfo?.directory).toBe(session.directory)
+        expect(receivedInfo?.title).toBe(session.title)
+
+        await Session.remove(session.id)
+      },
+    })
+  })
+
+  test("session.created event should be emitted before session.updated", async () => {
+    await Instance.provide({
+      directory: projectRoot,
+      fn: async () => {
+        const events: string[] = []
+
+        const unsubCreated = Bus.subscribe(Session.Event.Created, () => {
+          events.push("created")
+        })
+
+        const unsubUpdated = Bus.subscribe(Session.Event.Updated, () => {
+          events.push("updated")
+        })
+
+        const session = await Session.create({})
+
+        await new Promise((resolve) => setTimeout(resolve, 100))
+
+        unsubCreated()
+        unsubUpdated()
+
+        expect(events).toContain("created")
+        expect(events).toContain("updated")
+        expect(events.indexOf("created")).toBeLessThan(events.indexOf("updated"))
+
+        await Session.remove(session.id)
+      },
+    })
+  })
+})
+
+describe("step-finish token propagation via Bus event", () => {
+  test(
+    "non-zero tokens propagate through PartUpdated event",
+    async () => {
+      await Instance.provide({
+        directory: projectRoot,
+        fn: async () => {
+          const session = await Session.create({})
+
+          const messageID = MessageID.ascending()
+          await Session.updateMessage({
+            id: messageID,
+            sessionID: session.id,
+            role: "user",
+            time: { created: Date.now() },
+            agent: "user",
+            model: { providerID: "test", modelID: "test" },
+            tools: {},
+            mode: "",
+          } as unknown as MessageV2.Info)
+
+          let received: MessageV2.Part | undefined
+          const unsub = Bus.subscribe(MessageV2.Event.PartUpdated, (event) => {
+            received = event.properties.part
+          })
+
+          const tokens = {
+            total: 1500,
+            input: 500,
+            output: 800,
+            reasoning: 200,
+            cache: { read: 100, write: 50 },
+          }
+
+          const partInput = {
+            id: PartID.ascending(),
+            messageID,
+            sessionID: session.id,
+            type: "step-finish" as const,
+            reason: "stop",
+            cost: 0.005,
+            tokens,
+          }
+
+          await Session.updatePart(partInput)
+
+          await new Promise((resolve) => setTimeout(resolve, 100))
+
+          expect(received).toBeDefined()
+          expect(received!.type).toBe("step-finish")
+          const finish = received as MessageV2.StepFinishPart
+          expect(finish.tokens.input).toBe(500)
+          expect(finish.tokens.output).toBe(800)
+          expect(finish.tokens.reasoning).toBe(200)
+          expect(finish.tokens.total).toBe(1500)
+          expect(finish.tokens.cache.read).toBe(100)
+          expect(finish.tokens.cache.write).toBe(50)
+          expect(finish.cost).toBe(0.005)
+          expect(received).not.toBe(partInput)
+
+          unsub()
+          await Session.remove(session.id)
+        },
+      })
+    },
+    { timeout: 30000 },
+  )
+})