@neurocode-ai/core 1.18.8

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

@@ -0,0 +1,83 @@
+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 { VercelPlugin } from "@neurocode-ai/core/plugin/provider/vercel"
+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* VercelPlugin.effect(host)
+})
+
+describe("VercelPlugin", () => {
+  it.effect("applies legacy lower-case referer headers", () =>
+    Effect.gen(function* () {
+      const catalog = yield* Catalog.Service
+      yield* catalog.transform((catalog) => {
+        catalog.provider.update(ProviderV2.ID.make("vercel"), (provider) => {
+          provider.api = { type: "aisdk", package: "@ai-sdk/vercel" }
+          provider.request.headers.Existing = "1"
+        })
+      })
+      yield* addPlugin()
+      expect((yield* catalog.provider.get(ProviderV2.ID.make("vercel")))?.request.headers).toEqual({
+        Existing: "1",
+        "http-referer": "https://neurocode.ai/",
+        "x-title": "neurocode",
+      })
+    }),
+  )
+
+  it.effect("does not add legacy upper-case referer headers", () =>
+    Effect.gen(function* () {
+      const catalog = yield* Catalog.Service
+      yield* catalog.transform((catalog) =>
+        catalog.provider.update(ProviderV2.ID.make("vercel"), (provider) => {
+          provider.api = { type: "aisdk", package: "@ai-sdk/vercel" }
+        }),
+      )
+      yield* addPlugin()
+      expect((yield* catalog.provider.get(ProviderV2.ID.make("vercel")))?.request.headers).not.toHaveProperty(
+        "HTTP-Referer",
+      )
+      expect((yield* catalog.provider.get(ProviderV2.ID.make("vercel")))?.request.headers).not.toHaveProperty("X-Title")
+    }),
+  )
+
+  it.effect("creates @ai-sdk/vercel SDKs for custom provider IDs", () =>
+    Effect.gen(function* () {
+      const plugin = yield* PluginV2.Service
+      const aisdk = yield* AISDK.Service
+      yield* addPlugin()
+      const event = yield* aisdk.runSDK({
+        model: ModelV2.Info.make({
+          ...ModelV2.Info.empty(ProviderV2.ID.make("custom-vercel"), ModelV2.ID.make("v0-1.0-md")),
+          api: { id: ModelV2.ID.make("v0-1.0-md"), type: "aisdk", package: "@ai-sdk/vercel" },
+        }),
+        package: "@ai-sdk/vercel",
+        options: { name: "custom-vercel" },
+      })
+      expect(event.sdk).toBeDefined()
+      expect(event.sdk.languageModel("v0-1.0-md").provider).toBe("vercel.chat")
+    }),
+  )
+
+  it.effect("ignores non-Vercel providers", () =>
+    Effect.gen(function* () {
+      const catalog = yield* Catalog.Service
+      yield* catalog.transform((catalog) => catalog.provider.update(ProviderV2.ID.make("gateway"), () => {}))
+      yield* addPlugin()
+      expect((yield* catalog.provider.get(ProviderV2.ID.make("gateway")))?.request.headers).toEqual({})
+    }),
+  )
+})

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

@@ -0,0 +1,125 @@
+import { AISDK } from "@neurocode-ai/core/aisdk"
+import type { LanguageModelV3 } from "@ai-sdk/provider"
+import { describe, expect } from "bun:test"
+import { Effect } from "effect"
+import { ModelV2 } from "@neurocode-ai/core/model"
+import { PluginV2 } from "@neurocode-ai/core/plugin"
+import { PluginHost } from "@neurocode-ai/core/plugin/host"
+import { XAIPlugin } from "@neurocode-ai/core/plugin/provider/xai"
+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* XAIPlugin.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("XAIPlugin", () => {
+  it.effect("creates an xAI SDK only for @ai-sdk/xai", () =>
+    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("xai"), ModelV2.ID.make("grok-4")),
+          api: { id: ModelV2.ID.make("grok-4"), type: "aisdk", package: "@ai-sdk/xai" },
+        }),
+        package: "@ai-sdk/openai-compatible",
+        options: {},
+      })
+
+      const result = yield* aisdk.runSDK({
+        model: ModelV2.Info.make({
+          ...ModelV2.Info.empty(ProviderV2.ID.make("xai"), ModelV2.ID.make("grok-4")),
+          api: { id: ModelV2.ID.make("grok-4"), type: "aisdk", package: "@ai-sdk/xai" },
+        }),
+        package: "@ai-sdk/xai",
+        options: {},
+      })
+
+      expect(ignored.sdk).toBeUndefined()
+      expect(typeof result.sdk?.responses).toBe("function")
+    }),
+  )
+
+  it.effect("creates xAI 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-xai"), ModelV2.ID.make("grok-4")),
+          api: { id: ModelV2.ID.make("grok-4"), type: "aisdk", package: "@ai-sdk/xai" },
+        }),
+        package: "@ai-sdk/xai",
+        options: {},
+      })
+
+      expect(result.sdk.responses("grok-4").provider).toBe("xai.responses")
+    }),
+  )
+
+  it.effect("uses responses with the model api.id for xAI language models", () =>
+    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("xai"), ModelV2.ID.make("alias")),
+          api: { id: ModelV2.ID.make("grok-4"), type: "aisdk", package: "@ai-sdk/xai" },
+        }),
+        sdk: fakeSelectorSdk(calls),
+        options: {},
+      })
+
+      expect(calls).toEqual(["responses:grok-4"])
+      expect(result.language).toBeDefined()
+    }),
+  )
+
+  it.effect("ignores non-xAI 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.openai, ModelV2.ID.make("grok-4")),
+          api: { id: ModelV2.ID.make("grok-4"), type: "aisdk", package: "@ai-sdk/xai" },
+        }),
+        sdk: fakeSelectorSdk(calls),
+        options: {},
+      })
+
+      expect(calls).toEqual([])
+      expect(result.language).toBeUndefined()
+    }),
+  )
+})

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

@@ -0,0 +1,110 @@
+import { describe, expect } from "bun:test"
+import { Effect } from "effect"
+import { Catalog } from "@neurocode-ai/core/catalog"
+import { PluginV2 } from "@neurocode-ai/core/plugin"
+import { PluginHost } from "@neurocode-ai/core/plugin/host"
+import { ProviderPlugins } from "@neurocode-ai/core/plugin/provider"
+import { ZenmuxPlugin } from "@neurocode-ai/core/plugin/provider/zenmux"
+import { ProviderV2 } from "@neurocode-ai/core/provider"
+import { testEffect } from "../lib/effect"
+import { PluginTestLayer } from "./fixture"
+
+const it = testEffect(PluginTestLayer)
+
+const addPlugin = Effect.fn(function* () {
+  const plugin = yield* PluginV2.Service
+  const host = yield* PluginHost.make(plugin)
+  yield* ZenmuxPlugin.effect(host)
+})
+
+function required<T>(value: T | undefined): T {
+  if (value === undefined) throw new Error("Expected value")
+  return value
+}
+
+describe("ZenmuxPlugin", () => {
+  it.effect("is registered so legacy referer headers can be applied", () =>
+    Effect.sync(() => expect(ProviderPlugins.map((item) => item.id)).toContain(PluginV2.ID.make("zenmux"))),
+  )
+
+  it.effect("applies the exact legacy Zenmux headers", () =>
+    Effect.gen(function* () {
+      const catalog = yield* Catalog.Service
+      yield* catalog.transform((catalog) => {
+        catalog.provider.update(ProviderV2.ID.make("zenmux"), (provider) => {
+          provider.api = {
+            type: "aisdk",
+            package: "@ai-sdk/openai-compatible",
+            url: "https://zenmux.ai/api/v1",
+          }
+        })
+      })
+      yield* addPlugin()
+      const result = required(yield* catalog.provider.get(ProviderV2.ID.make("zenmux")))
+      expect(result.request.headers).toEqual({ "HTTP-Referer": "https://neurocode.ai/", "X-Title": "neurocode" })
+      expect(Object.keys(result.request.headers).sort()).toEqual(["HTTP-Referer", "X-Title"])
+    }),
+  )
+
+  it.effect("merges legacy Zenmux headers with existing headers", () =>
+    Effect.gen(function* () {
+      const catalog = yield* Catalog.Service
+      yield* catalog.transform((catalog) => {
+        catalog.provider.update(ProviderV2.ID.make("zenmux"), (provider) => {
+          provider.api = {
+            type: "aisdk",
+            package: "@ai-sdk/openai-compatible",
+            url: "https://zenmux.ai/api/v1",
+          }
+          provider.request.headers.Existing = "value"
+        })
+      })
+      yield* addPlugin()
+
+      expect(required(yield* catalog.provider.get(ProviderV2.ID.make("zenmux"))).request.headers).toEqual({
+        Existing: "value",
+        "HTTP-Referer": "https://neurocode.ai/",
+        "X-Title": "neurocode",
+      })
+    }),
+  )
+
+  it.effect("lets configured Zenmux legacy headers override defaults", () =>
+    Effect.gen(function* () {
+      const catalog = yield* Catalog.Service
+      yield* catalog.transform((catalog) => {
+        catalog.provider.update(ProviderV2.ID.make("zenmux"), (provider) => {
+          provider.api = {
+            type: "aisdk",
+            package: "@ai-sdk/openai-compatible",
+            url: "https://zenmux.ai/api/v1",
+          }
+          provider.request.headers = { "HTTP-Referer": "https://example.com/", "X-Title": "custom-title" }
+        })
+      })
+      yield* addPlugin()
+
+      expect(required(yield* catalog.provider.get(ProviderV2.ID.make("zenmux"))).request.headers).toEqual({
+        "HTTP-Referer": "https://example.com/",
+        "X-Title": "custom-title",
+      })
+    }),
+  )
+
+  it.effect("guards legacy Zenmux headers to the exact zenmux provider id", () =>
+    Effect.gen(function* () {
+      const catalog = yield* Catalog.Service
+      yield* catalog.transform((catalog) => {
+        catalog.provider.update(ProviderV2.ID.openrouter, (provider) => {
+          provider.request.headers = { "HTTP-Referer": "https://example.com/", "X-Title": "custom-title" }
+        })
+      })
+      yield* addPlugin()
+
+      expect(required(yield* catalog.provider.get(ProviderV2.ID.openrouter)).request.headers).toEqual({
+        "HTTP-Referer": "https://example.com/",
+        "X-Title": "custom-title",
+      })
+    }),
+  )
+})

package/test/plugin/skill.test.ts

@@ -0,0 +1,25 @@
+import { describe, expect } from "bun:test"
+import { Effect } from "effect"
+import { AppNodeBuilder } from "@neurocode-ai/core/effect/app-node-builder"
+import { SkillPlugin } from "@neurocode-ai/core/plugin/skill"
+import { SkillV2 } from "@neurocode-ai/core/skill"
+import { testEffect } from "../lib/effect"
+import { host } from "./host"
+
+const it = testEffect(AppNodeBuilder.build(SkillV2.node))
+
+describe("SkillPlugin.Plugin", () => {
+  it.effect("registers the built-in customize-neurocode skill", () =>
+    Effect.gen(function* () {
+      const skill = yield* SkillV2.Service
+      yield* SkillPlugin.Plugin.effect(host({ skill: { ...skill, reload: skill.reload } }))
+
+      expect(yield* skill.list()).toContainEqual(
+        expect.objectContaining({
+          name: "customize-neurocode",
+          description: expect.stringContaining("neurocode's own configuration"),
+        }),
+      )
+    }),
+  )
+})

package/test/plugin/variant.test.ts

@@ -0,0 +1,67 @@
+import { describe, expect } from "bun:test"
+import { Catalog } from "@neurocode-ai/core/catalog"
+import { AppNodeBuilder } from "@neurocode-ai/core/effect/app-node-builder"
+import { LayerNode } from "@neurocode-ai/core/effect/layer-node"
+import { Location } from "@neurocode-ai/core/location"
+import { ModelV2 } from "@neurocode-ai/core/model"
+import { VariantPlugin } from "@neurocode-ai/core/plugin/variant"
+import { ProviderV2 } from "@neurocode-ai/core/provider"
+import { AbsolutePath } from "@neurocode-ai/core/schema"
+import { Effect, Layer } from "effect"
+import { location } from "../fixture/location"
+import { testEffect } from "../lib/effect"
+import { catalogHost, host } from "./host"
+
+const locationLayer = Layer.succeed(
+  Location.Service,
+  Location.Service.of(location({ directory: AbsolutePath.make(import.meta.dir) })),
+)
+const it = testEffect(AppNodeBuilder.build(Catalog.node, [[Location.node, locationLayer]]))
+
+describe("VariantPlugin", () => {
+  it.effect("adds GLM 5.2 variants after catalog sources", () =>
+    Effect.gen(function* () {
+      const service = yield* Catalog.Service
+      yield* service.transform((catalog) => {
+        catalog.provider.update(ProviderV2.ID.opencode, (provider) => {
+          provider.api = { type: "aisdk", package: "@ai-sdk/openai-compatible" }
+        })
+        catalog.model.update(ProviderV2.ID.opencode, ModelV2.ID.make("glm-5.2"), (model) => {
+          model.api = {
+            id: ModelV2.ID.make("glm-5.2"),
+            type: "aisdk",
+            package: "@ai-sdk/openai-compatible",
+          }
+        })
+      })
+      yield* VariantPlugin.Plugin.effect(host({ catalog: catalogHost(service) }))
+
+      expect((yield* service.model.get(ProviderV2.ID.opencode, ModelV2.ID.make("glm-5.2")))?.variants).toEqual([
+        expect.objectContaining({ id: "high", body: { reasoning_effort: "high" } }),
+        expect.objectContaining({ id: "max", body: { reasoning_effort: "max" } }),
+      ])
+    }),
+  )
+
+  it.effect("keeps explicit variants over generated defaults", () =>
+    Effect.gen(function* () {
+      const service = yield* Catalog.Service
+      yield* service.transform((catalog) => {
+        catalog.model.update(ProviderV2.ID.opencode, ModelV2.ID.make("glm-5.2"), (model) => {
+          model.api = {
+            id: ModelV2.ID.make("glm-5.2"),
+            type: "aisdk",
+            package: "@ai-sdk/openai-compatible",
+          }
+          model.variants = [{ id: ModelV2.VariantID.make("high"), headers: { custom: "true" }, body: {} }]
+        })
+      })
+      yield* VariantPlugin.Plugin.effect(host({ catalog: catalogHost(service) }))
+
+      expect((yield* service.model.get(ProviderV2.ID.opencode, ModelV2.ID.make("glm-5.2")))?.variants).toEqual([
+        expect.objectContaining({ id: "high", headers: { custom: "true" } }),
+        expect.objectContaining({ id: "max", body: { reasoning_effort: "max" } }),
+      ])
+    }),
+  )
+})

package/test/plugin.test.ts

@@ -0,0 +1,71 @@
+import { describe, expect } from "bun:test"
+import { Effect, Exit, Fiber } from "effect"
+import { define } from "@neurocode-ai/plugin/v2/effect"
+import { AgentV2 } from "@neurocode-ai/core/agent"
+import { PluginV2 } from "@neurocode-ai/core/plugin"
+import { testEffect } from "./lib/effect"
+import { PluginTestLayer } from "./plugin/fixture"
+
+const it = testEffect(PluginTestLayer)
+
+describe("PluginV2", () => {
+  it.effect("waits for a plugin and returns immediately once active", () =>
+    Effect.gen(function* () {
+      const plugins = yield* PluginV2.Service
+      const id = PluginV2.ID.make("waited")
+      const waiting = yield* plugins.wait(id).pipe(Effect.forkChild)
+
+      yield* plugins.add(id, () => Effect.void)
+      yield* Fiber.join(waiting)
+      yield* plugins.wait(id)
+    }),
+  )
+
+  it.effect("propagates plugin activation defects to waiters", () =>
+    Effect.gen(function* () {
+      const plugins = yield* PluginV2.Service
+      const id = PluginV2.ID.make("failed")
+      const waiting = yield* plugins.wait(id).pipe(Effect.exit, Effect.forkChild)
+
+      const added = yield* plugins.add(id, () => Effect.die("boom")).pipe(Effect.exit)
+      const pending = yield* Fiber.join(waiting)
+      const later = yield* plugins.wait(id).pipe(Effect.exit)
+
+      expect(Exit.isFailure(added)).toBe(true)
+      expect(Exit.isFailure(pending)).toBe(true)
+      expect(Exit.isFailure(later)).toBe(true)
+    }),
+  )
+
+  it.effect("adds, replaces, and removes plugins", () =>
+    Effect.gen(function* () {
+      const plugins = yield* PluginV2.Service
+      const agents = yield* AgentV2.Service
+      let description = "first"
+
+      const managed = () =>
+        define({
+          id: "managed",
+          effect: (ctx) =>
+            ctx.agent
+              .transform((agents) =>
+                agents.update("configured", (agent) => {
+                  agent.description = description
+                }),
+              )
+              .pipe(Effect.asVoid),
+        })
+
+      yield* plugins.add(PluginV2.ID.make("managed"), managed().effect)
+
+      expect((yield* agents.get(AgentV2.ID.make("configured")))?.description).toBe("first")
+
+      description = "second"
+      yield* plugins.add(PluginV2.ID.make("managed"), managed().effect)
+      expect((yield* agents.get(AgentV2.ID.make("configured")))?.description).toBe("second")
+
+      yield* plugins.remove(PluginV2.ID.make("managed"))
+      expect(yield* agents.get(AgentV2.ID.make("configured"))).toBeUndefined()
+    }),
+  )
+})

package/test/policy.test.ts

@@ -0,0 +1,85 @@
+import { describe, expect } from "bun:test"
+import { Effect, Layer } from "effect"
+import { AppNodeBuilder } from "@neurocode-ai/core/effect/app-node-builder"
+import { Location } from "@neurocode-ai/core/location"
+import { Policy } from "@neurocode-ai/core/policy"
+import { AbsolutePath } from "@neurocode-ai/core/schema"
+import { location } from "./fixture/location"
+import { testEffect } from "./lib/effect"
+
+const it = testEffect(
+  AppNodeBuilder.build(Policy.node, [
+    [
+      Location.node,
+      Layer.succeed(Location.Service, Location.Service.of(location({ directory: AbsolutePath.make("test") }))),
+    ],
+  ]),
+)
+
+describe("Policy", () => {
+  it.effect("returns the caller's fallback when no statement matches", () =>
+    Effect.gen(function* () {
+      const policy = yield* Policy.Service
+
+      expect(yield* policy.evaluate("provider.use", "anthropic", "allow")).toBe("allow")
+      expect(yield* policy.evaluate("provider.use", "anthropic", "deny")).toBe("deny")
+    }),
+  )
+
+  it.effect("evaluates wildcard provider rules in written order", () =>
+    Effect.gen(function* () {
+      const policy = yield* Policy.Service
+      yield* policy.load([
+        new Policy.Info({
+          effect: "deny",
+          action: "provider.*",
+          resource: "*",
+        }),
+        new Policy.Info({
+          effect: "allow",
+          action: "provider.use",
+          resource: "anthropic",
+        }),
+      ])
+
+      expect(yield* policy.evaluate("provider.use", "anthropic", "allow")).toBe("allow")
+      expect(yield* policy.evaluate("provider.use", "openai", "allow")).toBe("deny")
+    }),
+  )
+
+  it.effect("matches action and resource independently", () =>
+    Effect.gen(function* () {
+      const policy = yield* Policy.Service
+      yield* policy.load([
+        new Policy.Info({
+          effect: "deny",
+          action: "provider.*",
+          resource: "company-*",
+        }),
+      ])
+
+      expect(yield* policy.evaluate("provider.use", "company-stable", "allow")).toBe("deny")
+      expect(yield* policy.evaluate("plugin.load", "company-stable", "allow")).toBe("allow")
+    }),
+  )
+
+  it.effect("uses the last matching loaded statement", () =>
+    Effect.gen(function* () {
+      const policy = yield* Policy.Service
+      yield* policy.load([
+        new Policy.Info({
+          effect: "allow",
+          action: "provider.use",
+          resource: "openai",
+        }),
+        new Policy.Info({
+          effect: "deny",
+          action: "provider.use",
+          resource: "openai",
+        }),
+      ])
+
+      expect(yield* policy.evaluate("provider.use", "openai", "allow")).toBe("deny")
+    }),
+  )
+})

package/test/preload.ts

@@ -0,0 +1,5 @@
+import path from "path"
+
+process.env.NEUROCODE_DB = ":memory:"
+process.env.NEUROCODE_MODELS_PATH = path.join(import.meta.dir, "plugin", "fixtures", "models-dev.json")
+process.env.NEUROCODE_DISABLE_MODELS_FETCH = "true"