@neurocode-ai/core 1.18.8

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

@@ -0,0 +1,423 @@
+import { describe, expect } from "bun:test"
+import { Effect } from "effect"
+import { Catalog } from "@neurocode-ai/core/catalog"
+import { Credential } from "@neurocode-ai/core/credential"
+import { EventV2 } from "@neurocode-ai/core/event"
+import { Integration } from "@neurocode-ai/core/integration"
+import { ModelV2 } from "@neurocode-ai/core/model"
+import { PluginV2 } from "@neurocode-ai/core/plugin"
+import { PluginHost } from "@neurocode-ai/core/plugin/host"
+import { OpencodePlugin } from "@neurocode-ai/core/plugin/provider/neurocode"
+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)
+  const events = yield* EventV2.Service
+  const integration = yield* Integration.Service
+  yield* OpencodePlugin.effect(host).pipe(
+    Effect.provideService(EventV2.Service, events),
+    Effect.provideService(Integration.Service, integration),
+  )
+})
+
+function required<T>(value: T | undefined): T {
+  if (value === undefined) throw new Error("Expected value")
+  return value
+}
+
+function eventually<A>(
+  effect: Effect.Effect<A>,
+  predicate: (value: A) => boolean,
+  remaining = 1000,
+): Effect.Effect<A, Error> {
+  return Effect.gen(function* () {
+    const value = yield* effect
+    if (predicate(value)) return value
+    if (remaining === 0) return yield* Effect.fail(new Error("Timed out waiting for value"))
+    yield* Effect.promise(() => Bun.sleep(1))
+    return yield* eventually(effect, predicate, remaining - 1)
+  })
+}
+
+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
+        }),
+      ),
+  )
+}
+
+const cost = (input: number, output = 0) => [{ input, output, cache: { read: 0, write: 0 } }]
+
+describe("OpencodePlugin", () => {
+  it.effect("registers account and service account methods", () =>
+    Effect.gen(function* () {
+      yield* addPlugin()
+      expect((yield* (yield* Integration.Service).get(Integration.ID.make("opencode")))?.methods).toEqual([
+        {
+          id: Integration.MethodID.make("device"),
+          type: "oauth",
+          label: "NeuroCode Console account",
+        },
+        { type: "key", label: "API key (service account)" },
+      ])
+    }),
+  )
+
+  it.live("loads providers and models from the connected NeuroCode server", () =>
+    Effect.acquireUseRelease(
+      Effect.sync(() => {
+        const authorization: Array<string | null> = []
+        const gate = Promise.withResolvers<void>()
+        return {
+          authorization,
+          release: gate.resolve,
+          server: Bun.serve({
+            port: 0,
+            fetch: async (request) => {
+              await gate.promise
+              authorization.push(request.headers.get("authorization"))
+              const origin = new URL(request.url).origin
+              return Response.json({
+                config: {
+                  enterprise: { url: origin },
+                  provider: {
+                    remote: {
+                      name: "Remote",
+                      npm: "@ai-sdk/openai-compatible",
+                      api: `${origin}/v1`,
+                      env: ["REMOTE_API_KEY"],
+                      options: {
+                        apiKey: "{env:REMOTE_API_KEY}",
+                        headers: { "x-org-id": "org" },
+                        custom: "value",
+                      },
+                      models: {
+                        model: {
+                          name: "Remote Model",
+                          family: "remote",
+                          release_date: "2026-01-02",
+                          tool_call: true,
+                          modalities: { input: ["text", "image"], output: ["text"] },
+                          options: { apiKey: "model-secret", temperature: 0.5 },
+                          variants: { high: { apiKey: "variant-secret", temperature: 0.2 } },
+                          cost: { input: 1, output: 2, cache_read: 0.1 },
+                          limit: { context: 1000, output: 100 },
+                        },
+                        disabled: { name: "Disabled", status: "deprecated" },
+                      },
+                    },
+                  },
+                },
+              })
+            },
+          }),
+        }
+      }),
+      ({ authorization, release, server }) =>
+        Effect.gen(function* () {
+          const credentials = yield* Credential.Service
+          const catalog = yield* Catalog.Service
+          yield* catalog.transform((draft) => {
+            draft.provider.update(ProviderV2.ID.make("remote"), () => {})
+            draft.model.update(ProviderV2.ID.make("remote"), ModelV2.ID.make("stale"), () => {})
+          })
+          yield* credentials.create({
+            integrationID: Integration.ID.make("opencode"),
+            value: Credential.Key.make({
+              type: "key",
+              key: "secret",
+              metadata: { server: server.url.origin },
+            }),
+          })
+
+          yield* addPlugin()
+          expect(authorization).toEqual([])
+          release()
+
+          const provider = required(
+            yield* eventually(
+              catalog.provider.get(ProviderV2.ID.make("remote")),
+              (item) => item?.integrationID === Integration.ID.make("opencode"),
+            ),
+          )
+          expect(provider).toMatchObject({
+            name: "Remote",
+            integrationID: "neurocode",
+            api: {
+              type: "aisdk",
+              package: "@ai-sdk/openai-compatible",
+              url: `${server.url.origin}/v1`,
+            },
+          })
+          expect(provider.request).toEqual({ headers: { "x-org-id": "org" }, body: { custom: "value" } })
+          expect(yield* (yield* Integration.Service).get(Integration.ID.make("remote"))).toBeUndefined()
+
+          const model = required(yield* catalog.model.get(ProviderV2.ID.make("remote"), ModelV2.ID.make("model")))
+          expect(model).toMatchObject({
+            name: "Remote Model",
+            family: "remote",
+            capabilities: { tools: true, input: ["text", "image"], output: ["text"] },
+            cost: [{ input: 1, output: 2, cache: { read: 0.1, write: 0 } }],
+            limit: { context: 1000, output: 100 },
+          })
+          expect(model.request.body).toEqual({ custom: "value", temperature: 0.5 })
+          expect(model.variants).toEqual([
+            {
+              id: ModelV2.VariantID.make("high"),
+              headers: {},
+              body: { temperature: 0.2 },
+            },
+          ])
+          expect(
+            required(yield* catalog.model.get(ProviderV2.ID.make("remote"), ModelV2.ID.make("disabled"))).enabled,
+          ).toBe(false)
+          expect(yield* catalog.model.get(ProviderV2.ID.make("remote"), ModelV2.ID.make("stale"))).toBeDefined()
+          expect(authorization).toContain("Bearer secret")
+        }),
+      ({ server }) => Effect.promise(() => server.stop(true)),
+    ),
+  )
+
+  it.effect("uses a public key and disables paid models without credentials", () =>
+    withEnv({ NEUROCODE_API_KEY: undefined }, () =>
+      Effect.gen(function* () {
+        const catalog = yield* Catalog.Service
+        yield* catalog.transform((catalog) => {
+          const provider = ProviderV2.Info.make({
+            ...ProviderV2.Info.empty(ProviderV2.ID.opencode),
+            api: { type: "aisdk", package: "test-provider" },
+          })
+          const model = ModelV2.Info.make({
+            ...ModelV2.Info.empty(provider.id, ModelV2.ID.make("paid")),
+            api: { id: ModelV2.ID.make("paid"), type: "aisdk", package: "test-provider" },
+            cost: cost(1),
+          })
+          catalog.provider.update(provider.id, () => {})
+          catalog.model.update(provider.id, model.id, (draft) => {
+            draft.cost = [...model.cost]
+          })
+        })
+        yield* addPlugin()
+        expect(required(yield* catalog.provider.get(ProviderV2.ID.opencode)).request.body.apiKey).toBe("public")
+        expect(required(yield* catalog.model.get(ProviderV2.ID.opencode, ModelV2.ID.make("paid"))).enabled).toBe(false)
+      }),
+    ),
+  )
+
+  it.effect("keeps free models without credentials", () =>
+    withEnv({ NEUROCODE_API_KEY: undefined }, () =>
+      Effect.gen(function* () {
+        const catalog = yield* Catalog.Service
+        yield* catalog.transform((catalog) => {
+          const provider = ProviderV2.Info.make({
+            ...ProviderV2.Info.empty(ProviderV2.ID.opencode),
+            api: { type: "aisdk", package: "test-provider" },
+          })
+          const model = ModelV2.Info.make({
+            ...ModelV2.Info.empty(provider.id, ModelV2.ID.make("free")),
+            api: { id: ModelV2.ID.make("free"), type: "aisdk", package: "test-provider" },
+            cost: cost(0),
+          })
+          catalog.provider.update(provider.id, () => {})
+          catalog.model.update(provider.id, model.id, (draft) => {
+            draft.cost = [...model.cost]
+          })
+        })
+        yield* addPlugin()
+        expect(required(yield* catalog.provider.get(ProviderV2.ID.opencode)).request.body.apiKey).toBe("public")
+        expect(required(yield* catalog.model.get(ProviderV2.ID.opencode, ModelV2.ID.make("free"))).enabled).toBe(true)
+      }),
+    ),
+  )
+
+  it.effect("treats output-only cost as free without credentials", () =>
+    withEnv({ NEUROCODE_API_KEY: undefined }, () =>
+      Effect.gen(function* () {
+        const catalog = yield* Catalog.Service
+        yield* catalog.transform((catalog) => {
+          const provider = ProviderV2.Info.make({
+            ...ProviderV2.Info.empty(ProviderV2.ID.opencode),
+            api: { type: "aisdk", package: "test-provider" },
+          })
+          const model = ModelV2.Info.make({
+            ...ModelV2.Info.empty(provider.id, ModelV2.ID.make("output-only")),
+            api: { id: ModelV2.ID.make("output-only"), type: "aisdk", package: "test-provider" },
+            cost: cost(0, 1),
+          })
+          catalog.provider.update(provider.id, () => {})
+          catalog.model.update(provider.id, model.id, (draft) => {
+            draft.cost = [...model.cost]
+          })
+        })
+        yield* addPlugin()
+        expect(required(yield* catalog.provider.get(ProviderV2.ID.opencode)).request.body.apiKey).toBe("public")
+        expect(required(yield* catalog.model.get(ProviderV2.ID.opencode, ModelV2.ID.make("output-only"))).enabled).toBe(
+          true,
+        )
+      }),
+    ),
+  )
+
+  it.effect("uses NEUROCODE_API_KEY as credentials", () =>
+    withEnv({ NEUROCODE_API_KEY: "secret" }, () =>
+      Effect.gen(function* () {
+        const catalog = yield* Catalog.Service
+        yield* catalog.transform((catalog) => {
+          const provider = ProviderV2.Info.make({
+            ...ProviderV2.Info.empty(ProviderV2.ID.opencode),
+            api: { type: "aisdk", package: "test-provider" },
+          })
+          const model = ModelV2.Info.make({
+            ...ModelV2.Info.empty(provider.id, ModelV2.ID.make("paid")),
+            api: { id: ModelV2.ID.make("paid"), type: "aisdk", package: "test-provider" },
+            cost: cost(1),
+          })
+          catalog.provider.update(provider.id, () => {})
+          catalog.model.update(provider.id, model.id, (draft) => {
+            draft.cost = [...model.cost]
+          })
+        })
+        yield* addPlugin()
+        expect(required(yield* catalog.provider.get(ProviderV2.ID.opencode)).request.body.apiKey).toBeUndefined()
+        expect(required(yield* catalog.model.get(ProviderV2.ID.opencode, ModelV2.ID.make("paid"))).enabled).toBe(true)
+      }),
+    ),
+  )
+
+  it.effect("uses configured provider env vars as credentials", () =>
+    withEnv({ NEUROCODE_API_KEY: undefined, CUSTOM_NEUROCODE_API_KEY: "secret" }, () =>
+      Effect.gen(function* () {
+        const catalog = yield* Catalog.Service
+        const integrations = yield* Integration.Service
+        yield* integrations.transform((editor) => {
+          editor.method.update({
+            integrationID: Integration.ID.make("opencode"),
+            method: { type: "env", names: ["CUSTOM_NEUROCODE_API_KEY"] },
+          })
+        })
+        yield* catalog.transform((catalog) => {
+          const provider = ProviderV2.Info.make({
+            ...ProviderV2.Info.empty(ProviderV2.ID.opencode),
+            api: { type: "aisdk", package: "test-provider" },
+          })
+          const model = ModelV2.Info.make({
+            ...ModelV2.Info.empty(provider.id, ModelV2.ID.make("paid")),
+            api: { id: ModelV2.ID.make("paid"), type: "aisdk", package: "test-provider" },
+            cost: cost(1),
+          })
+          catalog.provider.update(provider.id, () => {})
+          catalog.model.update(provider.id, model.id, (draft) => {
+            draft.cost = [...model.cost]
+          })
+        })
+        yield* addPlugin()
+        expect(required(yield* catalog.provider.get(ProviderV2.ID.opencode)).request.body.apiKey).toBeUndefined()
+        expect(required(yield* catalog.model.get(ProviderV2.ID.opencode, ModelV2.ID.make("paid"))).enabled).toBe(true)
+      }),
+    ),
+  )
+
+  it.effect("uses configured apiKey as credentials", () =>
+    withEnv({ NEUROCODE_API_KEY: undefined }, () =>
+      Effect.gen(function* () {
+        const catalog = yield* Catalog.Service
+        yield* catalog.transform((catalog) => {
+          const provider = ProviderV2.Info.make({
+            ...ProviderV2.Info.empty(ProviderV2.ID.opencode),
+            api: { type: "aisdk", package: "test-provider" },
+            request: {
+              headers: {},
+              body: { apiKey: "configured" },
+            },
+          })
+          const model = ModelV2.Info.make({
+            ...ModelV2.Info.empty(provider.id, ModelV2.ID.make("paid")),
+            api: { id: ModelV2.ID.make("paid"), type: "aisdk", package: "test-provider" },
+            cost: cost(1),
+          })
+          catalog.provider.update(provider.id, (draft) => {
+            draft.request = provider.request
+          })
+          catalog.model.update(provider.id, model.id, (draft) => {
+            draft.cost = [...model.cost]
+          })
+        })
+        yield* addPlugin()
+        expect(required(yield* catalog.provider.get(ProviderV2.ID.opencode)).request.body.apiKey).toBe("configured")
+        expect(required(yield* catalog.model.get(ProviderV2.ID.opencode, ModelV2.ID.make("paid"))).enabled).toBe(true)
+      }),
+    ),
+  )
+
+  it.effect("ignores non-neurocode providers and models", () =>
+    withEnv({ NEUROCODE_API_KEY: undefined }, () =>
+      Effect.gen(function* () {
+        const catalog = yield* Catalog.Service
+        yield* catalog.transform((catalog) => {
+          const provider = ProviderV2.Info.make({
+            ...ProviderV2.Info.empty(ProviderV2.ID.openai),
+            api: { type: "aisdk", package: "test-provider" },
+          })
+          const model = ModelV2.Info.make({
+            ...ModelV2.Info.empty(provider.id, ModelV2.ID.make("paid")),
+            api: { id: ModelV2.ID.make("paid"), type: "aisdk", package: "test-provider" },
+            cost: cost(1),
+          })
+          catalog.provider.update(provider.id, () => {})
+          catalog.model.update(provider.id, model.id, (draft) => {
+            draft.cost = [...model.cost]
+          })
+        })
+        yield* addPlugin()
+        expect(required(yield* catalog.provider.get(ProviderV2.ID.openai)).request.body.apiKey).toBeUndefined()
+        expect(required(yield* catalog.model.get(ProviderV2.ID.openai, ModelV2.ID.make("paid"))).enabled).toBe(true)
+      }),
+    ),
+  )
+
+  it.effect("prefers gpt-5-nano as the neurocode small model", () =>
+    Effect.gen(function* () {
+      const catalog = yield* Catalog.Service
+      const providerID = ProviderV2.ID.opencode
+
+      yield* catalog.transform((catalog) => {
+        catalog.provider.update(providerID, () => {})
+        catalog.model.update(providerID, ModelV2.ID.make("cheap-mini"), (model) => {
+          model.capabilities.input = ["text"]
+          model.capabilities.output = ["text"]
+          model.cost = [...cost(1, 1)]
+          model.time.released = Date.now()
+        })
+        catalog.model.update(providerID, ModelV2.ID.make("gpt-5-nano"), (model) => {
+          model.capabilities.input = ["text"]
+          model.capabilities.output = ["text"]
+          model.cost = [...cost(10, 10)]
+          model.time.released = Date.now()
+        })
+      })
+
+      const selected = yield* catalog.model.small(providerID)
+
+      expect(selected?.id).toBe(ModelV2.ID.make("gpt-5-nano"))
+    }),
+  )
+})

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

@@ -0,0 +1,113 @@
+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 { ProviderPlugins } from "@neurocode-ai/core/plugin/provider"
+import { OpenRouterPlugin } from "@neurocode-ai/core/plugin/provider/openrouter"
+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* OpenRouterPlugin.effect(host)
+})
+
+describe("OpenRouterPlugin", () => {
+  it.effect("is registered so legacy OpenRouter behavior can be applied", () =>
+    Effect.sync(() => expect(ProviderPlugins.map((item) => item.id)).toContain(PluginV2.ID.make("openrouter"))),
+  )
+
+  it.effect("applies legacy referer headers only to openrouter", () =>
+    Effect.gen(function* () {
+      const catalog = yield* Catalog.Service
+      yield* catalog.transform((catalog) => {
+        catalog.provider.update(ProviderV2.ID.openrouter, (provider) => {
+          provider.api = { type: "aisdk", package: "@openrouter/ai-sdk-provider" }
+          provider.request = { headers: { Existing: "value" }, body: {} }
+        })
+        catalog.provider.update(ProviderV2.ID.make("nvidia"), () => {})
+      })
+      yield* addPlugin()
+
+      expect((yield* catalog.provider.get(ProviderV2.ID.openrouter))?.request.headers).toEqual({
+        Existing: "value",
+        "HTTP-Referer": "https://neurocode.ai/",
+        "X-Title": "neurocode",
+      })
+      expect((yield* catalog.provider.get(ProviderV2.ID.make("nvidia")))?.request.headers).toEqual({})
+    }),
+  )
+
+  it.effect("creates an SDK only for the OpenRouter 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.openrouter, ModelV2.ID.make("openai/gpt-5")),
+          api: { id: ModelV2.ID.make("openai/gpt-5"), type: "aisdk", package: "test-provider" },
+        }),
+        package: "@ai-sdk/openai-compatible",
+        options: { name: "openrouter" },
+      })
+      expect(ignored.sdk).toBeUndefined()
+
+      const result = yield* aisdk.runSDK({
+        model: ModelV2.Info.make({
+          ...ModelV2.Info.empty(ProviderV2.ID.make("custom"), ModelV2.ID.make("openai/gpt-5")),
+          api: { id: ModelV2.ID.make("openai/gpt-5"), type: "aisdk", package: "test-provider" },
+        }),
+        package: "@openrouter/ai-sdk-provider",
+        options: { name: "custom" },
+      })
+      expect(result.sdk).toBeDefined()
+    }),
+  )
+
+  it.effect("filters OpenRouter's gpt-5 chat alias", () =>
+    Effect.gen(function* () {
+      const catalog = yield* Catalog.Service
+      yield* catalog.transform((catalog) => {
+        catalog.provider.update(ProviderV2.ID.openrouter, (provider) => {
+          provider.api = { type: "aisdk", package: "@openrouter/ai-sdk-provider" }
+        })
+        catalog.provider.update(ProviderV2.ID.openai, () => {})
+        catalog.model.update(ProviderV2.ID.openrouter, ModelV2.ID.make("openai/gpt-5-chat"), () => {})
+        catalog.model.update(ProviderV2.ID.openrouter, ModelV2.ID.make("openai/gpt-5"), () => {})
+        catalog.model.update(ProviderV2.ID.openai, ModelV2.ID.make("openai/gpt-5-chat"), () => {})
+      })
+      yield* addPlugin()
+
+      expect((yield* catalog.model.get(ProviderV2.ID.openrouter, ModelV2.ID.make("openai/gpt-5-chat")))?.enabled).toBe(
+        false,
+      )
+      expect((yield* catalog.model.get(ProviderV2.ID.openrouter, ModelV2.ID.make("openai/gpt-5")))?.enabled).toBe(true)
+      expect((yield* catalog.model.get(ProviderV2.ID.openai, ModelV2.ID.make("openai/gpt-5-chat")))?.enabled).toBe(true)
+    }),
+  )
+
+  it.effect("does not disable gpt-5-chat-latest for non-OpenRouter providers", () =>
+    Effect.gen(function* () {
+      const catalog = yield* Catalog.Service
+      yield* catalog.transform((catalog) => {
+        catalog.provider.update(ProviderV2.ID.make("custom-openrouter"), () => {})
+        catalog.model.update(ProviderV2.ID.make("custom-openrouter"), ModelV2.ID.make("gpt-5-chat-latest"), () => {})
+      })
+      yield* addPlugin()
+      expect(
+        (yield* catalog.model.get(ProviderV2.ID.make("custom-openrouter"), ModelV2.ID.make("gpt-5-chat-latest")))
+          ?.enabled,
+      ).toBe(true)
+    }),
+  )
+})

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

@@ -0,0 +1,122 @@
+import { AISDK } from "@neurocode-ai/core/aisdk"
+import { describe, expect } from "bun:test"
+import type { LanguageModelV3 } from "@ai-sdk/provider"
+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 { PerplexityPlugin } from "@neurocode-ai/core/plugin/provider/perplexity"
+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* PerplexityPlugin.effect(host)
+})
+
+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("PerplexityPlugin", () => {
+  it.effect("creates a Perplexity SDK for the exact @ai-sdk/perplexity package", () =>
+    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("perplexity"), ModelV2.ID.make("sonar")),
+          api: { id: ModelV2.ID.make("sonar"), type: "aisdk", package: "test-provider" },
+        }),
+        package: "@ai-sdk/perplexity",
+        options: { name: "perplexity" },
+      })
+      expect(result.sdk).toBeDefined()
+    }),
+  )
+
+  it.effect("ignores packages that are not the bundled Perplexity package", () =>
+    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("perplexity"), ModelV2.ID.make("sonar")),
+          api: { id: ModelV2.ID.make("sonar"), type: "aisdk", package: "test-provider" },
+        }),
+        package: "@ai-sdk/perplexity-compatible",
+        options: { name: "perplexity" },
+      })
+      expect(result.sdk).toBeUndefined()
+    }),
+  )
+
+  it.effect("uses the Perplexity provider ID as the SDK name for the bundled provider", () =>
+    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("perplexity"), ModelV2.ID.make("sonar")),
+          api: { id: ModelV2.ID.make("sonar"), type: "aisdk", package: "test-provider" },
+        }),
+        package: "@ai-sdk/perplexity",
+        options: { name: "perplexity" },
+      })
+      expect(result.sdk.languageModel("sonar").provider).toBe("perplexity")
+    }),
+  )
+
+  it.effect("creates bundled Perplexity SDKs for custom provider IDs", () =>
+    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-perplexity"), ModelV2.ID.make("sonar")),
+          api: { id: ModelV2.ID.make("sonar"), type: "aisdk", package: "test-provider" },
+        }),
+        package: "@ai-sdk/perplexity",
+        options: { name: "custom-perplexity" },
+      })
+      expect(result.sdk.languageModel("sonar").provider).toBe("perplexity")
+    }),
+  )
+
+  it.effect("leaves Perplexity language selection to the default languageModel fallback", () =>
+    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("perplexity"), ModelV2.ID.make("alias")),
+          api: { id: ModelV2.ID.make("sonar"), type: "aisdk", package: "test-provider" },
+        }),
+        sdk: fakeSelectorSdk(calls),
+        options: {},
+      })
+      expect(calls).toEqual([])
+      expect(result.language).toBeUndefined()
+    }),
+  )
+})