@neurocode-ai/core 1.18.8

package/src/plugin/provider/opencode.ts

@@ -0,0 +1,311 @@
+import { Duration, Effect, Schema, Semaphore, Stream } from "effect"
+import type { Scope } from "effect"
+import type { IntegrationOAuthMethodRegistration } from "@neurocode-ai/plugin/v2/effect/integration"
+import { define } from "@neurocode-ai/plugin/v2/effect/plugin"
+import type { CredentialValue } from "@neurocode-ai/sdk/v2/types"
+import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http"
+import { EventV2 } from "../../event"
+import { Credential } from "../../credential"
+import { Integration } from "../../integration"
+import { ModelV2 } from "../../model"
+import { ProviderV2 } from "../../provider"
+import { ConfigProviderV1 } from "../../v1/config/provider"
+import { ConfigProviderOptionsV1 } from "../../v1/config/provider-options"
+import { ConfigV1 } from "../../v1/config/config"
+
+const defaultServer = "https://console.opencode.ai"
+const clientID = "opencode-cli"
+const methodID = Integration.MethodID.make("device")
+const RemoteResponse = Schema.Struct({ config: ConfigV1.Info })
+const Device = Schema.Struct({
+  device_code: Schema.String,
+  user_code: Schema.String,
+  verification_uri_complete: Schema.String,
+  expires_in: Schema.Number,
+  interval: Schema.Number,
+})
+const Token = Schema.Struct({
+  access_token: Schema.String,
+  refresh_token: Schema.String,
+  expires_in: Schema.Number,
+})
+const TokenPending = Schema.Struct({ error: Schema.String })
+const DeviceToken = Schema.Union([Token, TokenPending])
+const User = Schema.Struct({ id: Schema.String, email: Schema.String })
+const Org = Schema.Struct({ id: Schema.String, name: Schema.String })
+
+function oauth(http: HttpClient.HttpClient) {
+  return {
+    integrationID: Integration.ID.make("opencode"),
+    method: {
+      id: methodID,
+      type: "oauth",
+      label: "OpenCode Console account",
+    },
+    authorize: () =>
+      Effect.gen(function* () {
+        const device = yield* post(http, `${defaultServer}/auth/device/code`, { client_id: clientID }, Device)
+        return {
+          mode: "auto" as const,
+          url: `${defaultServer}${device.verification_uri_complete}`,
+          instructions: `Enter code: ${device.user_code}`,
+          callback: poll(http, defaultServer, device.device_code, Duration.seconds(device.interval)),
+        }
+      }),
+    refresh: (credential) =>
+      Effect.gen(function* () {
+        const server = typeof credential.metadata?.server === "string" ? credential.metadata.server : defaultServer
+        const token = yield* post(
+          http,
+          `${server}/auth/device/token`,
+          { grant_type: "refresh_token", refresh_token: credential.refresh, client_id: clientID },
+          Token,
+        )
+        return {
+          ...credential,
+          access: token.access_token,
+          refresh: token.refresh_token,
+          expires: Date.now() + token.expires_in * 1000,
+        }
+      }),
+    label: (credential) => {
+      return typeof credential.metadata?.orgName === "string" ? credential.metadata.orgName : undefined
+    },
+  } satisfies IntegrationOAuthMethodRegistration
+}
+
+export const OpencodePlugin = define<HttpClient.HttpClient | EventV2.Service | Scope.Scope>({
+  id: "opencode",
+  effect: Effect.fn(function* (ctx) {
+    const events = yield* EventV2.Service
+    const http = yield* HttpClient.HttpClient
+    const loading = Semaphore.makeUnsafe(1)
+    let connected = false
+    let providers: typeof ConfigV1.Info.Type.provider | undefined
+
+    const load = Effect.fn("OpencodePlugin.load")(function* () {
+      const connection = yield* ctx.integration.connection.active("opencode")
+      const credential = connection
+        ? yield* ctx.integration.connection.resolve(connection).pipe(Effect.catch(() => Effect.succeed(undefined)))
+        : undefined
+      connected = connection !== undefined
+      providers = credential
+        ? yield* fetchProviders(http, credential).pipe(
+            Effect.catch((cause) =>
+              Effect.logWarning("failed to load OpenCode provider config", { cause }).pipe(Effect.as(undefined)),
+            ),
+          )
+        : undefined
+    })
+
+    yield* ctx.integration.transform((draft) => {
+      draft.update("opencode", (integration) => {
+        integration.name = "OpenCode"
+      })
+      draft.method.update(oauth(http))
+      draft.method.update({ integrationID: "opencode", method: { type: "key", label: "API key (service account)" } })
+    })
+
+    connected = (yield* ctx.integration.connection.active("opencode")) !== undefined
+    yield* ctx.catalog.transform((catalog) => {
+      for (const [providerID, item] of Object.entries(providers ?? {})) {
+        catalog.provider.update(providerID, (provider) => {
+          provider.integrationID = Integration.ID.make("opencode")
+          if (item.name !== undefined) provider.name = item.name
+          provider.api = item.npm
+            ? { type: "aisdk", package: item.npm, url: item.api }
+            : { type: "native", url: item.api, settings: {} }
+          Object.assign(provider.request.headers, item.options?.headers)
+          Object.assign(provider.request.body, withoutCredentials(item.options))
+        })
+
+        for (const [modelID, config] of Object.entries(item.models ?? {})) {
+          catalog.model.update(providerID, modelID, (model) => {
+            if (config.family !== undefined) model.family = config.family
+            if (config.name !== undefined) model.name = config.name
+            if (config.id !== undefined) model.api.id = config.id
+            if (config.provider !== undefined) {
+              model.api = config.provider.npm
+                ? {
+                    id: model.api.id,
+                    type: "aisdk",
+                    package: config.provider.npm,
+                    url: config.provider.api,
+                  }
+                : { id: model.api.id, type: "native", url: config.provider.api, settings: {} }
+            }
+            if (config.tool_call !== undefined) model.capabilities.tools = config.tool_call
+            if (config.modalities?.input !== undefined) model.capabilities.input = [...config.modalities.input]
+            if (config.modalities?.output !== undefined) model.capabilities.output = [...config.modalities.output]
+            const packageName = config.provider?.npm ?? item.npm
+            const lowerer = ConfigProviderOptionsV1.get(packageName)
+            Object.assign(model.request.headers, config.headers)
+            Object.assign(model.request.body, lowerer.request(withoutCredentials(config.options)))
+            if (config.variants !== undefined) {
+              model.variants = Object.entries(config.variants).map(([id, options]) => ({
+                id: ModelV2.VariantID.make(id),
+                headers: { ...(options.headers ?? {}) },
+                body: lowerer.request(withoutCredentials(options)),
+              }))
+            }
+            if (config.release_date !== undefined) {
+              const released = Date.parse(config.release_date)
+              model.time.released = Number.isFinite(released) ? released : 0
+            }
+            if (config.cost !== undefined) {
+              model.cost = remoteCost(config.cost)
+            }
+            model.status = config.status ?? "active"
+            model.enabled = config.status !== "deprecated"
+            if (config.limit !== undefined) model.limit = { ...config.limit }
+          })
+        }
+      }
+
+      const item = catalog.provider.get(ProviderV2.ID.opencode)
+      if (!item) return
+      const hasKey = Boolean(process.env.NEUROCODE_API_KEY || connected || item.provider.request.body.apiKey)
+      catalog.provider.update(item.provider.id, (provider) => {
+        if (!hasKey) provider.request.body.apiKey = "public"
+      })
+      if (hasKey) return
+      for (const model of item.models.values()) {
+        if (!model.cost.some((cost) => cost.input > 0)) continue
+        catalog.model.update(item.provider.id, model.id, (draft) => {
+          draft.enabled = false
+        })
+      }
+    })
+
+    const refresh = () => loading.withPermit(load().pipe(Effect.andThen(ctx.catalog.reload())))
+    yield* events.subscribe(Integration.Event.ConnectionUpdated).pipe(
+      Stream.filter((event) => event.data.integrationID === Integration.ID.make("opencode")),
+      Stream.runForEach(refresh),
+      Effect.forkScoped({ startImmediately: true }),
+    )
+    yield* refresh().pipe(Effect.forkScoped)
+  }),
+})
+
+function fetchProviders(http: HttpClient.HttpClient, value: CredentialValue) {
+  const metadata = value.metadata
+  const server = typeof metadata?.server === "string" ? metadata.server : defaultServer
+  const orgID = typeof metadata?.orgID === "string" ? metadata.orgID : undefined
+  const token = value.type === "oauth" ? value.access : value.key
+  return http
+    .execute(
+      HttpClientRequest.get(`${server}/api/config`).pipe(
+        HttpClientRequest.acceptJson,
+        HttpClientRequest.bearerToken(token),
+        HttpClientRequest.setHeaders(orgID ? { "x-org-id": orgID } : {}),
+      ),
+    )
+    .pipe(
+      Effect.flatMap((response) => {
+        if (response.status === 404) return Effect.succeed(undefined)
+        return HttpClientResponse.filterStatusOk(response).pipe(
+          Effect.flatMap(HttpClientResponse.schemaBodyJson(RemoteResponse)),
+          Effect.map((remote) => remote.config.provider),
+        )
+      }),
+    )
+}
+
+function withoutCredentials(body: Readonly<Record<string, unknown>> | undefined) {
+  return Object.fromEntries(Object.entries(body ?? {}).filter(([key]) => key !== "apiKey" && key !== "headers"))
+}
+
+function remoteCost(input: NonNullable<(typeof ConfigProviderV1.Model.Type)["cost"]>) {
+  const base = {
+    input: input.input,
+    output: input.output,
+    cache: { read: input.cache_read ?? 0, write: input.cache_write ?? 0 },
+  }
+  if (!input.context_over_200k) return [base]
+  return [
+    base,
+    {
+      tier: { type: "context" as const, size: 200_000 },
+      input: input.context_over_200k.input,
+      output: input.context_over_200k.output,
+      cache: {
+        read: input.context_over_200k.cache_read ?? 0,
+        write: input.context_over_200k.cache_write ?? 0,
+      },
+    },
+  ]
+}
+
+function poll(http: HttpClient.HttpClient, server: string, deviceCode: string, interval: Duration.Duration) {
+  const loop = (wait: Duration.Duration): Effect.Effect<Credential.OAuth, unknown> =>
+    Effect.gen(function* () {
+      yield* Effect.sleep(wait)
+      const result = yield* post(
+        http,
+        `${server}/auth/device/token`,
+        {
+          grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+          device_code: deviceCode,
+          client_id: clientID,
+        },
+        DeviceToken,
+        false,
+      )
+      if ("access_token" in result) return yield* credential(http, server, result)
+      if (result.error === "authorization_pending") return yield* loop(wait)
+      if (result.error === "slow_down") {
+        return yield* loop(Duration.sum(wait, Duration.seconds(5)))
+      }
+      return yield* Effect.fail(new Error(`Device authorization failed: ${result.error}`))
+    })
+  return loop(interval)
+}
+
+function credential(http: HttpClient.HttpClient, server: string, token: typeof Token.Type) {
+  return Effect.gen(function* () {
+    const [user, orgs] = yield* Effect.all(
+      [
+        get(http, `${server}/api/user`, token.access_token, User),
+        get(http, `${server}/api/orgs`, token.access_token, Schema.Array(Org)),
+      ],
+      { concurrency: 2 },
+    )
+    const org = orgs.toSorted((a, b) => a.name.localeCompare(b.name) || a.id.localeCompare(b.id))[0]
+    return Credential.OAuth.make({
+      type: "oauth" as const,
+      methodID,
+      access: token.access_token,
+      refresh: token.refresh_token,
+      expires: Date.now() + token.expires_in * 1000,
+      metadata: {
+        server,
+        accountID: user.id,
+        email: user.email,
+        orgID: org?.id,
+        orgName: org?.name,
+      },
+    })
+  })
+}
+
+function get<S extends Schema.Top>(http: HttpClient.HttpClient, url: string, token: string, schema: S) {
+  return HttpClient.filterStatusOk(http)
+    .execute(HttpClientRequest.get(url).pipe(HttpClientRequest.acceptJson, HttpClientRequest.bearerToken(token)))
+    .pipe(Effect.flatMap(HttpClientResponse.schemaBodyJson(schema)))
+}
+
+function post<S extends Schema.Top>(
+  http: HttpClient.HttpClient,
+  url: string,
+  body: Record<string, string>,
+  schema: S,
+  statusOk = true,
+) {
+  return HttpClientRequest.post(url).pipe(
+    HttpClientRequest.acceptJson,
+    HttpClientRequest.schemaBodyJson(Schema.Record(Schema.String, Schema.String))(body),
+    Effect.flatMap((request) => http.execute(request)),
+    Effect.flatMap((response) => (statusOk ? HttpClientResponse.filterStatusOk(response) : Effect.succeed(response))),
+    Effect.flatMap(HttpClientResponse.schemaBodyJson(schema)),
+  )
+}

package/src/plugin/provider/openrouter.ts

@@ -0,0 +1,36 @@
+import { Effect } from "effect"
+import { ModelV2 } from "../../model"
+import { define } from "../internal"
+
+export const OpenRouterPlugin = define({
+  id: "openrouter",
+  effect: Effect.fn(function* (ctx) {
+    yield* ctx.catalog.transform(
+      Effect.fn(function* (evt) {
+        for (const item of evt.provider.list()) {
+          if (item.provider.api.type !== "aisdk") continue
+          if (item.provider.api.package !== "@openrouter/ai-sdk-provider") continue
+          evt.provider.update(item.provider.id, (provider) => {
+            provider.request.headers["HTTP-Referer"] = "https://opencode.ai/"
+            provider.request.headers["X-Title"] = "opencode"
+          })
+          for (const modelID of [ModelV2.ID.make("gpt-5-chat-latest"), ModelV2.ID.make("openai/gpt-5-chat")]) {
+            if (!item.models.has(modelID)) continue
+            evt.model.update(item.provider.id, modelID, (model) => {
+              // These are OpenRouter-specific OpenAI chat aliases that do not work
+              // on the generic path. Keep custom providers with matching IDs untouched.
+              model.enabled = false
+            })
+          }
+        }
+      }),
+    )
+    yield* ctx.aisdk.sdk(
+      Effect.fn(function* (evt) {
+        if (evt.package !== "@openrouter/ai-sdk-provider") return
+        const mod = yield* Effect.promise(() => import("@openrouter/ai-sdk-provider"))
+        evt.sdk = mod.createOpenRouter(evt.options)
+      }),
+    )
+  }),
+})

package/src/plugin/provider/perplexity.ts

@@ -0,0 +1,15 @@
+import { Effect } from "effect"
+import { define } from "../internal"
+
+export const PerplexityPlugin = define({
+  id: "perplexity",
+  effect: Effect.fn(function* (ctx) {
+    yield* ctx.aisdk.sdk(
+      Effect.fn(function* (evt) {
+        if (evt.package !== "@ai-sdk/perplexity") return
+        const mod = yield* Effect.promise(() => import("@ai-sdk/perplexity"))
+        evt.sdk = mod.createPerplexity(evt.options)
+      }),
+    )
+  }),
+})

package/src/plugin/provider/sap-ai-core.ts

@@ -0,0 +1,46 @@
+import { Effect } from "effect"
+import { pathToFileURL } from "url"
+import { define } from "../internal"
+import { Npm } from "../../npm"
+import { ProviderV2 } from "../../provider"
+
+export const SapAICorePlugin = define({
+  id: "sap-ai-core",
+  effect: Effect.fn(function* (ctx) {
+    const npm = yield* Npm.Service
+    yield* ctx.aisdk.sdk(
+      Effect.fn(function* (evt) {
+        if (evt.model.providerID !== ProviderV2.ID.make("sap-ai-core")) return
+        const serviceKey =
+          process.env.AICORE_SERVICE_KEY ??
+          (typeof evt.options.serviceKey === "string" ? evt.options.serviceKey : undefined)
+        if (serviceKey && !process.env.AICORE_SERVICE_KEY) process.env.AICORE_SERVICE_KEY = serviceKey
+
+        const installedPath = evt.package.startsWith("file://")
+          ? evt.package
+          : (yield* npm.add(evt.package).pipe(Effect.orDie)).entrypoint
+        if (!installedPath) throw new Error(`Package ${evt.package} has no import entrypoint`)
+
+        const mod = yield* Effect.promise(async () => {
+          return (await import(
+            installedPath.startsWith("file://") ? installedPath : pathToFileURL(installedPath).href
+          )) as Record<string, (options: any) => any>
+        }).pipe(Effect.orDie)
+        const match = Object.keys(mod).find((name) => name.startsWith("create"))
+        if (!match) throw new Error(`Package ${evt.package} has no provider factory export`)
+
+        evt.sdk = mod[match](
+          serviceKey
+            ? { deploymentId: process.env.AICORE_DEPLOYMENT_ID, resourceGroup: process.env.AICORE_RESOURCE_GROUP }
+            : {},
+        )
+      }),
+    )
+    yield* ctx.aisdk.language(
+      Effect.fn(function* (evt) {
+        if (evt.model.providerID !== ProviderV2.ID.make("sap-ai-core")) return
+        evt.language = evt.sdk(evt.model.api.id)
+      }),
+    )
+  }),
+})

package/src/plugin/provider/snowflake-cortex.ts

@@ -0,0 +1,89 @@
+import { Effect } from "effect"
+import { define } from "../internal"
+import { ProviderV2 } from "../../provider"
+
+type FetchLike = (url: string | URL | Request, init?: RequestInit) => Promise<Response>
+
+// Exported for testing: intercepts Cortex-specific request/response quirks.
+export function cortexFetch(upstream: FetchLike = fetch) {
+  return async (url: string | URL | Request, init?: RequestInit): Promise<Response> => {
+    if (init?.body && typeof init.body === "string") {
+      try {
+        const body = JSON.parse(init.body)
+        if ("max_tokens" in body) {
+          body.max_completion_tokens = body.max_tokens
+          delete body.max_tokens
+          init = { ...init, body: JSON.stringify(body) }
+        }
+      } catch {}
+    }
+
+    const response = await upstream(url, init)
+
+    // Cortex returns 400 "conversation complete" as a normal stop condition
+    if (!response.ok && response.status === 400) {
+      try {
+        const errorData = (await response.clone().json()) as Record<string, unknown>
+        if (
+          String(errorData.message || errorData.error || "")
+            .toLowerCase()
+            .includes("conversation complete")
+        ) {
+          return new Response(
+            JSON.stringify({ choices: [{ finish_reason: "stop", message: { content: "", role: "assistant" } }] }),
+            { status: 200, headers: new Headers({ "content-type": "application/json" }) },
+          )
+        }
+      } catch {}
+    }
+
+    // Cortex returns role:"" in streaming deltas; the AI SDK schema requires "assistant"
+    if (response.body && response.headers.get("content-type")?.includes("text/event-stream")) {
+      const reader = response.body.getReader()
+      const encoder = new TextEncoder()
+      const decoder = new TextDecoder()
+      const stream = new ReadableStream({
+        async pull(ctrl) {
+          const { done, value } = await reader.read()
+          if (done) {
+            ctrl.close()
+            return
+          }
+          ctrl.enqueue(
+            encoder.encode(decoder.decode(value, { stream: true }).replace(/"role"\s*:\s*""/g, '"role":"assistant"')),
+          )
+        },
+        cancel() {
+          reader.cancel()
+        },
+      })
+      return new Response(stream, { headers: response.headers, status: response.status })
+    }
+
+    return response
+  }
+}
+
+export const SnowflakeCortexPlugin = define({
+  id: "snowflake-cortex",
+  effect: Effect.fn(function* (ctx) {
+    yield* ctx.aisdk.sdk(
+      Effect.fn(function* (evt) {
+        if (evt.model.providerID !== ProviderV2.ID.make("snowflake-cortex")) return
+        const token =
+          process.env.SNOWFLAKE_CORTEX_TOKEN ??
+          process.env.SNOWFLAKE_CORTEX_PAT ??
+          (typeof evt.options.token === "string" ? evt.options.token : undefined) ??
+          (typeof evt.options.apiKey === "string" ? evt.options.apiKey : undefined)
+        const upstream = typeof evt.options.fetch === "function" ? (evt.options.fetch as FetchLike) : undefined
+        if (evt.options.includeUsage !== false) evt.options.includeUsage = true
+        const mod = yield* Effect.promise(() => import("@ai-sdk/openai-compatible"))
+        evt.sdk = mod.createOpenAICompatible({
+          ...evt.options,
+          ...(token ? { apiKey: token } : {}),
+          fetch: cortexFetch(upstream) as typeof fetch,
+        } as any)
+      }),
+    )
+  }),
+})

package/src/plugin/provider/togetherai.ts

@@ -0,0 +1,15 @@
+import { Effect } from "effect"
+import { define } from "../internal"
+
+export const TogetherAIPlugin = define({
+  id: "togetherai",
+  effect: Effect.fn(function* (ctx) {
+    yield* ctx.aisdk.sdk(
+      Effect.fn(function* (evt) {
+        if (evt.package !== "@ai-sdk/togetherai") return
+        const mod = yield* Effect.promise(() => import("@ai-sdk/togetherai"))
+        evt.sdk = mod.createTogetherAI(evt.options)
+      }),
+    )
+  }),
+})

package/src/plugin/provider/venice.ts

@@ -0,0 +1,15 @@
+import { Effect } from "effect"
+import { define } from "../internal"
+
+export const VenicePlugin = define({
+  id: "venice",
+  effect: Effect.fn(function* (ctx) {
+    yield* ctx.aisdk.sdk(
+      Effect.fn(function* (evt) {
+        if (evt.package !== "venice-ai-sdk-provider") return
+        const mod = yield* Effect.promise(() => import("venice-ai-sdk-provider"))
+        evt.sdk = mod.createVenice(evt.options)
+      }),
+    )
+  }),
+})

package/src/plugin/provider/vercel.ts

@@ -0,0 +1,27 @@
+import { Effect } from "effect"
+import { define } from "../internal"
+
+export const VercelPlugin = define({
+  id: "vercel",
+  effect: Effect.fn(function* (ctx) {
+    yield* ctx.catalog.transform(
+      Effect.fn(function* (evt) {
+        for (const item of evt.provider.list()) {
+          if (item.provider.api.type !== "aisdk") continue
+          if (item.provider.api.package !== "@ai-sdk/vercel") continue
+          evt.provider.update(item.provider.id, (provider) => {
+            provider.request.headers["http-referer"] = "https://opencode.ai/"
+            provider.request.headers["x-title"] = "opencode"
+          })
+        }
+      }),
+    )
+    yield* ctx.aisdk.sdk(
+      Effect.fn(function* (evt) {
+        if (evt.package !== "@ai-sdk/vercel") return
+        const mod = yield* Effect.promise(() => import("@ai-sdk/vercel"))
+        evt.sdk = mod.createVercel(evt.options)
+      }),
+    )
+  }),
+})

package/src/plugin/provider/xai.ts

@@ -0,0 +1,22 @@
+import { Effect } from "effect"
+import { define } from "../internal"
+import { ProviderV2 } from "../../provider"
+
+export const XAIPlugin = define({
+  id: "xai",
+  effect: Effect.fn(function* (ctx) {
+    yield* ctx.aisdk.sdk(
+      Effect.fn(function* (evt) {
+        if (evt.package !== "@ai-sdk/xai") return
+        const mod = yield* Effect.promise(() => import("@ai-sdk/xai"))
+        evt.sdk = mod.createXai(evt.options)
+      }),
+    )
+    yield* ctx.aisdk.language(
+      Effect.fn(function* (evt) {
+        if (evt.model.providerID !== ProviderV2.ID.make("xai")) return
+        evt.language = evt.sdk.responses(evt.model.api.id)
+      }),
+    )
+  }),
+})

package/src/plugin/provider/zenmux.ts

@@ -0,0 +1,21 @@
+import { Effect } from "effect"
+import { define } from "../internal"
+
+export const ZenmuxPlugin = define({
+  id: "zenmux",
+  effect: Effect.fn(function* (ctx) {
+    yield* ctx.catalog.transform(
+      Effect.fn(function* (evt) {
+        for (const item of evt.provider.list()) {
+          if (item.provider.api.type !== "aisdk") continue
+          if (item.provider.api.package !== "@ai-sdk/openai-compatible") continue
+          if (item.provider.api.url !== "https://zenmux.ai/api/v1") continue
+          evt.provider.update(item.provider.id, (provider) => {
+            provider.request.headers["HTTP-Referer"] ??= "https://opencode.ai/"
+            provider.request.headers["X-Title"] ??= "opencode"
+          })
+        }
+      }),
+    )
+  }),
+})

package/src/plugin/provider.ts

@@ -0,0 +1,71 @@
+import { AlibabaPlugin } from "./provider/alibaba"
+import { AmazonBedrockPlugin } from "./provider/amazon-bedrock"
+import { AnthropicPlugin } from "./provider/anthropic"
+import { AzureCognitiveServicesPlugin, AzurePlugin } from "./provider/azure"
+import { CerebrasPlugin } from "./provider/cerebras"
+import { CloudflareAIGatewayPlugin } from "./provider/cloudflare-ai-gateway"
+import { CloudflareWorkersAIPlugin } from "./provider/cloudflare-workers-ai"
+import { CoherePlugin } from "./provider/cohere"
+import { DeepInfraPlugin } from "./provider/deepinfra"
+import { DynamicProviderPlugin } from "./provider/dynamic"
+import { GatewayPlugin } from "./provider/gateway"
+import { GithubCopilotPlugin } from "./provider/github-copilot"
+import { GitLabPlugin } from "./provider/gitlab"
+import { GooglePlugin } from "./provider/google"
+import { GoogleVertexAnthropicPlugin, GoogleVertexPlugin } from "./provider/google-vertex"
+import { GroqPlugin } from "./provider/groq"
+import { KiloPlugin } from "./provider/kilo"
+import { LLMGatewayPlugin } from "./provider/llmgateway"
+import { MistralPlugin } from "./provider/mistral"
+import { NvidiaPlugin } from "./provider/nvidia"
+import { OpenAIPlugin } from "./provider/openai"
+import { SnowflakeCortexPlugin } from "./provider/snowflake-cortex"
+import { OpenAICompatiblePlugin } from "./provider/openai-compatible"
+import { OpencodePlugin } from "./provider/opencode"
+import { OpenRouterPlugin } from "./provider/openrouter"
+import { PerplexityPlugin } from "./provider/perplexity"
+import { SapAICorePlugin } from "./provider/sap-ai-core"
+import { TogetherAIPlugin } from "./provider/togetherai"
+import { VercelPlugin } from "./provider/vercel"
+import { VenicePlugin } from "./provider/venice"
+import { XAIPlugin } from "./provider/xai"
+import { ZenmuxPlugin } from "./provider/zenmux"
+import type { PluginInternal } from "./internal"
+import type { Scope } from "effect"
+
+export const ProviderPlugins: PluginInternal.Plugin<PluginInternal.Requirements | Scope.Scope>[] = [
+  AlibabaPlugin,
+  AmazonBedrockPlugin,
+  AnthropicPlugin,
+  AzureCognitiveServicesPlugin,
+  AzurePlugin,
+  CerebrasPlugin,
+  CloudflareAIGatewayPlugin,
+  CloudflareWorkersAIPlugin,
+  CoherePlugin,
+  DeepInfraPlugin,
+  GatewayPlugin,
+  GithubCopilotPlugin,
+  GitLabPlugin,
+  GooglePlugin,
+  GoogleVertexAnthropicPlugin,
+  GoogleVertexPlugin,
+  GroqPlugin,
+  KiloPlugin,
+  LLMGatewayPlugin,
+  MistralPlugin,
+  NvidiaPlugin,
+  OpencodePlugin,
+  SnowflakeCortexPlugin,
+  OpenAICompatiblePlugin,
+  OpenAIPlugin,
+  OpenRouterPlugin,
+  PerplexityPlugin,
+  SapAICorePlugin,
+  TogetherAIPlugin,
+  VercelPlugin,
+  VenicePlugin,
+  XAIPlugin,
+  ZenmuxPlugin,
+  DynamicProviderPlugin,
+]