@neurocode-ai/core 1.18.8

package/test/plugin/provider-google-vertex.test.ts

@@ -0,0 +1,387 @@
+import { AISDK } from "@neurocode-ai/core/aisdk"
+import { describe, expect, mock } from "bun:test"
+import { Effect } from "effect"
+import { Catalog } from "@neurocode-ai/core/catalog"
+import { ModelV2 } from "@neurocode-ai/core/model"
+import { PluginV2 } from "@neurocode-ai/core/plugin"
+import { PluginHost } from "@neurocode-ai/core/plugin/host"
+import { GoogleVertexPlugin } from "@neurocode-ai/core/plugin/provider/google-vertex"
+import { ProviderV2 } from "@neurocode-ai/core/provider"
+import type { LanguageModelV3 } from "@ai-sdk/provider"
+import { testEffect } from "../lib/effect"
+import { PluginTestLayer } from "./fixture"
+
+const vertexOptions: Record<string, any>[] = []
+const googleAuthOptions: Record<string, any>[] = []
+const it = testEffect(PluginTestLayer)
+
+const addPlugin = Effect.fn(function* () {
+  const plugin = yield* PluginV2.Service
+  const aisdk = yield* AISDK.Service
+  const host = yield* PluginHost.make(plugin)
+  yield* GoogleVertexPlugin.effect(host)
+})
+
+function required<T>(value: T | undefined): T {
+  if (value === undefined) throw new Error("Expected value")
+  return value
+}
+
+function withEnv<A, E, R>(vars: Record<string, string | undefined>, effect: () => Effect.Effect<A, E, R>) {
+  return Effect.acquireUseRelease(
+    Effect.sync(() => {
+      const previous = Object.fromEntries(Object.keys(vars).map((key) => [key, process.env[key]]))
+      Object.entries(vars).forEach(([key, value]) => {
+        if (value === undefined) delete process.env[key]
+        else process.env[key] = value
+      })
+      return previous
+    }),
+    effect,
+    (previous) =>
+      Effect.sync(() =>
+        Object.entries(previous).forEach(([key, value]) => {
+          if (value === undefined) delete process.env[key]
+          else process.env[key] = value
+        }),
+      ),
+  )
+}
+
+function fakeSelectorSdk(calls: string[]) {
+  const make = (method: string) => (id: string) => {
+    calls.push(`${method}:${id}`)
+    return { modelId: id, provider: method, specificationVersion: "v3" } as unknown as LanguageModelV3
+  }
+  return {
+    responses: make("responses"),
+    messages: make("messages"),
+    chat: make("chat"),
+    languageModel: make("languageModel"),
+  }
+}
+
+void mock.module("@ai-sdk/google-vertex", () => ({
+  createVertex: (options: Record<string, any>) => {
+    vertexOptions.push(options)
+    return {
+      languageModel: (modelID: string) => ({ modelID, provider: "google-vertex", specificationVersion: "v3" }),
+    }
+  },
+}))
+
+void mock.module("google-auth-library", () => ({
+  GoogleAuth: class {
+    constructor(options: Record<string, any>) {
+      googleAuthOptions.push(options)
+    }
+
+    async getClient() {
+      return {
+        async getAccessToken() {
+          return { token: "vertex-token" }
+        },
+      }
+    }
+  },
+}))
+
+describe("GoogleVertexPlugin", () => {
+  it.effect("ignores OpenAI-compatible providers that are not Google Vertex", () =>
+    Effect.gen(function* () {
+      const catalog = yield* Catalog.Service
+      yield* catalog.transform((catalog) =>
+        catalog.provider.update(ProviderV2.ID.opencode, (provider) => {
+          provider.api = {
+            type: "aisdk",
+            package: "@ai-sdk/openai-compatible",
+            url: "https://neurocode.ai/zen/v1",
+          }
+        }),
+      )
+      yield* addPlugin()
+
+      const provider = required(yield* catalog.provider.get(ProviderV2.ID.opencode))
+      expect(provider.request.body).toEqual({})
+    }),
+  )
+
+  it.effect("resolves project and location from env using legacy precedence", () =>
+    withEnv(
+      {
+        GOOGLE_CLOUD_PROJECT: "google-cloud-project",
+        GCP_PROJECT: "gcp-project",
+        GCLOUD_PROJECT: "gcloud-project",
+        GOOGLE_VERTEX_LOCATION: "google-vertex-location",
+        GOOGLE_CLOUD_LOCATION: "google-cloud-location",
+        VERTEX_LOCATION: "vertex-location",
+      },
+      () =>
+        Effect.gen(function* () {
+          const catalog = yield* Catalog.Service
+          yield* catalog.transform((catalog) =>
+            catalog.provider.update(ProviderV2.ID.make("google-vertex"), (provider) => {
+              provider.api = {
+                type: "aisdk",
+                package: "@ai-sdk/openai-compatible",
+                url: "https://${GOOGLE_VERTEX_ENDPOINT}/v1/projects/${GOOGLE_VERTEX_PROJECT}/locations/${GOOGLE_VERTEX_LOCATION}",
+              }
+            }),
+          )
+          yield* addPlugin()
+          const provider = required(yield* catalog.provider.get(ProviderV2.ID.make("google-vertex")))
+          expect(provider.request.body.project).toBe("google-cloud-project")
+          expect(provider.request.body.location).toBe("google-vertex-location")
+          expect(provider.api).toEqual({
+            type: "aisdk",
+            package: "@ai-sdk/openai-compatible",
+            url: "https://google-vertex-location-aiplatform.googleapis.com/v1/projects/google-cloud-project/locations/google-vertex-location",
+          })
+        }),
+    ),
+  )
+
+  it.effect("resolves the advertised GOOGLE_VERTEX_PROJECT env for provider updates and SDKs", () =>
+    withEnv(
+      {
+        GOOGLE_VERTEX_PROJECT: "vertex-project",
+        GOOGLE_CLOUD_PROJECT: undefined,
+        GCP_PROJECT: undefined,
+        GCLOUD_PROJECT: undefined,
+        GOOGLE_VERTEX_LOCATION: "europe-west4",
+        GOOGLE_CLOUD_LOCATION: undefined,
+        VERTEX_LOCATION: undefined,
+      },
+      () =>
+        Effect.gen(function* () {
+          vertexOptions.length = 0
+          const plugin = yield* PluginV2.Service
+          const aisdk = yield* AISDK.Service
+          const catalog = yield* Catalog.Service
+          yield* catalog.transform((catalog) =>
+            catalog.provider.update(ProviderV2.ID.make("google-vertex"), (provider) => {
+              provider.api = {
+                type: "aisdk",
+                package: "@ai-sdk/openai-compatible",
+                url: "https://${GOOGLE_VERTEX_ENDPOINT}/v1/projects/${GOOGLE_VERTEX_PROJECT}/locations/${GOOGLE_VERTEX_LOCATION}",
+              }
+            }),
+          )
+          yield* addPlugin()
+          const provider = required(yield* catalog.provider.get(ProviderV2.ID.make("google-vertex")))
+          yield* aisdk.runSDK({
+            model: ModelV2.Info.make({
+              ...ModelV2.Info.empty(ProviderV2.ID.make("google-vertex"), ModelV2.ID.make("gemini")),
+              api: {
+                id: ModelV2.ID.make("gemini"),
+                type: "aisdk",
+                package: "@ai-sdk/google-vertex",
+              },
+            }),
+            package: "@ai-sdk/google-vertex",
+            options: { name: "google-vertex" },
+          })
+
+          expect(provider.request.body.project).toBe("vertex-project")
+          expect(provider.api).toEqual({
+            type: "aisdk",
+            package: "@ai-sdk/openai-compatible",
+            url: "https://europe-west4-aiplatform.googleapis.com/v1/projects/vertex-project/locations/europe-west4",
+          })
+          expect(vertexOptions[0].project).toBe("vertex-project")
+          expect(vertexOptions[0].location).toBe("europe-west4")
+        }),
+    ),
+  )
+
+  it.effect("keeps configured project and location over env and uses global endpoint", () =>
+    withEnv(
+      {
+        GOOGLE_CLOUD_PROJECT: "env-project",
+        GCP_PROJECT: "env-gcp-project",
+        GCLOUD_PROJECT: "env-gcloud-project",
+        GOOGLE_VERTEX_LOCATION: "env-location",
+        GOOGLE_CLOUD_LOCATION: "env-google-cloud-location",
+        VERTEX_LOCATION: "env-vertex-location",
+      },
+      () =>
+        Effect.gen(function* () {
+          const catalog = yield* Catalog.Service
+          yield* catalog.transform((catalog) =>
+            catalog.provider.update(ProviderV2.ID.make("google-vertex"), (provider) => {
+              provider.api = {
+                type: "aisdk",
+                package: "@ai-sdk/openai-compatible",
+                url: "https://${GOOGLE_VERTEX_ENDPOINT}/v1/projects/${GOOGLE_VERTEX_PROJECT}/locations/${GOOGLE_VERTEX_LOCATION}",
+              }
+              provider.request.body.project = "config-project"
+              provider.request.body.location = "global"
+            }),
+          )
+          yield* addPlugin()
+          const provider = required(yield* catalog.provider.get(ProviderV2.ID.make("google-vertex")))
+          expect(provider.request.body.project).toBe("config-project")
+          expect(provider.request.body.location).toBe("global")
+          expect(provider.api).toEqual({
+            type: "aisdk",
+            package: "@ai-sdk/openai-compatible",
+            url: "https://aiplatform.googleapis.com/v1/projects/config-project/locations/global",
+          })
+        }),
+    ),
+  )
+
+  it.effect("keeps OpenAI-compatible Vertex endpoint templates regional for eu", () =>
+    Effect.gen(function* () {
+      const catalog = yield* Catalog.Service
+      yield* catalog.transform((catalog) =>
+        catalog.provider.update(ProviderV2.ID.make("google-vertex"), (provider) => {
+          provider.api = {
+            type: "aisdk",
+            package: "@ai-sdk/openai-compatible",
+            url: "https://${GOOGLE_VERTEX_ENDPOINT}/v1/projects/${GOOGLE_VERTEX_PROJECT}/locations/${GOOGLE_VERTEX_LOCATION}",
+          }
+          provider.request.body.project = "config-project"
+          provider.request.body.location = "eu"
+        }),
+      )
+      yield* addPlugin()
+      const provider = required(yield* catalog.provider.get(ProviderV2.ID.make("google-vertex")))
+      expect(provider.api).toEqual({
+        type: "aisdk",
+        package: "@ai-sdk/openai-compatible",
+        url: "https://eu-aiplatform.googleapis.com/v1/projects/config-project/locations/eu",
+      })
+    }),
+  )
+
+  it.effect("defaults location to us-central1 when only project is configured", () =>
+    withEnv(
+      {
+        GOOGLE_CLOUD_PROJECT: undefined,
+        GCP_PROJECT: undefined,
+        GCLOUD_PROJECT: undefined,
+        GOOGLE_VERTEX_LOCATION: undefined,
+        GOOGLE_CLOUD_LOCATION: undefined,
+        VERTEX_LOCATION: undefined,
+      },
+      () =>
+        Effect.gen(function* () {
+          const catalog = yield* Catalog.Service
+          yield* catalog.transform((catalog) =>
+            catalog.provider.update(ProviderV2.ID.make("google-vertex"), (provider) => {
+              provider.api = { type: "aisdk", package: "@ai-sdk/google-vertex" }
+              provider.request.body.project = "config-project"
+            }),
+          )
+          yield* addPlugin()
+          const provider = required(yield* catalog.provider.get(ProviderV2.ID.make("google-vertex")))
+          expect(provider.request.body.project).toBe("config-project")
+          expect(provider.request.body.location).toBe("us-central1")
+        }),
+    ),
+  )
+
+  it.effect("does not pass Google auth fetch to the native Vertex SDK", () =>
+    withEnv(
+      {
+        GOOGLE_CLOUD_PROJECT: "env-project",
+        GOOGLE_VERTEX_LOCATION: "env-location",
+      },
+      () =>
+        Effect.gen(function* () {
+          vertexOptions.length = 0
+          const plugin = yield* PluginV2.Service
+          const aisdk = yield* AISDK.Service
+          yield* addPlugin()
+          yield* aisdk.runSDK({
+            model: ModelV2.Info.make({
+              ...ModelV2.Info.empty(ProviderV2.ID.make("google-vertex"), ModelV2.ID.make("gemini")),
+              api: {
+                id: ModelV2.ID.make("gemini"),
+                type: "aisdk",
+                package: "@ai-sdk/google-vertex",
+              },
+            }),
+            package: "@ai-sdk/google-vertex",
+            options: { name: "google-vertex" },
+          })
+          expect(vertexOptions).toHaveLength(1)
+          expect(vertexOptions[0].project).toBe("env-project")
+          expect(vertexOptions[0].location).toBe("env-location")
+          expect(vertexOptions[0].fetch).toBeUndefined()
+        }),
+    ),
+  )
+
+  it.effect("keeps Google auth fetch for OpenAI-compatible Vertex endpoints", () =>
+    Effect.gen(function* () {
+      googleAuthOptions.length = 0
+      const fetchCalls: { input: Parameters<typeof fetch>[0]; init?: RequestInit }[] = []
+      const plugin = yield* PluginV2.Service
+      const aisdk = yield* AISDK.Service
+      yield* addPlugin()
+      yield* aisdk.hook.sdk((evt) =>
+        Effect.promise(async () => {
+          if (evt.model.providerID !== "google-vertex") return
+          if (evt.package !== "@ai-sdk/openai-compatible") return
+          expect(typeof evt.options.fetch).toBe("function")
+          await evt.options.fetch("https://vertex.example", {
+            headers: { "x-test": "1" },
+          })
+        }),
+      )
+      const originalFetch = fetch
+      ;(globalThis as typeof globalThis & { fetch: typeof fetch }).fetch = (async (
+        input: Parameters<typeof fetch>[0],
+        init?: RequestInit,
+      ) => {
+        fetchCalls.push({ input, init })
+        return new Response("ok")
+      }) as typeof fetch
+      yield* Effect.acquireUseRelease(
+        Effect.void,
+        () =>
+          aisdk.runSDK({
+            model: ModelV2.Info.make({
+              ...ModelV2.Info.empty(ProviderV2.ID.make("google-vertex"), ModelV2.ID.make("gemini")),
+              api: {
+                id: ModelV2.ID.make("gemini"),
+                type: "aisdk",
+                package: "@ai-sdk/openai-compatible",
+              },
+            }),
+            package: "@ai-sdk/openai-compatible",
+            options: { name: "google-vertex" },
+          }),
+        () =>
+          Effect.sync(() => {
+            ;(globalThis as typeof globalThis & { fetch: typeof fetch }).fetch = originalFetch
+          }),
+      )
+      expect(fetchCalls).toHaveLength(1)
+      expect(googleAuthOptions).toEqual([{ scopes: ["https://www.googleapis.com/auth/cloud-platform"] }])
+      expect(fetchCalls[0].input).toBe("https://vertex.example")
+      expect(new Headers(fetchCalls[0].init?.headers).get("authorization")).toBe("Bearer vertex-token")
+      expect(new Headers(fetchCalls[0].init?.headers).get("x-test")).toBe("1")
+    }),
+  )
+
+  it.effect("trims model IDs before selecting language models", () =>
+    Effect.gen(function* () {
+      const plugin = yield* PluginV2.Service
+      const aisdk = yield* AISDK.Service
+      const calls: string[] = []
+      yield* addPlugin()
+      yield* aisdk.runLanguage({
+        model: ModelV2.Info.make({
+          ...ModelV2.Info.empty(ProviderV2.ID.make("google-vertex"), ModelV2.ID.make(" gemini-2.5-pro ")),
+          api: { id: ModelV2.ID.make(" gemini-2.5-pro "), type: "aisdk", package: "test-provider" },
+        }),
+        sdk: { languageModel: fakeSelectorSdk(calls).languageModel },
+        options: {},
+      })
+      expect(calls).toEqual(["languageModel:gemini-2.5-pro"])
+    }),
+  )
+})

package/test/plugin/provider-google.test.ts

@@ -0,0 +1,80 @@
+import { AISDK } from "@neurocode-ai/core/aisdk"
+import { describe, expect } from "bun:test"
+import { Effect } from "effect"
+import { ModelV2 } from "@neurocode-ai/core/model"
+import { PluginV2 } from "@neurocode-ai/core/plugin"
+import { PluginHost } from "@neurocode-ai/core/plugin/host"
+import { GooglePlugin } from "@neurocode-ai/core/plugin/provider/google"
+import { ProviderV2 } from "@neurocode-ai/core/provider"
+import { testEffect } from "../lib/effect"
+import { PluginTestLayer } from "./fixture"
+
+const it = testEffect(PluginTestLayer)
+
+const addPlugin = Effect.fn(function* () {
+  const plugin = yield* PluginV2.Service
+  const aisdk = yield* AISDK.Service
+  const host = yield* PluginHost.make(plugin)
+  yield* GooglePlugin.effect(host)
+})
+
+describe("GooglePlugin", () => {
+  it.effect("creates a Google Generative AI SDK for @ai-sdk/google using the provider ID as SDK name", () =>
+    Effect.gen(function* () {
+      const plugin = yield* PluginV2.Service
+      const aisdk = yield* AISDK.Service
+      yield* addPlugin()
+      const result = yield* aisdk.runSDK({
+        model: ModelV2.Info.make({
+          ...ModelV2.Info.empty(ProviderV2.ID.make("custom-google"), ModelV2.ID.make("gemini")),
+          api: { id: ModelV2.ID.make("gemini"), type: "aisdk", package: "@ai-sdk/google" },
+        }),
+        package: "@ai-sdk/google",
+        options: { name: "custom-google", apiKey: "test" },
+      })
+      expect(result.sdk).toBeDefined()
+      expect(result.sdk?.languageModel("gemini").provider).toBe("custom-google")
+    }),
+  )
+
+  it.effect("ignores non-Google SDK packages", () =>
+    Effect.gen(function* () {
+      const plugin = yield* PluginV2.Service
+      const aisdk = yield* AISDK.Service
+      yield* addPlugin()
+      const result = yield* aisdk.runSDK({
+        model: ModelV2.Info.make({
+          ...ModelV2.Info.empty(ProviderV2.ID.make("google"), ModelV2.ID.make("gemini")),
+          api: { id: ModelV2.ID.make("gemini"), type: "aisdk", package: "@ai-sdk/google" },
+        }),
+        package: "@ai-sdk/google-vertex",
+        options: { name: "google" },
+      })
+      expect(result.sdk).toBeUndefined()
+    }),
+  )
+
+  it.effect("uses default languageModel loading with provider ID parity", () =>
+    Effect.gen(function* () {
+      const plugin = yield* PluginV2.Service
+      const aisdk = yield* AISDK.Service
+      yield* addPlugin()
+      const sdkEvent = yield* aisdk.runSDK({
+        model: ModelV2.Info.make({
+          ...ModelV2.Info.empty(ProviderV2.ID.make("custom-google"), ModelV2.ID.make("alias")),
+          api: { id: ModelV2.ID.make("gemini-api"), type: "aisdk", package: "@ai-sdk/google" },
+        }),
+        package: "@ai-sdk/google",
+        options: { name: "custom-google", apiKey: "test" },
+      })
+      const result = yield* aisdk.runLanguage({
+        model: sdkEvent.model,
+        sdk: sdkEvent.sdk,
+        options: sdkEvent.options,
+      })
+      const language = result.language ?? result.sdk.languageModel(result.model.api.id)
+      expect(language.modelId).toBe("gemini-api")
+      expect(language.provider).toBe("custom-google")
+    }),
+  )
+})

package/test/plugin/provider-groq.test.ts

@@ -0,0 +1,121 @@
+import { AISDK } from "@neurocode-ai/core/aisdk"
+import { describe, expect } from "bun:test"
+import { createGroq } from "@ai-sdk/groq"
+import { Effect } from "effect"
+import { ModelV2 } from "@neurocode-ai/core/model"
+import { PluginV2 } from "@neurocode-ai/core/plugin"
+import { PluginHost } from "@neurocode-ai/core/plugin/host"
+import { GroqPlugin } from "@neurocode-ai/core/plugin/provider/groq"
+import { ProviderV2 } from "@neurocode-ai/core/provider"
+import { testEffect } from "../lib/effect"
+import { PluginTestLayer } from "./fixture"
+
+const it = testEffect(PluginTestLayer)
+
+const addPlugin = Effect.fn(function* () {
+  const plugin = yield* PluginV2.Service
+  const aisdk = yield* AISDK.Service
+  const host = yield* PluginHost.make(plugin)
+  yield* GroqPlugin.effect(host)
+})
+
+describe("GroqPlugin", () => {
+  it.effect("creates a Groq SDK for @ai-sdk/groq", () =>
+    Effect.gen(function* () {
+      const plugin = yield* PluginV2.Service
+      const aisdk = yield* AISDK.Service
+      yield* addPlugin()
+      const result = yield* aisdk.runSDK({
+        model: ModelV2.Info.make({
+          ...ModelV2.Info.empty(ProviderV2.ID.make("groq"), ModelV2.ID.make("llama")),
+          api: { id: ModelV2.ID.make("llama"), type: "aisdk", package: "@ai-sdk/groq" },
+        }),
+        package: "@ai-sdk/groq",
+        options: { name: "groq" },
+      })
+      expect(result.sdk).toBeDefined()
+    }),
+  )
+
+  it.effect("ignores non-Groq SDK packages", () =>
+    Effect.gen(function* () {
+      const plugin = yield* PluginV2.Service
+      const aisdk = yield* AISDK.Service
+      yield* addPlugin()
+      const result = yield* aisdk.runSDK({
+        model: ModelV2.Info.make({
+          ...ModelV2.Info.empty(ProviderV2.ID.make("groq"), ModelV2.ID.make("llama")),
+          api: { id: ModelV2.ID.make("llama"), type: "aisdk", package: "@ai-sdk/groq" },
+        }),
+        package: "@ai-sdk/openai-compatible",
+        options: { name: "groq" },
+      })
+      expect(result.sdk).toBeUndefined()
+    }),
+  )
+
+  it.effect("only matches the bundled @ai-sdk/groq package exactly", () =>
+    Effect.gen(function* () {
+      const plugin = yield* PluginV2.Service
+      const aisdk = yield* AISDK.Service
+      yield* addPlugin()
+      const result = yield* aisdk.runSDK({
+        model: ModelV2.Info.make({
+          ...ModelV2.Info.empty(ProviderV2.ID.make("groq"), ModelV2.ID.make("llama")),
+          api: { id: ModelV2.ID.make("llama"), type: "aisdk", package: "@ai-sdk/groq" },
+        }),
+        package: "@ai-sdk/groq/compat",
+        options: { name: "groq" },
+      })
+      expect(result.sdk).toBeUndefined()
+    }),
+  )
+
+  it.effect("matches the old bundled Groq SDK provider naming", () =>
+    Effect.gen(function* () {
+      const plugin = yield* PluginV2.Service
+      const aisdk = yield* AISDK.Service
+      yield* addPlugin()
+      const result = yield* aisdk.runSDK({
+        model: ModelV2.Info.make({
+          ...ModelV2.Info.empty(ProviderV2.ID.make("custom-groq"), ModelV2.ID.make("llama")),
+          api: { id: ModelV2.ID.make("llama"), type: "aisdk", package: "@ai-sdk/groq" },
+        }),
+        package: "@ai-sdk/groq",
+        options: { name: "custom-groq", apiKey: "test" },
+      })
+      const expected = createGroq({ name: "custom-groq", apiKey: "test" } as Parameters<typeof createGroq>[0] & {
+        name: string
+      }).languageModel("llama")
+      const actual = result.sdk?.languageModel("llama")
+      expect(actual?.provider).toBe(expected.provider)
+      expect(actual?.modelId).toBe(expected.modelId)
+    }),
+  )
+
+  it.effect("uses the default languageModel(api.id) behavior", () =>
+    Effect.gen(function* () {
+      const plugin = yield* PluginV2.Service
+      const aisdk = yield* AISDK.Service
+      yield* addPlugin()
+      const sdk = createGroq({ name: "groq", apiKey: "test" } as Parameters<typeof createGroq>[0] & {
+        name: string
+      })
+      const result = yield* aisdk.runLanguage({
+        model: ModelV2.Info.make({
+          ...ModelV2.Info.empty(ProviderV2.ID.make("groq"), ModelV2.ID.make("alias")),
+          api: {
+            id: ModelV2.ID.make("llama-api"),
+            type: "aisdk",
+            package: "@ai-sdk/groq",
+          },
+        }),
+        sdk,
+        options: { name: "groq", apiKey: "test" },
+      })
+      const language = result.language ?? sdk.languageModel(result.model.api.id)
+      expect(language.modelId).toBe("llama-api")
+      expect(language.provider).toBe("groq.chat")
+    }),
+  )
+})

package/test/plugin/provider-kilo.test.ts

@@ -0,0 +1,99 @@
+import { describe, expect } from "bun:test"
+import { Effect } from "effect"
+import { Catalog } from "@neurocode-ai/core/catalog"
+import { PluginV2 } from "@neurocode-ai/core/plugin"
+import { PluginHost } from "@neurocode-ai/core/plugin/host"
+import { ProviderPlugins } from "@neurocode-ai/core/plugin/provider"
+import { KiloPlugin } from "@neurocode-ai/core/plugin/provider/kilo"
+import { ProviderV2 } from "@neurocode-ai/core/provider"
+import { testEffect } from "../lib/effect"
+import { PluginTestLayer } from "./fixture"
+
+const it = testEffect(PluginTestLayer)
+
+const addPlugin = Effect.fn(function* () {
+  const plugin = yield* PluginV2.Service
+  const host = yield* PluginHost.make(plugin)
+  yield* KiloPlugin.effect(host)
+})
+
+describe("KiloPlugin", () => {
+  it.effect("is registered so legacy referer headers can be applied", () =>
+    Effect.sync(() => expect(ProviderPlugins.map((item) => item.id)).toContain(PluginV2.ID.make("kilo"))),
+  )
+
+  it.effect("applies legacy referer headers only to kilo", () =>
+    Effect.gen(function* () {
+      const catalog = yield* Catalog.Service
+      yield* catalog.transform((catalog) => {
+        catalog.provider.update(ProviderV2.ID.make("kilo"), (provider) => {
+          provider.api = {
+            type: "aisdk",
+            package: "@ai-sdk/openai-compatible",
+            url: "https://api.kilo.ai/api/gateway",
+          }
+          provider.request = { headers: { Existing: "value" }, body: {} }
+        })
+        catalog.provider.update(ProviderV2.ID.openrouter, () => {})
+      })
+      yield* addPlugin()
+      expect((yield* catalog.provider.get(ProviderV2.ID.make("kilo")))?.request.headers).toEqual({
+        Existing: "value",
+        "HTTP-Referer": "https://neurocode.ai/",
+        "X-Title": "neurocode",
+      })
+      expect((yield* catalog.provider.get(ProviderV2.ID.openrouter))?.request.headers).toEqual({})
+    }),
+  )
+
+  it.effect("uses the exact legacy Kilo header casing and set", () =>
+    Effect.gen(function* () {
+      const catalog = yield* Catalog.Service
+      yield* catalog.transform((catalog) => {
+        catalog.provider.update(ProviderV2.ID.make("kilo"), (provider) => {
+          provider.api = {
+            type: "aisdk",
+            package: "@ai-sdk/openai-compatible",
+            url: "https://api.kilo.ai/api/gateway",
+          }
+        })
+      })
+      yield* addPlugin()
+
+      expect((yield* catalog.provider.get(ProviderV2.ID.make("kilo")))?.request.headers).toEqual({
+        "HTTP-Referer": "https://neurocode.ai/",
+        "X-Title": "neurocode",
+      })
+      expect((yield* catalog.provider.get(ProviderV2.ID.make("kilo")))?.request.headers).not.toHaveProperty(
+        "http-referer",
+      )
+      expect((yield* catalog.provider.get(ProviderV2.ID.make("kilo")))?.request.headers).not.toHaveProperty("x-title")
+      expect((yield* catalog.provider.get(ProviderV2.ID.make("kilo")))?.request.headers).not.toHaveProperty("X-Source")
+    }),
+  )
+
+  it.effect("uses the legacy provider-id guard instead of endpoint package matching", () =>
+    Effect.gen(function* () {
+      const catalog = yield* Catalog.Service
+      yield* catalog.transform((catalog) => {
+        catalog.provider.update(ProviderV2.ID.make("kilo"), (provider) => {
+          provider.api = {
+            type: "aisdk",
+            package: "@ai-sdk/openai-compatible",
+            url: "https://api.kilo.ai/api/gateway",
+          }
+        })
+        catalog.provider.update(ProviderV2.ID.make("custom-kilo"), (provider) => {
+          provider.api = { type: "aisdk", package: "kilo" }
+        })
+      })
+      yield* addPlugin()
+
+      expect((yield* catalog.provider.get(ProviderV2.ID.make("kilo")))?.request.headers).toEqual({
+        "HTTP-Referer": "https://neurocode.ai/",
+        "X-Title": "neurocode",
+      })
+      expect((yield* catalog.provider.get(ProviderV2.ID.make("custom-kilo")))?.request.headers).toEqual({})
+    }),
+  )
+})