artificial-code 1.17.13

package/test/project/worktree.test.ts

@@ -0,0 +1,324 @@
+import { afterEach, describe, expect } from "bun:test"
+import path from "path"
+import { LayerNode } from "@ac/core/effect/layer-node"
+import { FSUtil } from "@ac/core/fs-util"
+import { Cause, Deferred, Effect, Exit, Fiber } from "effect"
+import { GlobalBus, type GlobalEvent } from "../../src/bus/global"
+import { Git } from "../../src/git"
+import { InstanceBootstrap } from "../../src/project/bootstrap"
+import { InstanceStore } from "../../src/project/instance-store"
+import { Worktree } from "../../src/worktree"
+import { disposeAllInstances, provideInstance, TestInstance } from "../fixture/fixture"
+import { testEffect } from "../lib/effect"
+
+const it = testEffect(
+  LayerNode.compile(LayerNode.group([Worktree.node, FSUtil.node, Git.node]), [
+    [InstanceStore.bootstrapNode, InstanceBootstrap.node],
+  ]),
+)
+const wintest = process.platform !== "win32" ? it.instance : it.instance.skip
+
+function normalize(input: string) {
+  return input.replace(/\\/g, "/").toLowerCase()
+}
+
+const waitReady = Effect.fn("WorktreeTest.waitReady")(function* () {
+  const ready = yield* Deferred.make<{ name: string; branch?: string }>()
+  const on = (evt: GlobalEvent) => {
+    if (evt.payload.type !== Worktree.Event.Ready.type) return
+    Deferred.doneUnsafe(ready, Effect.succeed(evt.payload.properties))
+  }
+
+  GlobalBus.on("event", on)
+  yield* Effect.addFinalizer(() => Effect.sync(() => GlobalBus.off("event", on)))
+
+  return yield* Deferred.await(ready).pipe(
+    Effect.timeoutOrElse({
+      duration: "10 seconds",
+      orElse: () => Effect.fail(new Error("timed out waiting for worktree.ready")),
+    }),
+  )
+})
+
+const removeCreatedWorktree = (directory: string) =>
+  Effect.gen(function* () {
+    const svc = yield* Worktree.Service
+    const ok = yield* svc.remove({ directory })
+    if (!ok) return yield* Effect.fail(new Error(`failed to remove worktree ${directory}`))
+  })
+
+const withCreatedWorktree = <A, E, R>(
+  input: Parameters<Worktree.Interface["create"]>[0],
+  use: (created: { info: Worktree.Info; ready: { name: string; branch?: string } }) => Effect.Effect<A, E, R>,
+) =>
+  Effect.acquireUseRelease(
+    Effect.gen(function* () {
+      const svc = yield* Worktree.Service
+      const ready = yield* waitReady().pipe(Effect.forkScoped)
+      const info = yield* svc.create(input)
+      const props = yield* Fiber.join(ready)
+      return { info, ready: props }
+    }),
+    use,
+    ({ info }) => removeCreatedWorktree(info.directory),
+  )
+
+const git = Effect.fn("WorktreeTest.git")(function* (cwd: string, args: string[]) {
+  const service = yield* Git.Service
+  const result = yield* service.run(args, { cwd })
+  if (result.exitCode !== 0) throw new Error(`git ${args.join(" ")} failed: ${result.stderr.toString("utf8")}`)
+  return result.text()
+})
+
+const gitResult = Effect.fn("WorktreeTest.gitResult")(function* (cwd: string, args: string[]) {
+  const service = yield* Git.Service
+  return yield* service.run(args, { cwd })
+})
+
+describe("Worktree", () => {
+  afterEach(() => disposeAllInstances())
+
+  describe("makeWorktreeInfo", () => {
+    it.instance(
+      "returns info with name, branch, and directory",
+      () =>
+        Effect.gen(function* () {
+          const svc = yield* Worktree.Service
+          const info = yield* svc.makeWorktreeInfo()
+
+          expect(info.name).toBeDefined()
+          expect(typeof info.name).toBe("string")
+          expect(info.branch).toBe(`opencode/${info.name}`)
+          expect(info.directory).toContain(info.name)
+        }),
+      { git: true },
+    )
+
+    it.instance(
+      "uses provided name as base",
+      () =>
+        Effect.gen(function* () {
+          const svc = yield* Worktree.Service
+          const info = yield* svc.makeWorktreeInfo({ name: "my-feature" })
+
+          expect(info.name).toBe("my-feature")
+          expect(info.branch).toBe("opencode/my-feature")
+        }),
+      { git: true },
+    )
+
+    it.instance(
+      "slugifies the provided name",
+      () =>
+        Effect.gen(function* () {
+          const svc = yield* Worktree.Service
+          const info = yield* svc.makeWorktreeInfo({ name: "My Feature Branch!" })
+
+          expect(info.name).toBe("my-feature-branch")
+        }),
+      { git: true },
+    )
+
+    it.instance(
+      "omits branch for detached info",
+      () =>
+        Effect.gen(function* () {
+          const test = yield* TestInstance
+          const svc = yield* Worktree.Service
+          yield* git(test.directory, ["branch", "opencode/my-feature"])
+
+          const info = yield* svc.makeWorktreeInfo({ name: "my-feature", detached: true })
+
+          expect(info.name).toBe("my-feature")
+          expect(info.branch).toBeUndefined()
+        }),
+      { git: true },
+    )
+
+    it.instance("fails with NotGitError for non-git directories", () =>
+      Effect.gen(function* () {
+        const svc = yield* Worktree.Service
+        const exit = yield* Effect.exit(svc.makeWorktreeInfo())
+
+        expect(Exit.isFailure(exit)).toBe(true)
+        if (Exit.isFailure(exit)) {
+          const error = Cause.squash(exit.cause)
+          expect(error).toBeInstanceOf(Worktree.NotGitError)
+          if (error instanceof Worktree.NotGitError) expect(error._tag).toBe("WorktreeNotGitError")
+        }
+      }),
+    )
+
+    wintest(
+      "creates detached git worktree when info has no branch",
+      () =>
+        Effect.gen(function* () {
+          const test = yield* TestInstance
+          const svc = yield* Worktree.Service
+          const info = yield* svc.makeWorktreeInfo({ name: "detached-test", detached: true })
+          const ready = yield* waitReady().pipe(Effect.forkScoped)
+          yield* svc.createFromInfo(info)
+
+          const list = yield* git(test.directory, ["worktree", "list", "--porcelain"])
+          const normalizedList = normalize(list)
+          const normalizedDir = normalize(info.directory)
+          expect(normalizedList).toContain(normalizedDir)
+
+          const branch = yield* gitResult(info.directory, ["symbolic-ref", "-q", "--short", "HEAD"])
+          expect(branch.exitCode).not.toBe(0)
+
+          const props = yield* Fiber.join(ready)
+          expect(props.name).toBe(info.name)
+          expect(props.branch).toBeUndefined()
+
+          yield* svc.remove({ directory: info.directory })
+        }),
+      { git: true },
+    )
+  })
+
+  describe("create + remove lifecycle", () => {
+    it.instance(
+      "create returns worktree info and remove cleans up",
+      () =>
+        withCreatedWorktree(undefined, ({ info }) =>
+          Effect.gen(function* () {
+            expect(info.name).toBeDefined()
+            expect(info.branch ?? "").toStartWith("opencode/")
+            expect(info.directory).toBeDefined()
+          }),
+        ),
+      { git: true },
+    )
+
+    it.instance(
+      "create returns after setup and fires Event.Ready after bootstrap",
+      () =>
+        withCreatedWorktree(undefined, ({ info, ready }) =>
+          Effect.gen(function* () {
+            const svc = yield* Worktree.Service
+
+            expect(info.name).toBeDefined()
+            expect(info.branch ?? "").toStartWith("opencode/")
+
+            expect(ready.name).toBe(info.name)
+            expect(ready.branch).toBe(info.branch)
+
+            const list = yield* svc.list()
+            expect(list).toContainEqual(expect.objectContaining({ name: info.name, branch: info.branch }))
+          }),
+        ),
+      { git: true },
+    )
+
+    it.instance(
+      "lists the active linked worktree but not the project checkout",
+      () =>
+        withCreatedWorktree(undefined, ({ info }) =>
+          Effect.gen(function* () {
+            const test = yield* TestInstance
+            const svc = yield* Worktree.Service
+            const list = yield* svc.list().pipe(provideInstance(info.directory))
+
+            expect(list.map((item) => item.name)).toContain(info.name)
+            expect(list.map((item) => item.name)).not.toContain(path.basename(test.directory).toLowerCase())
+          }),
+        ),
+      { git: true },
+    )
+
+    it.instance(
+      "create with custom name",
+      () =>
+        withCreatedWorktree({ name: "test-workspace" }, ({ info }) =>
+          Effect.gen(function* () {
+            expect(info.name).toBe("test-workspace")
+            expect(info.branch).toBe("opencode/test-workspace")
+          }),
+        ),
+      { git: true },
+    )
+  })
+
+  describe("createFromInfo", () => {
+    wintest(
+      "creates git worktree and boots asynchronously",
+      () =>
+        Effect.gen(function* () {
+          const test = yield* TestInstance
+          const svc = yield* Worktree.Service
+          const info = yield* svc.makeWorktreeInfo({ name: "from-info-test" })
+          const ready = yield* waitReady().pipe(Effect.forkScoped)
+          yield* svc.createFromInfo(info)
+
+          const list = yield* git(test.directory, ["worktree", "list", "--porcelain"])
+          const normalizedList = list.replace(/\\/g, "/")
+          const normalizedDir = info.directory.replace(/\\/g, "/")
+          expect(normalizedList).toContain(normalizedDir)
+
+          yield* Fiber.join(ready)
+          yield* removeCreatedWorktree(info.directory)
+        }),
+      { git: true },
+    )
+  })
+
+  describe("list", () => {
+    it.instance(
+      "uses parent folder name when worktree basename matches the primary worktree",
+      () =>
+        Effect.gen(function* () {
+          const test = yield* TestInstance
+          const fs = yield* FSUtil.Service
+          const svc = yield* Worktree.Service
+          const parent = path.join(path.dirname(test.directory), `${path.basename(test.directory)}-parent`)
+          const target = path.join(parent, path.basename(test.directory))
+          const branch = `same-basename-list-${Date.now()}`
+
+          yield* fs.ensureDir(parent)
+          yield* git(test.directory, ["worktree", "add", "-b", branch, target])
+
+          const list = yield* svc.list()
+          const directory = yield* fs.realPath(target).pipe(Effect.catch(() => Effect.succeed(target)))
+
+          expect(list.map((item) => ({ ...item, directory: normalize(item.directory) }))).toContainEqual({
+            name: path.basename(parent),
+            branch,
+            directory: normalize(directory),
+          })
+
+          yield* svc.remove({ directory: target })
+        }),
+      { git: true },
+    )
+  })
+
+  describe("remove edge cases", () => {
+    it.instance(
+      "remove non-existent directory succeeds silently",
+      () =>
+        Effect.gen(function* () {
+          const test = yield* TestInstance
+          const svc = yield* Worktree.Service
+          const ok = yield* svc.remove({ directory: path.join(test.directory, "does-not-exist") })
+          expect(ok).toBe(true)
+        }),
+      { git: true },
+    )
+
+    it.instance("fails with NotGitError for non-git directories", () =>
+      Effect.gen(function* () {
+        const test = yield* TestInstance
+        const svc = yield* Worktree.Service
+        const exit = yield* Effect.exit(svc.remove({ directory: path.join(test.directory, "fake") }))
+
+        expect(Exit.isFailure(exit)).toBe(true)
+        if (Exit.isFailure(exit)) {
+          const error = Cause.squash(exit.cause)
+          expect(error).toBeInstanceOf(Worktree.NotGitError)
+          if (error instanceof Worktree.NotGitError) expect(error._tag).toBe("WorktreeNotGitError")
+        }
+      }),
+    )
+  })
+})

package/test/provider/amazon-bedrock.test.ts

@@ -0,0 +1,361 @@
+import { afterEach, describe, expect, test } from "bun:test"
+import { LayerNode } from "@ac/core/effect/layer-node"
+import { Effect } from "effect"
+import path from "path"
+import { unlink } from "fs/promises"
+import { Global } from "@ac/core/global"
+import { Filesystem } from "@/util/filesystem"
+import { Env } from "../../src/env"
+import { Provider } from "@/provider/provider"
+
+import { disposeAllInstances } from "../fixture/fixture"
+import { testEffect } from "../lib/effect"
+import { ProviderV2 } from "@ac/core/provider"
+import { ModelV2 } from "@ac/core/model"
+
+const it = testEffect(LayerNode.compile(LayerNode.group([Provider.node, Env.node])))
+
+const originalEnv = new Map<string, string | undefined>()
+
+const set = (k: string, v: string) =>
+  Effect.gen(function* () {
+    if (!originalEnv.has(k)) originalEnv.set(k, process.env[k])
+    process.env[k] = v
+    yield* Env.use.set(k, v)
+  })
+
+afterEach(async () => {
+  for (const [key, value] of originalEnv) {
+    if (value === undefined) delete process.env[key]
+    else process.env[key] = value
+  }
+  originalEnv.clear()
+  await disposeAllInstances()
+})
+
+const list = Provider.use.list()
+
+const mantleModelConfig = {
+  provider: { npm: "@ai-sdk/amazon-bedrock/mantle" },
+  limit: { context: 272_000, output: 32_000 },
+  modalities: {
+    input: ["text", "image", "pdf"] as Array<"text" | "image" | "pdf">,
+    output: ["text"] as Array<"text">,
+  },
+}
+
+const withAuthJson = (contents: string) =>
+  Effect.acquireRelease(
+    Effect.promise(async () => {
+      const authPath = path.join(Global.Path.data, "auth.json")
+      let original: string | undefined
+      try {
+        original = await Filesystem.readText(authPath)
+      } catch {
+        original = undefined
+      }
+      await Filesystem.write(authPath, contents)
+      return { authPath, original }
+    }),
+    ({ authPath, original }) =>
+      Effect.promise(async () => {
+        if (original !== undefined) {
+          await Filesystem.write(authPath, original)
+          return
+        }
+        await unlink(authPath).catch(() => undefined)
+      }),
+  )
+
+it.instance(
+  "Bedrock: config region takes precedence over AWS_REGION env var",
+  () =>
+    Effect.gen(function* () {
+      yield* set("AWS_REGION", "us-east-1")
+      yield* set("AWS_PROFILE", "default")
+      const providers = yield* list
+      expect(providers[ProviderV2.ID.amazonBedrock]).toBeDefined()
+      expect(providers[ProviderV2.ID.amazonBedrock].options?.region).toBe("eu-west-1")
+    }),
+  { config: { provider: { "amazon-bedrock": { options: { region: "eu-west-1" } } } } },
+)
+
+it.instance("Bedrock: falls back to AWS_REGION env var when no config region", () =>
+  Effect.gen(function* () {
+    yield* set("AWS_REGION", "eu-west-1")
+    yield* set("AWS_PROFILE", "default")
+    const providers = yield* list
+    expect(providers[ProviderV2.ID.amazonBedrock]).toBeDefined()
+    expect(providers[ProviderV2.ID.amazonBedrock].options?.region).toBe("eu-west-1")
+  }),
+)
+
+it.instance(
+  "Bedrock: loads when bearer token from auth.json is present",
+  () =>
+    Effect.gen(function* () {
+      yield* withAuthJson(JSON.stringify({ "amazon-bedrock": { type: "api", key: "test-bearer-token" } }))
+      yield* set("AWS_PROFILE", "")
+      yield* set("AWS_ACCESS_KEY_ID", "")
+      yield* set("AWS_BEARER_TOKEN_BEDROCK", "")
+      const providers = yield* list
+      expect(providers[ProviderV2.ID.amazonBedrock]).toBeDefined()
+      expect(providers[ProviderV2.ID.amazonBedrock].options?.region).toBe("eu-west-1")
+    }),
+  { config: { provider: { "amazon-bedrock": { options: { region: "eu-west-1" } } } } },
+)
+
+it.instance(
+  "Bedrock Mantle: GPT-5.5 uses Responses API and OpenAI base path",
+  () =>
+    Effect.gen(function* () {
+      yield* set("AWS_REGION", "")
+      yield* set("AWS_PROFILE", "")
+      yield* set("AWS_ACCESS_KEY_ID", "")
+      yield* set("AWS_BEARER_TOKEN_BEDROCK", "")
+      const model = yield* Provider.use.getModel(ProviderV2.ID.amazonBedrock, ModelV2.ID.make("openai.gpt-5.5"))
+      const language = yield* Provider.use.getLanguage(model)
+      expect((language as { provider: string }).provider).toBe("bedrock-mantle.responses")
+      expect((language as { modelId: string }).modelId).toBe("openai.gpt-5.5")
+      expect(
+        (language as unknown as { config: { url: (input: { path: string; modelId: string }) => string } }).config.url({
+          path: "/responses",
+          modelId: "openai.gpt-5.5",
+        }),
+      ).toBe("https://bedrock-mantle.us-east-2.api.aws/openai/v1/responses")
+    }),
+  {
+    config: {
+      provider: {
+        "amazon-bedrock": {
+          options: { region: "us-east-2", apiKey: "test-bearer-token" },
+          models: {
+            "openai.gpt-5.5": {
+              ...mantleModelConfig,
+              provider: {
+                npm: "@ai-sdk/amazon-bedrock/mantle",
+                api: "https://bedrock-mantle.${AWS_REGION}.api.aws/openai/v1",
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+)
+
+it.instance(
+  "Bedrock Mantle: GPT OSS safeguard uses Chat Completions and Mantle base path",
+  () =>
+    Effect.gen(function* () {
+      yield* set("AWS_BEARER_TOKEN_BEDROCK", "test-bearer-token")
+      const model = yield* Provider.use.getModel(
+        ProviderV2.ID.amazonBedrock,
+        ModelV2.ID.make("openai.gpt-oss-safeguard-120b"),
+      )
+      const language = yield* Provider.use.getLanguage(model)
+      expect((language as { provider: string }).provider).toBe("bedrock-mantle.chat")
+      expect((language as { modelId: string }).modelId).toBe("openai.gpt-oss-safeguard-120b")
+      expect(
+        (language as unknown as { config: { url: (input: { path: string; modelId: string }) => string } }).config.url({
+          path: "/chat/completions",
+          modelId: "openai.gpt-oss-safeguard-120b",
+        }),
+      ).toBe("https://bedrock-mantle.us-east-1.api.aws/v1/chat/completions")
+    }),
+  {
+    config: {
+      provider: {
+        "amazon-bedrock": {
+          options: { region: "us-east-1" },
+          models: { "openai.gpt-oss-safeguard-120b": mantleModelConfig },
+        },
+      },
+    },
+  },
+)
+
+it.instance(
+  "Bedrock: config profile takes precedence over AWS_PROFILE env var",
+  () =>
+    Effect.gen(function* () {
+      yield* set("AWS_PROFILE", "default")
+      yield* set("AWS_ACCESS_KEY_ID", "test-key-id")
+      const providers = yield* list
+      expect(providers[ProviderV2.ID.amazonBedrock]).toBeDefined()
+      expect(providers[ProviderV2.ID.amazonBedrock].options?.region).toBe("us-east-1")
+    }),
+  {
+    config: {
+      provider: { "amazon-bedrock": { options: { profile: "my-custom-profile", region: "us-east-1" } } },
+    },
+  },
+)
+
+it.instance(
+  "Bedrock: includes custom endpoint in options when specified",
+  () =>
+    Effect.gen(function* () {
+      yield* set("AWS_PROFILE", "default")
+      const providers = yield* list
+      expect(providers[ProviderV2.ID.amazonBedrock]).toBeDefined()
+      expect(providers[ProviderV2.ID.amazonBedrock].options?.endpoint).toBe(
+        "https://bedrock-runtime.us-east-1.vpce-xxxxx.amazonaws.com",
+      )
+    }),
+  {
+    config: {
+      provider: {
+        "amazon-bedrock": {
+          options: { endpoint: "https://bedrock-runtime.us-east-1.vpce-xxxxx.amazonaws.com" },
+        },
+      },
+    },
+  },
+)
+
+it.instance(
+  "Bedrock: autoloads when AWS_WEB_IDENTITY_TOKEN_FILE is present",
+  () =>
+    Effect.gen(function* () {
+      yield* set("AWS_WEB_IDENTITY_TOKEN_FILE", "/var/run/secrets/eks.amazonaws.com/serviceaccount/token")
+      yield* set("AWS_ROLE_ARN", "arn:aws:iam::123456789012:role/my-eks-role")
+      yield* set("AWS_PROFILE", "")
+      yield* set("AWS_ACCESS_KEY_ID", "")
+      const providers = yield* list
+      expect(providers[ProviderV2.ID.amazonBedrock]).toBeDefined()
+      expect(providers[ProviderV2.ID.amazonBedrock].options?.region).toBe("us-east-1")
+    }),
+  { config: { provider: { "amazon-bedrock": { options: { region: "us-east-1" } } } } },
+)
+
+// Cross-region inference profile prefix handling.
+// Models from models.dev may come with prefixes already (e.g. us., eu., global.).
+// These should NOT be double-prefixed when passed to the SDK.
+
+it.instance(
+  "Bedrock: model with us. prefix should not be double-prefixed",
+  () =>
+    Effect.gen(function* () {
+      yield* set("AWS_PROFILE", "default")
+      const providers = yield* list
+      expect(providers[ProviderV2.ID.amazonBedrock]).toBeDefined()
+      expect(providers[ProviderV2.ID.amazonBedrock].models["us.anthropic.claude-opus-4-5-20251101-v1:0"]).toBeDefined()
+    }),
+  {
+    config: {
+      provider: {
+        "amazon-bedrock": {
+          options: { region: "us-east-1" },
+          models: { "us.anthropic.claude-opus-4-5-20251101-v1:0": { name: "Claude Opus 4.5 (US)" } },
+        },
+      },
+    },
+  },
+)
+
+it.instance(
+  "Bedrock: model with global. prefix should not be prefixed",
+  () =>
+    Effect.gen(function* () {
+      yield* set("AWS_PROFILE", "default")
+      const providers = yield* list
+      expect(providers[ProviderV2.ID.amazonBedrock]).toBeDefined()
+      expect(
+        providers[ProviderV2.ID.amazonBedrock].models["global.anthropic.claude-opus-4-5-20251101-v1:0"],
+      ).toBeDefined()
+    }),
+  {
+    config: {
+      provider: {
+        "amazon-bedrock": {
+          options: { region: "us-east-1" },
+          models: { "global.anthropic.claude-opus-4-5-20251101-v1:0": { name: "Claude Opus 4.5 (Global)" } },
+        },
+      },
+    },
+  },
+)
+
+it.instance(
+  "Bedrock: model with eu. prefix should not be double-prefixed",
+  () =>
+    Effect.gen(function* () {
+      yield* set("AWS_PROFILE", "default")
+      const providers = yield* list
+      expect(providers[ProviderV2.ID.amazonBedrock]).toBeDefined()
+      expect(providers[ProviderV2.ID.amazonBedrock].models["eu.anthropic.claude-opus-4-5-20251101-v1:0"]).toBeDefined()
+    }),
+  {
+    config: {
+      provider: {
+        "amazon-bedrock": {
+          options: { region: "eu-west-1" },
+          models: { "eu.anthropic.claude-opus-4-5-20251101-v1:0": { name: "Claude Opus 4.5 (EU)" } },
+        },
+      },
+    },
+  },
+)
+
+it.instance(
+  "Bedrock: model without prefix in US region should get us. prefix added",
+  () =>
+    Effect.gen(function* () {
+      yield* set("AWS_PROFILE", "default")
+      const providers = yield* list
+      expect(providers[ProviderV2.ID.amazonBedrock]).toBeDefined()
+      expect(providers[ProviderV2.ID.amazonBedrock].models["anthropic.claude-opus-4-5-20251101-v1:0"]).toBeDefined()
+    }),
+  {
+    config: {
+      provider: {
+        "amazon-bedrock": {
+          options: { region: "us-east-1" },
+          models: { "anthropic.claude-opus-4-5-20251101-v1:0": { name: "Claude Opus 4.5" } },
+        },
+      },
+    },
+  },
+)
+
+// Direct unit tests for cross-region inference profile prefix detection.
+describe("Bedrock cross-region prefix detection", () => {
+  const crossRegionPrefixes = ["global.", "us.", "eu.", "jp.", "apac.", "au."]
+
+  test("should detect global. prefix", () => {
+    expect(crossRegionPrefixes.some((p) => "global.anthropic.claude-opus-4-5-20251101-v1:0".startsWith(p))).toBe(true)
+  })
+
+  test("should detect us. prefix", () => {
+    expect(crossRegionPrefixes.some((p) => "us.anthropic.claude-opus-4-5-20251101-v1:0".startsWith(p))).toBe(true)
+  })
+
+  test("should detect eu. prefix", () => {
+    expect(crossRegionPrefixes.some((p) => "eu.anthropic.claude-opus-4-5-20251101-v1:0".startsWith(p))).toBe(true)
+  })
+
+  test("should detect jp. prefix", () => {
+    expect(crossRegionPrefixes.some((p) => "jp.anthropic.claude-sonnet-4-20250514-v1:0".startsWith(p))).toBe(true)
+  })
+
+  test("should detect apac. prefix", () => {
+    expect(crossRegionPrefixes.some((p) => "apac.anthropic.claude-sonnet-4-20250514-v1:0".startsWith(p))).toBe(true)
+  })
+
+  test("should detect au. prefix", () => {
+    expect(crossRegionPrefixes.some((p) => "au.anthropic.claude-sonnet-4-5-20250929-v1:0".startsWith(p))).toBe(true)
+  })
+
+  test("should NOT detect prefix for non-prefixed model", () => {
+    expect(crossRegionPrefixes.some((p) => "anthropic.claude-opus-4-5-20251101-v1:0".startsWith(p))).toBe(false)
+  })
+
+  test("should NOT detect prefix for amazon nova models", () => {
+    expect(crossRegionPrefixes.some((p) => "amazon.nova-pro-v1:0".startsWith(p))).toBe(false)
+  })
+
+  test("should NOT detect prefix for cohere models", () => {
+    expect(crossRegionPrefixes.some((p) => "cohere.command-r-plus-v1:0".startsWith(p))).toBe(false)
+  })
+})