@stonerzju/opencode 1.2.17 → 1.2.18

package/test/session/prompt.test.ts

@@ -1,211 +0,0 @@
-import path from "path"
-import { describe, expect, test } from "bun:test"
-import { fileURLToPath } from "url"
-import { Instance } from "../../src/project/instance"
-import { Session } from "../../src/session"
-import { MessageV2 } from "../../src/session/message-v2"
-import { SessionPrompt } from "../../src/session/prompt"
-import { Log } from "../../src/util/log"
-import { tmpdir } from "../fixture/fixture"
-
-Log.init({ print: false })
-
-describe("session.prompt missing file", () => {
-  test("does not fail the prompt when a file part is missing", async () => {
-    await using tmp = await tmpdir({
-      git: true,
-      config: {
-        agent: {
-          build: {
-            model: "openai/gpt-5.2",
-          },
-        },
-      },
-    })
-
-    await Instance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        const session = await Session.create({})
-
-        const missing = path.join(tmp.path, "does-not-exist.ts")
-        const msg = await SessionPrompt.prompt({
-          sessionID: session.id,
-          agent: "build",
-          noReply: true,
-          parts: [
-            { type: "text", text: "please review @does-not-exist.ts" },
-            {
-              type: "file",
-              mime: "text/plain",
-              url: `file://${missing}`,
-              filename: "does-not-exist.ts",
-            },
-          ],
-        })
-
-        if (msg.info.role !== "user") throw new Error("expected user message")
-
-        const hasFailure = msg.parts.some(
-          (part) => part.type === "text" && part.synthetic && part.text.includes("Read tool failed to read"),
-        )
-        expect(hasFailure).toBe(true)
-
-        await Session.remove(session.id)
-      },
-    })
-  })
-
-  test("keeps stored part order stable when file resolution is async", async () => {
-    await using tmp = await tmpdir({
-      git: true,
-      config: {
-        agent: {
-          build: {
-            model: "openai/gpt-5.2",
-          },
-        },
-      },
-    })
-
-    await Instance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        const session = await Session.create({})
-
-        const missing = path.join(tmp.path, "still-missing.ts")
-        const msg = await SessionPrompt.prompt({
-          sessionID: session.id,
-          agent: "build",
-          noReply: true,
-          parts: [
-            {
-              type: "file",
-              mime: "text/plain",
-              url: `file://${missing}`,
-              filename: "still-missing.ts",
-            },
-            { type: "text", text: "after-file" },
-          ],
-        })
-
-        if (msg.info.role !== "user") throw new Error("expected user message")
-
-        const stored = await MessageV2.get({
-          sessionID: session.id,
-          messageID: msg.info.id,
-        })
-        const text = stored.parts.filter((part) => part.type === "text").map((part) => part.text)
-
-        expect(text[0]?.startsWith("Called the Read tool with the following input:")).toBe(true)
-        expect(text[1]?.includes("Read tool failed to read")).toBe(true)
-        expect(text[2]).toBe("after-file")
-
-        await Session.remove(session.id)
-      },
-    })
-  })
-})
-
-describe("session.prompt special characters", () => {
-  test("handles filenames with # character", async () => {
-    await using tmp = await tmpdir({
-      git: true,
-      init: async (dir) => {
-        await Bun.write(path.join(dir, "file#name.txt"), "special content\n")
-      },
-    })
-
-    await Instance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        const session = await Session.create({})
-        const template = "Read @file#name.txt"
-        const parts = await SessionPrompt.resolvePromptParts(template)
-        const fileParts = parts.filter((part) => part.type === "file")
-
-        expect(fileParts.length).toBe(1)
-        expect(fileParts[0].filename).toBe("file#name.txt")
-        expect(fileParts[0].url).toContain("%23")
-
-        const decodedPath = fileURLToPath(fileParts[0].url)
-        expect(decodedPath).toBe(path.join(tmp.path, "file#name.txt"))
-
-        const message = await SessionPrompt.prompt({
-          sessionID: session.id,
-          parts,
-          noReply: true,
-        })
-        const stored = await MessageV2.get({ sessionID: session.id, messageID: message.info.id })
-        const textParts = stored.parts.filter((part) => part.type === "text")
-        const hasContent = textParts.some((part) => part.text.includes("special content"))
-        expect(hasContent).toBe(true)
-
-        await Session.remove(session.id)
-      },
-    })
-  })
-})
-
-describe("session.prompt agent variant", () => {
-  test("applies agent variant only when using agent model", async () => {
-    const prev = process.env.OPENAI_API_KEY
-    process.env.OPENAI_API_KEY = "test-openai-key"
-
-    try {
-      await using tmp = await tmpdir({
-        git: true,
-        config: {
-          agent: {
-            build: {
-              model: "openai/gpt-5.2",
-              variant: "xhigh",
-            },
-          },
-        },
-      })
-
-      await Instance.provide({
-        directory: tmp.path,
-        fn: async () => {
-          const session = await Session.create({})
-
-          const other = await SessionPrompt.prompt({
-            sessionID: session.id,
-            agent: "build",
-            model: { providerID: "opencode", modelID: "kimi-k2.5-free" },
-            noReply: true,
-            parts: [{ type: "text", text: "hello" }],
-          })
-          if (other.info.role !== "user") throw new Error("expected user message")
-          expect(other.info.variant).toBeUndefined()
-
-          const match = await SessionPrompt.prompt({
-            sessionID: session.id,
-            agent: "build",
-            noReply: true,
-            parts: [{ type: "text", text: "hello again" }],
-          })
-          if (match.info.role !== "user") throw new Error("expected user message")
-          expect(match.info.model).toEqual({ providerID: "openai", modelID: "gpt-5.2" })
-          expect(match.info.variant).toBe("xhigh")
-
-          const override = await SessionPrompt.prompt({
-            sessionID: session.id,
-            agent: "build",
-            noReply: true,
-            variant: "high",
-            parts: [{ type: "text", text: "hello third" }],
-          })
-          if (override.info.role !== "user") throw new Error("expected user message")
-          expect(override.info.variant).toBe("high")
-
-          await Session.remove(session.id)
-        },
-      })
-    } finally {
-      if (prev === undefined) delete process.env.OPENAI_API_KEY
-      else process.env.OPENAI_API_KEY = prev
-    }
-  })
-})

package/test/session/retry.test.ts

@@ -1,188 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import type { NamedError } from "@opencode-ai/util/error"
-import { APICallError } from "ai"
-import { SessionRetry } from "../../src/session/retry"
-import { MessageV2 } from "../../src/session/message-v2"
-
-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("sleep caps delay to max 32-bit signed integer to avoid TimeoutOverflowWarning", async () => {
-    const controller = new AbortController()
-
-    const warnings: string[] = []
-    const originalWarn = process.emitWarning
-    process.emitWarning = (warning: string | Error) => {
-      warnings.push(typeof warning === "string" ? warning : warning.message)
-    }
-
-    const promise = SessionRetry.sleep(2_560_914_000, controller.signal)
-    controller.abort()
-
-    try {
-      await promise
-    } catch {}
-
-    process.emitWarning = originalWarn
-    expect(warnings.some((w) => w.includes("TimeoutOverflowWarning"))).toBe(false)
-  })
-})
-
-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("handles json messages without code", () => {
-    const error = wrap(JSON.stringify({ error: { message: "no_kv_space" } }))
-    expect(SessionRetry.retryable(error)).toBe(`{"error":{"message":"no_kv_space"}}`)
-  })
-
-  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()
-  })
-})
-
-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 Bun.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: "test" })
-
-      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: "openai" }) as MessageV2.APIError
-    expect(result.data.isRetryable).toBe(true)
-  })
-})

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

@@ -1,285 +0,0 @@
-import { describe, expect, test, beforeEach, afterEach } from "bun:test"
-import path from "path"
-import { Session } from "../../src/session"
-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 { Identifier } from "../../src/id/id"
-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: Identifier.ascending("message"),
-          role: "user",
-          sessionID,
-          agent: "default",
-          model: {
-            providerID: "openai",
-            modelID: "gpt-4",
-          },
-          time: {
-            created: Date.now(),
-          },
-        })
-
-        // Add a text part to the user message
-        await Session.updatePart({
-          id: Identifier.ascending("part"),
-          messageID: userMsg1.id,
-          sessionID,
-          type: "text",
-          text: "Hello, please help me",
-        })
-
-        // Create an assistant response message
-        const assistantMsg1: MessageV2.Assistant = {
-          id: Identifier.ascending("message"),
-          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: "gpt-4",
-          providerID: "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: Identifier.ascending("part"),
-          messageID: assistantMsg1.id,
-          sessionID,
-          type: "text",
-          text: "Sure, I'll help you!",
-        })
-
-        // Create another user message
-        const userMsg2 = await Session.updateMessage({
-          id: Identifier.ascending("message"),
-          role: "user",
-          sessionID,
-          agent: "default",
-          model: {
-            providerID: "openai",
-            modelID: "gpt-4",
-          },
-          time: {
-            created: Date.now(),
-          },
-        })
-
-        await Session.updatePart({
-          id: Identifier.ascending("part"),
-          messageID: userMsg2.id,
-          sessionID,
-          type: "text",
-          text: "What's the capital of France?",
-        })
-
-        // Create another assistant response
-        const assistantMsg2: MessageV2.Assistant = {
-          id: Identifier.ascending("message"),
-          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: "gpt-4",
-          providerID: "openai",
-          parentID: userMsg2.id,
-          time: {
-            created: Date.now(),
-          },
-          finish: "end_turn",
-        }
-        await Session.updateMessage(assistantMsg2)
-
-        await Session.updatePart({
-          id: Identifier.ascending("part"),
-          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: Identifier.ascending("message"),
-          role: "user",
-          sessionID,
-          agent: "default",
-          model: {
-            providerID: "openai",
-            modelID: "gpt-4",
-          },
-          time: {
-            created: Date.now(),
-          },
-        })
-
-        await Session.updatePart({
-          id: Identifier.ascending("part"),
-          messageID: userMsg.id,
-          sessionID,
-          type: "text",
-          text: "Hello",
-        })
-
-        const assistantMsg: MessageV2.Assistant = {
-          id: Identifier.ascending("message"),
-          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: "gpt-4",
-          providerID: "openai",
-          parentID: userMsg.id,
-          time: {
-            created: Date.now(),
-          },
-          finish: "end_turn",
-        }
-        await Session.updateMessage(assistantMsg)
-
-        await Session.updatePart({
-          id: Identifier.ascending("part"),
-          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)
-      },
-    })
-  })
-})