@neurocode-ai/core 1.18.8

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

@@ -0,0 +1,184 @@
+import { Npm } from "@neurocode-ai/core/npm"
+import { describe, expect } from "bun:test"
+import { Cause, Effect, Layer } from "effect"
+import fs from "fs/promises"
+import os from "os"
+import path from "path"
+import { fileURLToPath } from "url"
+import { AISDK } from "@neurocode-ai/core/aisdk"
+import { AppNodeBuilder } from "@neurocode-ai/core/effect/app-node-builder"
+import { ModelV2 } from "@neurocode-ai/core/model"
+import { PluginV2 } from "@neurocode-ai/core/plugin"
+import { PluginHost } from "@neurocode-ai/core/plugin/host"
+import { DynamicProviderPlugin } from "@neurocode-ai/core/plugin/provider/dynamic"
+import { ProviderV2 } from "@neurocode-ai/core/provider"
+import { testEffect } from "../lib/effect"
+import { PluginTestLayer } from "./fixture"
+
+const fixtureProvider = new URL("./fixtures/provider-factory.ts", import.meta.url).href
+const fixtureProviderPath = fileURLToPath(fixtureProvider)
+const it = testEffect(PluginTestLayer)
+const itWithAISDK = testEffect(Layer.mergeAll(PluginTestLayer, AppNodeBuilder.build(AISDK.node)))
+
+function npmEntrypoint(entrypoint?: string) {
+  return Npm.Service.of({
+    add: () => Effect.succeed({ directory: "", entrypoint }),
+    install: () => Effect.void,
+    which: () => Effect.succeed(undefined),
+  })
+}
+
+const addPlugin = Effect.fn(function* (npm?: Npm.Interface) {
+  const plugin = yield* PluginV2.Service
+  const host = yield* PluginHost.make(plugin)
+  yield* DynamicProviderPlugin.effect(host).pipe(Effect.provideService(Npm.Service, npm ?? (yield* Npm.Service)))
+})
+
+function tempEntrypoint(source: string) {
+  return Effect.acquireRelease(
+    Effect.promise(async () => {
+      const directory = await fs.mkdtemp(path.join(os.tmpdir(), "neurocode-provider-dynamic-"))
+      const entrypoint = path.join(directory, "provider.mjs")
+      await Bun.write(entrypoint, source)
+      return { directory, entrypoint }
+    }),
+    (tmp) => Effect.promise(() => fs.rm(tmp.directory, { recursive: true, force: true })),
+  )
+}
+
+describe("DynamicProviderPlugin", () => {
+  it.effect("creates an SDK from a provider factory export", () =>
+    Effect.gen(function* () {
+      const aisdk = yield* AISDK.Service
+      yield* addPlugin()
+      const result = yield* aisdk.runSDK({
+        model: ModelV2.Info.make({
+          ...ModelV2.Info.empty(ProviderV2.ID.make("custom"), ModelV2.ID.make("test-model")),
+          api: { id: ModelV2.ID.make("test-model"), type: "aisdk", package: fixtureProvider },
+        }),
+        package: fixtureProvider,
+        options: { name: "custom", marker: "dynamic" },
+      })
+      expect(result.sdk.options).toEqual({ marker: "dynamic", name: "custom" })
+      expect(result.sdk.languageModel("x")).toEqual({ modelID: "x", options: { marker: "dynamic", name: "custom" } })
+    }),
+  )
+
+  it.effect("does not override an SDK already supplied by an earlier plugin", () =>
+    Effect.gen(function* () {
+      const aisdk = yield* AISDK.Service
+      const sdk = { marker: "existing" }
+      yield* addPlugin()
+      const result = yield* aisdk.runSDK({
+        model: ModelV2.Info.make({
+          ...ModelV2.Info.empty(ProviderV2.ID.make("custom"), ModelV2.ID.make("test-model")),
+          api: { id: ModelV2.ID.make("test-model"), type: "aisdk", package: fixtureProvider },
+        }),
+        package: fixtureProvider,
+        options: { name: "custom", marker: "dynamic" },
+        sdk,
+      })
+      expect(result.sdk).toBe(sdk)
+    }),
+  )
+
+  it.effect("injects the provider ID as the SDK factory name", () =>
+    Effect.gen(function* () {
+      const aisdk = yield* AISDK.Service
+      yield* addPlugin()
+      const result = yield* aisdk.runSDK({
+        model: ModelV2.Info.make({
+          ...ModelV2.Info.empty(ProviderV2.ID.make("custom-provider"), ModelV2.ID.make("test-model")),
+          api: { id: ModelV2.ID.make("test-model"), type: "aisdk", package: fixtureProvider },
+        }),
+        package: fixtureProvider,
+        options: { name: "custom-provider", marker: "dynamic" },
+      })
+      expect(result.sdk.options).toEqual({ marker: "dynamic", name: "custom-provider" })
+    }),
+  )
+
+  it.effect("loads npm packages through their resolved import entrypoint", () =>
+    Effect.gen(function* () {
+      const aisdk = yield* AISDK.Service
+      yield* addPlugin(npmEntrypoint(fixtureProviderPath))
+      const result = yield* aisdk.runSDK({
+        model: ModelV2.Info.make({
+          ...ModelV2.Info.empty(ProviderV2.ID.make("npm-provider"), ModelV2.ID.make("test-model")),
+          api: { id: ModelV2.ID.make("test-model"), type: "aisdk", package: "fixture-provider" },
+        }),
+        package: "fixture-provider",
+        options: { name: "npm-provider", marker: "npm" },
+      })
+      expect(result.sdk.languageModel("x")).toEqual({ modelID: "x", options: { marker: "npm", name: "npm-provider" } })
+    }),
+  )
+
+  itWithAISDK.effect("wraps missing npm entrypoint failures as AISDK init errors", () =>
+    Effect.gen(function* () {
+      const aisdk = yield* AISDK.Service
+      yield* addPlugin(npmEntrypoint())
+      const exit = yield* aisdk
+        .language(
+          ModelV2.Info.make({
+            ...ModelV2.Info.empty(ProviderV2.ID.make("missing-entrypoint"), ModelV2.ID.make("alias")),
+            api: { id: ModelV2.ID.make("alias"), type: "aisdk", package: "fixture-provider" },
+          }),
+        )
+        .pipe(Effect.exit)
+      expect(exit._tag).toBe("Failure")
+      if (exit._tag === "Failure") expect(Cause.prettyErrors(exit.cause).join("\n")).toContain("AISDK.InitError")
+    }),
+  )
+
+  itWithAISDK.effect("wraps dynamic import failures as AISDK init errors", () =>
+    Effect.gen(function* () {
+      const aisdk = yield* AISDK.Service
+      yield* addPlugin()
+      const exit = yield* aisdk
+        .language(
+          ModelV2.Info.make({
+            ...ModelV2.Info.empty(ProviderV2.ID.make("bad-import"), ModelV2.ID.make("alias")),
+            api: { id: ModelV2.ID.make("alias"), type: "aisdk", package: "file:///missing/provider-factory.js" },
+          }),
+        )
+        .pipe(Effect.exit)
+      expect(exit._tag).toBe("Failure")
+      if (exit._tag === "Failure") expect(Cause.prettyErrors(exit.cause).join("\n")).toContain("AISDK.InitError")
+    }),
+  )
+
+  itWithAISDK.live("wraps missing provider factory exports as AISDK init errors", () =>
+    Effect.gen(function* () {
+      const plugin = yield* PluginV2.Service
+      const aisdk = yield* AISDK.Service
+      const tmp = yield* tempEntrypoint("export const notAProviderFactory = true\n")
+      yield* addPlugin(npmEntrypoint(tmp.entrypoint))
+      const exit = yield* aisdk
+        .language(
+          ModelV2.Info.make({
+            ...ModelV2.Info.empty(ProviderV2.ID.make("missing-factory"), ModelV2.ID.make("alias")),
+            api: { id: ModelV2.ID.make("alias"), type: "aisdk", package: "fixture-provider" },
+          }),
+        )
+        .pipe(Effect.exit)
+      expect(exit._tag).toBe("Failure")
+      if (exit._tag === "Failure") expect(Cause.prettyErrors(exit.cause).join("\n")).toContain("AISDK.InitError")
+    }),
+  )
+
+  itWithAISDK.effect("uses the model api.id for the default language model", () =>
+    Effect.gen(function* () {
+      const plugin = yield* PluginV2.Service
+      const aisdk = yield* AISDK.Service
+      yield* addPlugin()
+      const language = yield* aisdk.language(
+        ModelV2.Info.make({
+          ...ModelV2.Info.empty(ProviderV2.ID.make("custom"), ModelV2.ID.make("alias")),
+          api: { id: ModelV2.ID.make("test-model-api"), type: "aisdk", package: fixtureProvider },
+        }),
+      )
+      expect(language).toMatchObject({ modelID: "test-model-api", options: { name: "custom" } })
+    }),
+  )
+})

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

@@ -0,0 +1,115 @@
+import { AISDK } from "@neurocode-ai/core/aisdk"
+import { describe, expect, mock } 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 { GatewayPlugin } from "@neurocode-ai/core/plugin/provider/gateway"
+import { ProviderV2 } from "@neurocode-ai/core/provider"
+import { testEffect } from "../lib/effect"
+import { PluginTestLayer } from "./fixture"
+
+const gatewayCalls: Record<string, unknown>[] = []
+const vercelGatewayModels = ["anthropic/claude-sonnet-4", "openai/gpt-5", "google/gemini-2.5-pro"]
+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* GatewayPlugin.effect(host)
+})
+
+mock.module("@ai-sdk/gateway", () => ({
+  createGateway(options: Record<string, unknown>) {
+    gatewayCalls.push({ ...options })
+    return {
+      languageModel(modelID: string) {
+        return {
+          modelId: modelID,
+          provider: options.name,
+          specificationVersion: "v3",
+        }
+      },
+    }
+  },
+}))
+
+describe("GatewayPlugin", () => {
+  it.effect("creates a Gateway SDK for @ai-sdk/gateway", () =>
+    Effect.gen(function* () {
+      gatewayCalls.length = 0
+      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("gateway"), ModelV2.ID.make("model")),
+          api: { id: ModelV2.ID.make("model"), type: "aisdk", package: "test-provider" },
+        }),
+        package: "@ai-sdk/gateway",
+        options: { name: "gateway" },
+      })
+      expect(result.sdk).toBeDefined()
+      expect(gatewayCalls).toHaveLength(1)
+    }),
+  )
+
+  it.effect("passes the model providerID as the Gateway SDK name", () =>
+    Effect.gen(function* () {
+      gatewayCalls.length = 0
+      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("vercel"), ModelV2.ID.make("anthropic/claude-sonnet-4")),
+          api: {
+            id: ModelV2.ID.make("anthropic/claude-sonnet-4"),
+            type: "aisdk",
+            package: "test-provider",
+          },
+        }),
+        package: "@ai-sdk/gateway",
+        options: { name: "vercel", apiKey: "test-key" },
+      })
+
+      expect(gatewayCalls).toEqual([{ name: "vercel", apiKey: "test-key" }])
+      expect(result.sdk.languageModel("anthropic/claude-sonnet-4").provider).toBe("vercel")
+    }),
+  )
+
+  it.effect("matches Vercel AI Gateway models by their @ai-sdk/gateway package", () =>
+    Effect.gen(function* () {
+      gatewayCalls.length = 0
+      const plugin = yield* PluginV2.Service
+      const aisdk = yield* AISDK.Service
+      yield* addPlugin()
+
+      for (const modelID of vercelGatewayModels) {
+        const ignored = yield* aisdk.runSDK({
+          model: ModelV2.Info.make({
+            ...ModelV2.Info.empty(ProviderV2.ID.make("vercel"), ModelV2.ID.make(modelID)),
+            api: { id: ModelV2.ID.make(modelID), type: "aisdk", package: "test-provider" },
+          }),
+          package: "@ai-sdk/vercel",
+          options: { name: "vercel" },
+        })
+        expect(ignored.sdk).toBeUndefined()
+
+        const result = yield* aisdk.runSDK({
+          model: ModelV2.Info.make({
+            ...ModelV2.Info.empty(ProviderV2.ID.make("vercel"), ModelV2.ID.make(modelID)),
+            api: { id: ModelV2.ID.make(modelID), type: "aisdk", package: "test-provider" },
+          }),
+          package: "@ai-sdk/gateway",
+          options: { name: "vercel" },
+        })
+        expect(result.sdk).toBeDefined()
+      }
+
+      expect(gatewayCalls).toHaveLength(3)
+    }),
+  )
+})

package/test/plugin/provider-github-copilot.test.ts

@@ -0,0 +1,278 @@
+import { AISDK } from "@neurocode-ai/core/aisdk"
+import { describe, expect } 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 { GithubCopilotPlugin } from "@neurocode-ai/core/plugin/provider/github-copilot"
+import { ProviderV2 } from "@neurocode-ai/core/provider"
+import type { LanguageModelV3 } from "@ai-sdk/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* GithubCopilotPlugin.effect(host)
+})
+
+function required<T>(value: T | undefined): T {
+  if (value === undefined) throw new Error("Expected value")
+  return 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"),
+  }
+}
+
+describe("GithubCopilotPlugin", () => {
+  it.effect("creates the bundled Copilot SDK for the GitHub Copilot package", () =>
+    Effect.gen(function* () {
+      const plugin = yield* PluginV2.Service
+      const aisdk = yield* AISDK.Service
+      yield* addPlugin()
+      const ignored = yield* aisdk.runSDK({
+        model: ModelV2.Info.make({
+          ...ModelV2.Info.empty(ProviderV2.ID.make("github-copilot"), ModelV2.ID.make("gpt-5")),
+          api: { id: ModelV2.ID.make("gpt-5"), type: "aisdk", package: "test-provider" },
+        }),
+        package: "@ai-sdk/openai-compatible",
+        options: { name: "github-copilot" },
+      })
+      const result = yield* aisdk.runSDK({
+        model: ModelV2.Info.make({
+          ...ModelV2.Info.empty(ProviderV2.ID.make("github-copilot"), ModelV2.ID.make("gpt-5")),
+          api: { id: ModelV2.ID.make("gpt-5"), type: "aisdk", package: "test-provider" },
+        }),
+        package: "@ai-sdk/github-copilot",
+        options: { name: "github-copilot" },
+      })
+      expect(ignored.sdk).toBeUndefined()
+      expect(result.sdk).toBeDefined()
+    }),
+  )
+
+  it.effect("selects languageModel when responses and chat are absent", () =>
+    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("github-copilot"), ModelV2.ID.make("claude-sonnet-4")),
+          api: { id: ModelV2.ID.make("claude-sonnet-4"), type: "aisdk", package: "test-provider" },
+        }),
+        sdk: { languageModel: fakeSelectorSdk(calls).languageModel },
+        options: {},
+      })
+      expect(calls).toEqual(["languageModel:claude-sonnet-4"])
+    }),
+  )
+
+  it.effect("selects languageModel with the API model ID when responses and chat are absent", () =>
+    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("github-copilot"), ModelV2.ID.make("alias")),
+          api: { id: ModelV2.ID.make("claude-sonnet-4"), type: "aisdk", package: "test-provider" },
+        }),
+        sdk: { languageModel: fakeSelectorSdk(calls).languageModel },
+        options: {},
+      })
+      expect(calls).toEqual(["languageModel:claude-sonnet-4"])
+    }),
+  )
+
+  it.effect("uses responses for gpt-5 models except gpt-5-mini", () =>
+    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("github-copilot"), ModelV2.ID.make("gpt-5")),
+          api: { id: ModelV2.ID.make("gpt-5"), type: "aisdk", package: "test-provider" },
+        }),
+        sdk: fakeSelectorSdk(calls),
+        options: {},
+      })
+      yield* aisdk.runLanguage({
+        model: ModelV2.Info.make({
+          ...ModelV2.Info.empty(ProviderV2.ID.make("github-copilot"), ModelV2.ID.make("gpt-5.1-codex")),
+          api: { id: ModelV2.ID.make("gpt-5.1-codex"), type: "aisdk", package: "test-provider" },
+        }),
+        sdk: fakeSelectorSdk(calls),
+        options: {},
+      })
+      yield* aisdk.runLanguage({
+        model: ModelV2.Info.make({
+          ...ModelV2.Info.empty(ProviderV2.ID.make("github-copilot"), ModelV2.ID.make("gpt-4o")),
+          api: { id: ModelV2.ID.make("gpt-4o"), type: "aisdk", package: "test-provider" },
+        }),
+        sdk: fakeSelectorSdk(calls),
+        options: {},
+      })
+      yield* aisdk.runLanguage({
+        model: ModelV2.Info.make({
+          ...ModelV2.Info.empty(ProviderV2.ID.make("github-copilot"), ModelV2.ID.make("gpt-5-mini")),
+          api: { id: ModelV2.ID.make("gpt-5-mini"), type: "aisdk", package: "test-provider" },
+        }),
+        sdk: fakeSelectorSdk(calls),
+        options: {},
+      })
+      yield* aisdk.runLanguage({
+        model: ModelV2.Info.make({
+          ...ModelV2.Info.empty(ProviderV2.ID.make("github-copilot"), ModelV2.ID.make("gpt-5-mini-2025-08-07")),
+          api: { id: ModelV2.ID.make("gpt-5-mini-2025-08-07"), type: "aisdk", package: "test-provider" },
+        }),
+        sdk: fakeSelectorSdk(calls),
+        options: {},
+      })
+      expect(calls).toEqual([
+        "responses:gpt-5",
+        "responses:gpt-5.1-codex",
+        "chat:gpt-4o",
+        "chat:gpt-5-mini",
+        "chat:gpt-5-mini-2025-08-07",
+      ])
+    }),
+  )
+
+  it.effect("uses advertised Copilot endpoint metadata before model ID fallbacks", () =>
+    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("github-copilot"), ModelV2.ID.make("mai-code-1-flash-picker")),
+          api: {
+            id: ModelV2.ID.make("mai-code-1-flash-picker"),
+            type: "aisdk",
+            package: "test-provider",
+            settings: { endpoint: "responses" },
+          },
+        }),
+        sdk: fakeSelectorSdk(calls),
+        options: { endpoint: "responses" },
+      })
+      yield* aisdk.runLanguage({
+        model: ModelV2.Info.make({
+          ...ModelV2.Info.empty(ProviderV2.ID.make("github-copilot"), ModelV2.ID.make("gpt-5")),
+          api: {
+            id: ModelV2.ID.make("gpt-5"),
+            type: "aisdk",
+            package: "test-provider",
+            settings: { endpoint: "chat" },
+          },
+        }),
+        sdk: fakeSelectorSdk(calls),
+        options: { endpoint: "chat" },
+      })
+      expect(calls).toEqual(["responses:mai-code-1-flash-picker", "chat:gpt-5"])
+    }),
+  )
+
+  it.effect("uses the API model ID when selecting responses or chat", () =>
+    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("github-copilot"), ModelV2.ID.make("default")),
+          api: { id: ModelV2.ID.make("gpt-5"), type: "aisdk", package: "test-provider" },
+        }),
+        sdk: fakeSelectorSdk(calls),
+        options: {},
+      })
+      yield* aisdk.runLanguage({
+        model: ModelV2.Info.make({
+          ...ModelV2.Info.empty(ProviderV2.ID.make("github-copilot"), ModelV2.ID.make("small")),
+          api: { id: ModelV2.ID.make("gpt-5-mini"), type: "aisdk", package: "test-provider" },
+        }),
+        sdk: fakeSelectorSdk(calls),
+        options: {},
+      })
+      yield* aisdk.runLanguage({
+        model: ModelV2.Info.make({
+          ...ModelV2.Info.empty(ProviderV2.ID.make("github-copilot"), ModelV2.ID.make("sonnet")),
+          api: { id: ModelV2.ID.make("claude-sonnet-4"), type: "aisdk", package: "test-provider" },
+        }),
+        sdk: fakeSelectorSdk(calls),
+        options: {},
+      })
+      expect(calls).toEqual(["responses:gpt-5", "chat:gpt-5-mini", "chat:claude-sonnet-4"])
+    }),
+  )
+
+  it.effect("disables gpt-5-chat-latest before Copilot language selection", () =>
+    Effect.gen(function* () {
+      const catalog = yield* Catalog.Service
+      yield* catalog.transform((catalog) => {
+        catalog.provider.update(ProviderV2.ID.make("github-copilot"), () => {})
+        catalog.model.update(ProviderV2.ID.make("github-copilot"), ModelV2.ID.make("gpt-5-chat-latest"), () => {})
+      })
+      yield* addPlugin()
+      expect(
+        required(yield* catalog.model.get(ProviderV2.ID.make("github-copilot"), ModelV2.ID.make("gpt-5-chat-latest")))
+          .enabled,
+      ).toBe(false)
+    }),
+  )
+
+  it.effect("does not disable gpt-5-chat-latest for non-Copilot providers", () =>
+    Effect.gen(function* () {
+      const catalog = yield* Catalog.Service
+      yield* catalog.transform((catalog) => {
+        catalog.provider.update(ProviderV2.ID.make("custom-copilot"), () => {})
+        catalog.model.update(ProviderV2.ID.make("custom-copilot"), ModelV2.ID.make("gpt-5-chat-latest"), () => {})
+      })
+      yield* addPlugin()
+      expect(
+        required(yield* catalog.model.get(ProviderV2.ID.make("custom-copilot"), ModelV2.ID.make("gpt-5-chat-latest")))
+          .enabled,
+      ).toBe(true)
+    }),
+  )
+
+  it.effect("ignores non-Copilot providers", () =>
+    Effect.gen(function* () {
+      const plugin = yield* PluginV2.Service
+      const aisdk = yield* AISDK.Service
+      const calls: string[] = []
+      yield* addPlugin()
+      const result = yield* aisdk.runLanguage({
+        model: ModelV2.Info.make({
+          ...ModelV2.Info.empty(ProviderV2.ID.make("openai"), ModelV2.ID.make("gpt-5")),
+          api: { id: ModelV2.ID.make("gpt-5"), type: "aisdk", package: "test-provider" },
+        }),
+        sdk: fakeSelectorSdk(calls),
+        options: {},
+      })
+      expect(calls).toEqual([])
+      expect(result.language).toBeUndefined()
+    }),
+  )
+})