@stonerzju/opencode 1.2.17 → 1.2.18

package/test/server/session-select.test.ts

@@ -1,78 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import path from "path"
-import { Session } from "../../src/session"
-import { Log } from "../../src/util/log"
-import { Instance } from "../../src/project/instance"
-import { Server } from "../../src/server/server"
-
-const projectRoot = path.join(__dirname, "../..")
-Log.init({ print: false })
-
-describe("tui.selectSession endpoint", () => {
-  test("should return 200 when called with valid session", async () => {
-    await Instance.provide({
-      directory: projectRoot,
-      fn: async () => {
-        // #given
-        const session = await Session.create({})
-
-        // #when
-        const app = Server.App()
-        const response = await app.request("/tui/select-session", {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({ sessionID: session.id }),
-        })
-
-        // #then
-        expect(response.status).toBe(200)
-        const body = await response.json()
-        expect(body).toBe(true)
-
-        await Session.remove(session.id)
-      },
-    })
-  })
-
-  test("should return 404 when session does not exist", async () => {
-    await Instance.provide({
-      directory: projectRoot,
-      fn: async () => {
-        // #given
-        const nonExistentSessionID = "ses_nonexistent123"
-
-        // #when
-        const app = Server.App()
-        const response = await app.request("/tui/select-session", {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({ sessionID: nonExistentSessionID }),
-        })
-
-        // #then
-        expect(response.status).toBe(404)
-      },
-    })
-  })
-
-  test("should return 400 when session ID format is invalid", async () => {
-    await Instance.provide({
-      directory: projectRoot,
-      fn: async () => {
-        // #given
-        const invalidSessionID = "invalid_session_id"
-
-        // #when
-        const app = Server.App()
-        const response = await app.request("/tui/select-session", {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({ sessionID: invalidSessionID }),
-        })
-
-        // #then
-        expect(response.status).toBe(400)
-      },
-    })
-  })
-})

package/test/session/compaction.test.ts

@@ -1,423 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import path from "path"
-import { SessionCompaction } from "../../src/session/compaction"
-import { Token } from "../../src/util/token"
-import { Instance } from "../../src/project/instance"
-import { Log } from "../../src/util/log"
-import { tmpdir } from "../fixture/fixture"
-import { Session } from "../../src/session"
-import type { Provider } from "../../src/provider/provider"
-
-Log.init({ print: false })
-
-function createModel(opts: {
-  context: number
-  output: number
-  input?: number
-  cost?: Provider.Model["cost"]
-  npm?: string
-}): Provider.Model {
-  return {
-    id: "test-model",
-    providerID: "test",
-    name: "Test",
-    limit: {
-      context: opts.context,
-      input: opts.input,
-      output: opts.output,
-    },
-    cost: opts.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: opts.npm ?? "@ai-sdk/anthropic" },
-    options: {},
-  } as Provider.Model
-}
-
-describe("session.compaction.isOverflow", () => {
-  test("returns true when token count exceeds usable context", async () => {
-    await using tmp = await tmpdir()
-    await Instance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        const model = createModel({ context: 100_000, output: 32_000 })
-        const tokens = { input: 75_000, output: 5_000, reasoning: 0, cache: { read: 0, write: 0 } }
-        expect(await SessionCompaction.isOverflow({ tokens, model })).toBe(true)
-      },
-    })
-  })
-
-  test("returns false when token count within usable context", async () => {
-    await using tmp = await tmpdir()
-    await Instance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        const model = createModel({ context: 200_000, output: 32_000 })
-        const tokens = { input: 100_000, output: 10_000, reasoning: 0, cache: { read: 0, write: 0 } }
-        expect(await SessionCompaction.isOverflow({ tokens, model })).toBe(false)
-      },
-    })
-  })
-
-  test("includes cache.read in token count", async () => {
-    await using tmp = await tmpdir()
-    await Instance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        const model = createModel({ context: 100_000, output: 32_000 })
-        const tokens = { input: 60_000, output: 10_000, reasoning: 0, cache: { read: 10_000, write: 0 } }
-        expect(await SessionCompaction.isOverflow({ tokens, model })).toBe(true)
-      },
-    })
-  })
-
-  test("respects input limit for input caps", async () => {
-    await using tmp = await tmpdir()
-    await Instance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        const model = createModel({ context: 400_000, input: 272_000, output: 128_000 })
-        const tokens = { input: 271_000, output: 1_000, reasoning: 0, cache: { read: 2_000, write: 0 } }
-        expect(await SessionCompaction.isOverflow({ tokens, model })).toBe(true)
-      },
-    })
-  })
-
-  test("returns false when input/output are within input caps", async () => {
-    await using tmp = await tmpdir()
-    await Instance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        const model = createModel({ context: 400_000, input: 272_000, output: 128_000 })
-        const tokens = { input: 200_000, output: 20_000, reasoning: 0, cache: { read: 10_000, write: 0 } }
-        expect(await SessionCompaction.isOverflow({ tokens, model })).toBe(false)
-      },
-    })
-  })
-
-  test("returns false when output within limit with input caps", async () => {
-    await using tmp = await tmpdir()
-    await Instance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        const model = createModel({ context: 200_000, input: 120_000, output: 10_000 })
-        const tokens = { input: 50_000, output: 9_999, reasoning: 0, cache: { read: 0, write: 0 } }
-        expect(await SessionCompaction.isOverflow({ tokens, model })).toBe(false)
-      },
-    })
-  })
-
-  // ─── Bug reproduction tests ───────────────────────────────────────────
-  // These tests demonstrate that when limit.input is set, isOverflow()
-  // does not subtract any headroom for the next model response. This means
-  // compaction only triggers AFTER we've already consumed the full input
-  // budget, leaving zero room for the next API call's output tokens.
-  //
-  // Compare: without limit.input, usable = context - output (reserves space).
-  // With limit.input, usable = limit.input (reserves nothing).
-  //
-  // Related issues: #10634, #8089, #11086, #12621
-  // Open PRs: #6875, #12924
-
-  test("BUG: no headroom when limit.input is set — compaction should trigger near boundary but does not", async () => {
-    await using tmp = await tmpdir()
-    await Instance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        // Simulate Claude with prompt caching: input limit = 200K, output limit = 32K
-        const model = createModel({ context: 200_000, input: 200_000, output: 32_000 })
-
-        // We've used 198K tokens total. Only 2K under the input limit.
-        // On the next turn, the full conversation (198K) becomes input,
-        // plus the model needs room to generate output — this WILL overflow.
-        const tokens = { input: 180_000, output: 15_000, reasoning: 0, cache: { read: 3_000, write: 0 } }
-        // count = 180K + 3K + 15K = 198K
-        // usable = limit.input = 200K (no output subtracted!)
-        // 198K > 200K = false → no compaction triggered
-
-        // WITHOUT limit.input: usable = 200K - 32K = 168K, and 198K > 168K = true ✓
-        // WITH limit.input: usable = 200K, and 198K > 200K = false ✗
-
-        // With 198K used and only 2K headroom, the next turn will overflow.
-        // Compaction MUST trigger here.
-        expect(await SessionCompaction.isOverflow({ tokens, model })).toBe(true)
-      },
-    })
-  })
-
-  test("BUG: without limit.input, same token count correctly triggers compaction", async () => {
-    await using tmp = await tmpdir()
-    await Instance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        // Same model but without limit.input — uses context - output instead
-        const model = createModel({ context: 200_000, output: 32_000 })
-
-        // Same token usage as above
-        const tokens = { input: 180_000, output: 15_000, reasoning: 0, cache: { read: 3_000, write: 0 } }
-        // count = 198K
-        // usable = context - output = 200K - 32K = 168K
-        // 198K > 168K = true → compaction correctly triggered
-
-        const result = await SessionCompaction.isOverflow({ tokens, model })
-        expect(result).toBe(true) // ← Correct: headroom is reserved
-      },
-    })
-  })
-
-  test("BUG: asymmetry — limit.input model allows 30K more usage before compaction than equivalent model without it", async () => {
-    await using tmp = await tmpdir()
-    await Instance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        // Two models with identical context/output limits, differing only in limit.input
-        const withInputLimit = createModel({ context: 200_000, input: 200_000, output: 32_000 })
-        const withoutInputLimit = createModel({ context: 200_000, output: 32_000 })
-
-        // 170K total tokens — well above context-output (168K) but below input limit (200K)
-        const tokens = { input: 166_000, output: 10_000, reasoning: 0, cache: { read: 5_000, write: 0 } }
-
-        const withLimit = await SessionCompaction.isOverflow({ tokens, model: withInputLimit })
-        const withoutLimit = await SessionCompaction.isOverflow({ tokens, model: withoutInputLimit })
-
-        // Both models have identical real capacity — they should agree:
-        expect(withLimit).toBe(true) // should compact (170K leaves no room for 32K output)
-        expect(withoutLimit).toBe(true) // correctly compacts (170K > 168K)
-      },
-    })
-  })
-
-  test("returns false when model context limit is 0", async () => {
-    await using tmp = await tmpdir()
-    await Instance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        const model = createModel({ context: 0, output: 32_000 })
-        const tokens = { input: 100_000, output: 10_000, reasoning: 0, cache: { read: 0, write: 0 } }
-        expect(await SessionCompaction.isOverflow({ tokens, model })).toBe(false)
-      },
-    })
-  })
-
-  test("returns false when compaction.auto is disabled", async () => {
-    await using tmp = await tmpdir({
-      init: async (dir) => {
-        await Bun.write(
-          path.join(dir, "opencode.json"),
-          JSON.stringify({
-            compaction: { auto: false },
-          }),
-        )
-      },
-    })
-    await Instance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        const model = createModel({ context: 100_000, output: 32_000 })
-        const tokens = { input: 75_000, output: 5_000, reasoning: 0, cache: { read: 0, write: 0 } }
-        expect(await SessionCompaction.isOverflow({ tokens, model })).toBe(false)
-      },
-    })
-  })
-})
-
-describe("util.token.estimate", () => {
-  test("estimates tokens from text (4 chars per token)", () => {
-    const text = "x".repeat(4000)
-    expect(Token.estimate(text)).toBe(1000)
-  })
-
-  test("estimates tokens from larger text", () => {
-    const text = "y".repeat(20_000)
-    expect(Token.estimate(text)).toBe(5000)
-  })
-
-  test("returns 0 for empty string", () => {
-    expect(Token.estimate("")).toBe(0)
-  })
-})
-
-describe("session.getUsage", () => {
-  test("normalizes standard usage to token format", () => {
-    const model = createModel({ context: 100_000, output: 32_000 })
-    const result = Session.getUsage({
-      model,
-      usage: {
-        inputTokens: 1000,
-        outputTokens: 500,
-        totalTokens: 1500,
-      },
-    })
-
-    expect(result.tokens.input).toBe(1000)
-    expect(result.tokens.output).toBe(500)
-    expect(result.tokens.reasoning).toBe(0)
-    expect(result.tokens.cache.read).toBe(0)
-    expect(result.tokens.cache.write).toBe(0)
-  })
-
-  test("extracts cached tokens to cache.read", () => {
-    const model = createModel({ context: 100_000, output: 32_000 })
-    const result = Session.getUsage({
-      model,
-      usage: {
-        inputTokens: 1000,
-        outputTokens: 500,
-        totalTokens: 1500,
-        cachedInputTokens: 200,
-      },
-    })
-
-    expect(result.tokens.input).toBe(800)
-    expect(result.tokens.cache.read).toBe(200)
-  })
-
-  test("handles anthropic cache write metadata", () => {
-    const model = createModel({ context: 100_000, output: 32_000 })
-    const result = Session.getUsage({
-      model,
-      usage: {
-        inputTokens: 1000,
-        outputTokens: 500,
-        totalTokens: 1500,
-      },
-      metadata: {
-        anthropic: {
-          cacheCreationInputTokens: 300,
-        },
-      },
-    })
-
-    expect(result.tokens.cache.write).toBe(300)
-  })
-
-  test("does not subtract cached tokens for anthropic provider", () => {
-    const model = createModel({ context: 100_000, output: 32_000 })
-    const result = Session.getUsage({
-      model,
-      usage: {
-        inputTokens: 1000,
-        outputTokens: 500,
-        totalTokens: 1500,
-        cachedInputTokens: 200,
-      },
-      metadata: {
-        anthropic: {},
-      },
-    })
-
-    expect(result.tokens.input).toBe(1000)
-    expect(result.tokens.cache.read).toBe(200)
-  })
-
-  test("handles reasoning tokens", () => {
-    const model = createModel({ context: 100_000, output: 32_000 })
-    const result = Session.getUsage({
-      model,
-      usage: {
-        inputTokens: 1000,
-        outputTokens: 500,
-        totalTokens: 1500,
-        reasoningTokens: 100,
-      },
-    })
-
-    expect(result.tokens.reasoning).toBe(100)
-  })
-
-  test("handles undefined optional values gracefully", () => {
-    const model = createModel({ context: 100_000, output: 32_000 })
-    const result = Session.getUsage({
-      model,
-      usage: {
-        inputTokens: 0,
-        outputTokens: 0,
-        totalTokens: 0,
-      },
-    })
-
-    expect(result.tokens.input).toBe(0)
-    expect(result.tokens.output).toBe(0)
-    expect(result.tokens.reasoning).toBe(0)
-    expect(result.tokens.cache.read).toBe(0)
-    expect(result.tokens.cache.write).toBe(0)
-    expect(Number.isNaN(result.cost)).toBe(false)
-  })
-
-  test("calculates cost correctly", () => {
-    const model = createModel({
-      context: 100_000,
-      output: 32_000,
-      cost: {
-        input: 3,
-        output: 15,
-        cache: { read: 0.3, write: 3.75 },
-      },
-    })
-    const result = Session.getUsage({
-      model,
-      usage: {
-        inputTokens: 1_000_000,
-        outputTokens: 100_000,
-        totalTokens: 1_100_000,
-      },
-    })
-
-    expect(result.cost).toBe(3 + 1.5)
-  })
-
-  test.each(["@ai-sdk/anthropic", "@ai-sdk/amazon-bedrock", "@ai-sdk/google-vertex/anthropic"])(
-    "computes total from components for %s models",
-    (npm) => {
-      const model = createModel({ context: 100_000, output: 32_000, npm })
-      const usage = {
-        inputTokens: 1000,
-        outputTokens: 500,
-        // These providers typically report total as input + output only,
-        // excluding cache read/write.
-        totalTokens: 1500,
-        cachedInputTokens: 200,
-      }
-      if (npm === "@ai-sdk/amazon-bedrock") {
-        const result = Session.getUsage({
-          model,
-          usage,
-          metadata: {
-            bedrock: {
-              usage: {
-                cacheWriteInputTokens: 300,
-              },
-            },
-          },
-        })
-
-        expect(result.tokens.input).toBe(1000)
-        expect(result.tokens.cache.read).toBe(200)
-        expect(result.tokens.cache.write).toBe(300)
-        expect(result.tokens.total).toBe(2000)
-        return
-      }
-
-      const result = Session.getUsage({
-        model,
-        usage,
-        metadata: {
-          anthropic: {
-            cacheCreationInputTokens: 300,
-          },
-        },
-      })
-
-      expect(result.tokens.input).toBe(1000)
-      expect(result.tokens.cache.read).toBe(200)
-      expect(result.tokens.cache.write).toBe(300)
-      expect(result.tokens.total).toBe(2000)
-    },
-  )
-})

package/test/session/instruction.test.ts

@@ -1,170 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from "bun:test"
-import path from "path"
-import { InstructionPrompt } from "../../src/session/instruction"
-import { Instance } from "../../src/project/instance"
-import { Global } from "../../src/global"
-import { tmpdir } from "../fixture/fixture"
-
-describe("InstructionPrompt.resolve", () => {
-  test("returns empty when AGENTS.md is at project root (already in systemPaths)", async () => {
-    await using tmp = await tmpdir({
-      init: async (dir) => {
-        await Bun.write(path.join(dir, "AGENTS.md"), "# Root Instructions")
-        await Bun.write(path.join(dir, "src", "file.ts"), "const x = 1")
-      },
-    })
-    await Instance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        const system = await InstructionPrompt.systemPaths()
-        expect(system.has(path.join(tmp.path, "AGENTS.md"))).toBe(true)
-
-        const results = await InstructionPrompt.resolve([], path.join(tmp.path, "src", "file.ts"), "test-message-1")
-        expect(results).toEqual([])
-      },
-    })
-  })
-
-  test("returns AGENTS.md from subdirectory (not in systemPaths)", async () => {
-    await using tmp = await tmpdir({
-      init: async (dir) => {
-        await Bun.write(path.join(dir, "subdir", "AGENTS.md"), "# Subdir Instructions")
-        await Bun.write(path.join(dir, "subdir", "nested", "file.ts"), "const x = 1")
-      },
-    })
-    await Instance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        const system = await InstructionPrompt.systemPaths()
-        expect(system.has(path.join(tmp.path, "subdir", "AGENTS.md"))).toBe(false)
-
-        const results = await InstructionPrompt.resolve(
-          [],
-          path.join(tmp.path, "subdir", "nested", "file.ts"),
-          "test-message-2",
-        )
-        expect(results.length).toBe(1)
-        expect(results[0].filepath).toBe(path.join(tmp.path, "subdir", "AGENTS.md"))
-      },
-    })
-  })
-
-  test("doesn't reload AGENTS.md when reading it directly", async () => {
-    await using tmp = await tmpdir({
-      init: async (dir) => {
-        await Bun.write(path.join(dir, "subdir", "AGENTS.md"), "# Subdir Instructions")
-        await Bun.write(path.join(dir, "subdir", "nested", "file.ts"), "const x = 1")
-      },
-    })
-    await Instance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        const filepath = path.join(tmp.path, "subdir", "AGENTS.md")
-        const system = await InstructionPrompt.systemPaths()
-        expect(system.has(filepath)).toBe(false)
-
-        const results = await InstructionPrompt.resolve([], filepath, "test-message-2")
-        expect(results).toEqual([])
-      },
-    })
-  })
-})
-
-describe("InstructionPrompt.systemPaths OPENCODE_CONFIG_DIR", () => {
-  let originalConfigDir: string | undefined
-
-  beforeEach(() => {
-    originalConfigDir = process.env["OPENCODE_CONFIG_DIR"]
-  })
-
-  afterEach(() => {
-    if (originalConfigDir === undefined) {
-      delete process.env["OPENCODE_CONFIG_DIR"]
-    } else {
-      process.env["OPENCODE_CONFIG_DIR"] = originalConfigDir
-    }
-  })
-
-  test("prefers OPENCODE_CONFIG_DIR AGENTS.md over global when both exist", async () => {
-    await using profileTmp = await tmpdir({
-      init: async (dir) => {
-        await Bun.write(path.join(dir, "AGENTS.md"), "# Profile Instructions")
-      },
-    })
-    await using globalTmp = await tmpdir({
-      init: async (dir) => {
-        await Bun.write(path.join(dir, "AGENTS.md"), "# Global Instructions")
-      },
-    })
-    await using projectTmp = await tmpdir()
-
-    process.env["OPENCODE_CONFIG_DIR"] = profileTmp.path
-    const originalGlobalConfig = Global.Path.config
-    ;(Global.Path as { config: string }).config = globalTmp.path
-
-    try {
-      await Instance.provide({
-        directory: projectTmp.path,
-        fn: async () => {
-          const paths = await InstructionPrompt.systemPaths()
-          expect(paths.has(path.join(profileTmp.path, "AGENTS.md"))).toBe(true)
-          expect(paths.has(path.join(globalTmp.path, "AGENTS.md"))).toBe(false)
-        },
-      })
-    } finally {
-      ;(Global.Path as { config: string }).config = originalGlobalConfig
-    }
-  })
-
-  test("falls back to global AGENTS.md when OPENCODE_CONFIG_DIR has no AGENTS.md", async () => {
-    await using profileTmp = await tmpdir()
-    await using globalTmp = await tmpdir({
-      init: async (dir) => {
-        await Bun.write(path.join(dir, "AGENTS.md"), "# Global Instructions")
-      },
-    })
-    await using projectTmp = await tmpdir()
-
-    process.env["OPENCODE_CONFIG_DIR"] = profileTmp.path
-    const originalGlobalConfig = Global.Path.config
-    ;(Global.Path as { config: string }).config = globalTmp.path
-
-    try {
-      await Instance.provide({
-        directory: projectTmp.path,
-        fn: async () => {
-          const paths = await InstructionPrompt.systemPaths()
-          expect(paths.has(path.join(profileTmp.path, "AGENTS.md"))).toBe(false)
-          expect(paths.has(path.join(globalTmp.path, "AGENTS.md"))).toBe(true)
-        },
-      })
-    } finally {
-      ;(Global.Path as { config: string }).config = originalGlobalConfig
-    }
-  })
-
-  test("uses global AGENTS.md when OPENCODE_CONFIG_DIR is not set", async () => {
-    await using globalTmp = await tmpdir({
-      init: async (dir) => {
-        await Bun.write(path.join(dir, "AGENTS.md"), "# Global Instructions")
-      },
-    })
-    await using projectTmp = await tmpdir()
-
-    delete process.env["OPENCODE_CONFIG_DIR"]
-    const originalGlobalConfig = Global.Path.config
-    ;(Global.Path as { config: string }).config = globalTmp.path
-
-    try {
-      await Instance.provide({
-        directory: projectTmp.path,
-        fn: async () => {
-          const paths = await InstructionPrompt.systemPaths()
-          expect(paths.has(path.join(globalTmp.path, "AGENTS.md"))).toBe(true)
-        },
-      })
-    } finally {
-      ;(Global.Path as { config: string }).config = originalGlobalConfig
-    }
-  })
-})