@neurocode-ai/core 1.18.8

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

@@ -0,0 +1,136 @@
+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 { CerebrasPlugin } from "@neurocode-ai/core/plugin/provider/cerebras"
+import { ProviderV2 } from "@neurocode-ai/core/provider"
+import { testEffect } from "../lib/effect"
+import { PluginTestLayer } from "./fixture"
+
+const cerebrasOptions: Record<string, unknown>[] = []
+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* CerebrasPlugin.effect(host)
+})
+
+void mock.module("@ai-sdk/cerebras", () => ({
+  createCerebras: (options: Record<string, unknown>) => {
+    const snapshot = { ...options }
+    cerebrasOptions.push(snapshot)
+    return {
+      languageModel: (modelID: string) => ({ modelID, provider: snapshot.name, specificationVersion: "v3" }),
+    }
+  },
+}))
+
+describe("CerebrasPlugin", () => {
+  it.effect("applies the legacy integration header", () =>
+    Effect.gen(function* () {
+      const catalog = yield* Catalog.Service
+      yield* catalog.transform((catalog) => {
+        catalog.provider.update(ProviderV2.ID.make("cerebras"), (item) => {
+          item.api = { type: "aisdk", package: "@ai-sdk/cerebras" }
+          item.request.headers.Existing = "1"
+        })
+      })
+      yield* addPlugin()
+      expect((yield* catalog.provider.get(ProviderV2.ID.make("cerebras")))?.request.headers).toEqual({
+        Existing: "1",
+        "X-Cerebras-3rd-Party-Integration": "neurocode",
+      })
+    }),
+  )
+
+  it.effect("ignores non-Cerebras providers", () =>
+    Effect.gen(function* () {
+      const catalog = yield* Catalog.Service
+      yield* catalog.transform((catalog) => catalog.provider.update(ProviderV2.ID.make("groq"), () => {}))
+      yield* addPlugin()
+      expect((yield* catalog.provider.get(ProviderV2.ID.make("groq")))?.request.headers).toEqual({})
+    }),
+  )
+
+  it.effect("creates a bundled Cerebras SDK with the model provider ID as the SDK name", () =>
+    Effect.gen(function* () {
+      cerebrasOptions.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("custom-cerebras"),
+            ModelV2.ID.make("llama-4-scout-17b-16e-instruct"),
+          ),
+          api: {
+            id: ModelV2.ID.make("llama-4-scout-17b-16e-instruct"),
+            type: "aisdk",
+            package: "test-provider",
+          },
+        }),
+        package: "@ai-sdk/cerebras",
+        options: { name: "custom-cerebras", apiKey: "test" },
+      })
+      expect(cerebrasOptions).toEqual([{ name: "custom-cerebras", apiKey: "test" }])
+      expect(result.sdk.languageModel("llama-4-scout-17b-16e-instruct").provider).toBe("custom-cerebras")
+    }),
+  )
+
+  it.effect("preserves an explicit bundled Cerebras SDK name option", () =>
+    Effect.gen(function* () {
+      cerebrasOptions.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("custom-cerebras"),
+            ModelV2.ID.make("llama-4-scout-17b-16e-instruct"),
+          ),
+          api: {
+            id: ModelV2.ID.make("llama-4-scout-17b-16e-instruct"),
+            type: "aisdk",
+            package: "test-provider",
+          },
+        }),
+        package: "@ai-sdk/cerebras",
+        options: { name: "configured-cerebras", apiKey: "test" },
+      })
+      expect(cerebrasOptions).toEqual([{ name: "configured-cerebras", apiKey: "test" }])
+    }),
+  )
+
+  it.effect("ignores non-Cerebras SDK packages", () =>
+    Effect.gen(function* () {
+      cerebrasOptions.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("custom-cerebras"),
+            ModelV2.ID.make("llama-4-scout-17b-16e-instruct"),
+          ),
+          api: {
+            id: ModelV2.ID.make("llama-4-scout-17b-16e-instruct"),
+            type: "aisdk",
+            package: "test-provider",
+          },
+        }),
+        package: "@ai-sdk/groq",
+        options: { name: "custom-cerebras", apiKey: "test" },
+      })
+      expect(cerebrasOptions).toEqual([])
+      expect(result.sdk).toBeUndefined()
+    }),
+  )
+})

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

@@ -0,0 +1,426 @@
+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 { CloudflareAIGatewayPlugin } from "@neurocode-ai/core/plugin/provider/cloudflare-ai-gateway"
+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* CloudflareAIGatewayPlugin.effect(host)
+})
+
+function withEnv<A, E, R>(vars: Record<string, string | undefined>, fx: () => 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
+    }),
+    fx,
+    (previous) =>
+      Effect.sync(() => {
+        Object.entries(previous).forEach(([key, value]) => {
+          if (value === undefined) delete process.env[key]
+          else process.env[key] = value
+        })
+      }),
+  )
+}
+
+const aiGatewayCalls: Record<string, unknown>[] = []
+const unifiedCalls: string[] = []
+const gatewayModelCalls: unknown[] = []
+
+function captureAiGatewayOptions(options: Record<string, unknown>) {
+  const nested =
+    options.options && typeof options.options === "object" ? (options.options as Record<string, unknown>) : undefined
+  return {
+    ...options,
+    ...(nested
+      ? {
+          options: {
+            ...nested,
+            headers:
+              nested.headers && typeof nested.headers === "object"
+                ? { ...(nested.headers as Record<string, unknown>) }
+                : nested.headers,
+          },
+        }
+      : {}),
+  }
+}
+
+function resetCalls() {
+  aiGatewayCalls.length = 0
+  unifiedCalls.length = 0
+  gatewayModelCalls.length = 0
+}
+
+function cloudflareEnv(overrides: Record<string, string | undefined> = {}) {
+  return {
+    CLOUDFLARE_ACCOUNT_ID: "env-account",
+    CLOUDFLARE_GATEWAY_ID: "env-gateway",
+    CLOUDFLARE_API_TOKEN: "env-token",
+    CF_AIG_TOKEN: undefined,
+    ...overrides,
+  }
+}
+
+mock.module("ai-gateway-provider", () => ({
+  createAiGateway(options: Record<string, unknown>) {
+    aiGatewayCalls.push(captureAiGatewayOptions(options))
+    return (input: unknown) => {
+      gatewayModelCalls.push(input)
+      return {
+        modelId: input,
+        provider: "cloudflare-ai-gateway",
+        specificationVersion: "v3",
+      }
+    }
+  },
+}))
+
+mock.module("ai-gateway-provider/providers/unified", () => ({
+  createUnified() {
+    return (modelID: string) => {
+      unifiedCalls.push(modelID)
+      return { unifiedModelID: modelID }
+    }
+  },
+}))
+
+describe("CloudflareAIGatewayPlugin", () => {
+  it.effect("requires account, gateway, and token before creating the unified SDK", () =>
+    withEnv(
+      {
+        CLOUDFLARE_ACCOUNT_ID: "acct",
+        CLOUDFLARE_GATEWAY_ID: "gateway",
+        CLOUDFLARE_API_TOKEN: "token",
+        CF_AIG_TOKEN: undefined,
+      },
+      () =>
+        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("cloudflare-ai-gateway"), ModelV2.ID.make("openai/gpt-5")),
+              api: { id: ModelV2.ID.make("openai/gpt-5"), type: "aisdk", package: "test-provider" },
+            }),
+            package: "ai-gateway-provider",
+            options: { name: "cloudflare-ai-gateway" },
+          })
+          expect(result.sdk.languageModel("openai/gpt-5")).toBeDefined()
+        }),
+    ),
+  )
+
+  it.effect("passes legacy metadata, cache, log, and User-Agent values under the AI Gateway options key", () =>
+    withEnv(cloudflareEnv(), () =>
+      Effect.gen(function* () {
+        resetCalls()
+        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("cloudflare-ai-gateway"), ModelV2.ID.make("openai/gpt-5")),
+            api: { id: ModelV2.ID.make("openai/gpt-5"), type: "aisdk", package: "test-provider" },
+          }),
+          package: "ai-gateway-provider",
+          options: {
+            name: "cloudflare-ai-gateway",
+            metadata: { invoked_by: "test", project: "neurocode" },
+            cacheTtl: 300,
+            cacheKey: "cache-key",
+            skipCache: true,
+            collectLog: false,
+          },
+        })
+
+        expect(aiGatewayCalls).toHaveLength(1)
+        expect(aiGatewayCalls[0]).toEqual({
+          accountId: "env-account",
+          gateway: "env-gateway",
+          apiKey: "env-token",
+          options: {
+            metadata: { invoked_by: "test", project: "neurocode" },
+            cacheTtl: 300,
+            cacheKey: "cache-key",
+            skipCache: true,
+            collectLog: false,
+            headers: {
+              "User-Agent": expect.stringContaining("opencode/"),
+            },
+          },
+        })
+      }),
+    ),
+  )
+
+  it.effect("parses legacy cf-aig-metadata header when metadata option is absent", () =>
+    withEnv(cloudflareEnv(), () =>
+      Effect.gen(function* () {
+        resetCalls()
+        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("cloudflare-ai-gateway"), ModelV2.ID.make("openai/gpt-5")),
+            api: { id: ModelV2.ID.make("openai/gpt-5"), type: "aisdk", package: "test-provider" },
+          }),
+          package: "ai-gateway-provider",
+          options: {
+            name: "cloudflare-ai-gateway",
+            headers: {
+              "cf-aig-metadata": JSON.stringify({ invoked_by: "header", project: "neurocode" }),
+            },
+          },
+        })
+
+        expect(aiGatewayCalls[0]?.options).toMatchObject({
+          metadata: { invoked_by: "header", project: "neurocode" },
+        })
+      }),
+    ),
+  )
+
+  it.effect("prefers Cloudflare env values over auth/config-derived options", () =>
+    withEnv(cloudflareEnv(), () =>
+      Effect.gen(function* () {
+        resetCalls()
+        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("cloudflare-ai-gateway"), ModelV2.ID.make("openai/gpt-5")),
+            api: { id: ModelV2.ID.make("openai/gpt-5"), type: "aisdk", package: "test-provider" },
+          }),
+          package: "ai-gateway-provider",
+          options: {
+            name: "cloudflare-ai-gateway",
+            accountId: "auth-account",
+            gateway: "auth-gateway",
+            apiKey: "auth-token",
+          },
+        })
+
+        expect(aiGatewayCalls[0]).toMatchObject({
+          accountId: "env-account",
+          gateway: "env-gateway",
+          apiKey: "env-token",
+        })
+      }),
+    ),
+  )
+
+  it.effect("accepts gatewayId metadata copied from auth into provider options", () =>
+    withEnv(
+      cloudflareEnv({
+        CLOUDFLARE_ACCOUNT_ID: undefined,
+        CLOUDFLARE_GATEWAY_ID: undefined,
+        CLOUDFLARE_API_TOKEN: undefined,
+      }),
+      () =>
+        Effect.gen(function* () {
+          resetCalls()
+          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("cloudflare-ai-gateway"), ModelV2.ID.make("openai/gpt-5")),
+              api: { id: ModelV2.ID.make("openai/gpt-5"), type: "aisdk", package: "test-provider" },
+            }),
+            package: "ai-gateway-provider",
+            options: {
+              name: "cloudflare-ai-gateway",
+              accountId: "auth-account",
+              gatewayId: "auth-gateway",
+              apiKey: "auth-token",
+            },
+          })
+
+          expect(aiGatewayCalls[0]).toMatchObject({
+            accountId: "auth-account",
+            gateway: "auth-gateway",
+            apiKey: "auth-token",
+          })
+        }),
+    ),
+  )
+
+  it.effect("falls back to CF_AIG_TOKEN when CLOUDFLARE_API_TOKEN is unset", () =>
+    withEnv(cloudflareEnv({ CLOUDFLARE_API_TOKEN: undefined, CF_AIG_TOKEN: "cf-aig-token" }), () =>
+      Effect.gen(function* () {
+        resetCalls()
+        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("cloudflare-ai-gateway"), ModelV2.ID.make("openai/gpt-5")),
+            api: { id: ModelV2.ID.make("openai/gpt-5"), type: "aisdk", package: "test-provider" },
+          }),
+          package: "ai-gateway-provider",
+          options: { name: "cloudflare-ai-gateway" },
+        })
+
+        expect(aiGatewayCalls[0]).toMatchObject({ apiKey: "cf-aig-token" })
+      }),
+    ),
+  )
+
+  it.effect("does not create an SDK when account and gateway IDs are missing", () =>
+    withEnv(cloudflareEnv({ CLOUDFLARE_ACCOUNT_ID: undefined, CLOUDFLARE_GATEWAY_ID: undefined }), () =>
+      Effect.gen(function* () {
+        resetCalls()
+        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("cloudflare-ai-gateway"), ModelV2.ID.make("openai/gpt-5")),
+            api: { id: ModelV2.ID.make("openai/gpt-5"), type: "aisdk", package: "test-provider" },
+          }),
+          package: "ai-gateway-provider",
+          options: { name: "cloudflare-ai-gateway" },
+        })
+
+        expect(result.sdk).toBeUndefined()
+        expect(aiGatewayCalls).toHaveLength(0)
+      }),
+    ),
+  )
+
+  it.effect("does not create an SDK when the token is missing", () =>
+    withEnv(cloudflareEnv({ CLOUDFLARE_API_TOKEN: undefined, CF_AIG_TOKEN: undefined }), () =>
+      Effect.gen(function* () {
+        resetCalls()
+        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("cloudflare-ai-gateway"), ModelV2.ID.make("openai/gpt-5")),
+            api: { id: ModelV2.ID.make("openai/gpt-5"), type: "aisdk", package: "test-provider" },
+          }),
+          package: "ai-gateway-provider",
+          options: { name: "cloudflare-ai-gateway" },
+        })
+
+        expect(result.sdk).toBeUndefined()
+        expect(aiGatewayCalls).toHaveLength(0)
+      }),
+    ),
+  )
+
+  it.effect("does not replace a configured baseURL with the Cloudflare AI Gateway SDK", () =>
+    withEnv(
+      cloudflareEnv({
+        CLOUDFLARE_ACCOUNT_ID: undefined,
+        CLOUDFLARE_GATEWAY_ID: undefined,
+        CLOUDFLARE_API_TOKEN: undefined,
+      }),
+      () =>
+        Effect.gen(function* () {
+          resetCalls()
+          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("cloudflare-ai-gateway"), ModelV2.ID.make("openai/gpt-5")),
+              api: { id: ModelV2.ID.make("openai/gpt-5"), type: "aisdk", package: "test-provider" },
+            }),
+            package: "ai-gateway-provider",
+            options: { name: "cloudflare-ai-gateway", baseURL: "https://proxy.example/v1" },
+          })
+
+          expect(result.sdk).toBeUndefined()
+          expect(aiGatewayCalls).toHaveLength(0)
+        }),
+    ),
+  )
+
+  it.effect("maps provider/model IDs through the unified Cloudflare provider unchanged", () =>
+    withEnv(cloudflareEnv(), () =>
+      Effect.gen(function* () {
+        resetCalls()
+        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("cloudflare-ai-gateway"),
+              ModelV2.ID.make("anthropic/claude-sonnet-4-5"),
+            ),
+            api: {
+              id: ModelV2.ID.make("anthropic/claude-sonnet-4-5"),
+              type: "aisdk",
+              package: "test-provider",
+            },
+          }),
+          package: "ai-gateway-provider",
+          options: { name: "cloudflare-ai-gateway" },
+        })
+
+        expect(result.sdk.languageModel("anthropic/claude-sonnet-4-5")).toEqual({
+          modelId: { unifiedModelID: "anthropic/claude-sonnet-4-5" },
+          provider: "cloudflare-ai-gateway",
+          specificationVersion: "v3",
+        })
+        expect(unifiedCalls).toEqual(["anthropic/claude-sonnet-4-5"])
+        expect(gatewayModelCalls).toEqual([{ unifiedModelID: "anthropic/claude-sonnet-4-5" }])
+      }),
+    ),
+  )
+
+  it.effect("ignores non Cloudflare AI Gateway packages", () =>
+    withEnv(cloudflareEnv(), () =>
+      Effect.gen(function* () {
+        resetCalls()
+        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("cloudflare-ai-gateway"), 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: "cloudflare-ai-gateway" },
+        })
+
+        expect(result.sdk).toBeUndefined()
+        expect(aiGatewayCalls).toHaveLength(0)
+      }),
+    ),
+  )
+})