@neurocode-ai/core 1.18.8

package/test/config/fixtures/plugin/directory-plugin.ts

@@ -0,0 +1,13 @@
+import { define } from "@neurocode-ai/plugin/v2/promise"
+
+export default define({
+  id: "directory-plugin",
+  setup: async (ctx) => {
+    await ctx.agent.transform((agents) => {
+      agents.update("directory", (agent) => {
+        agent.description = "Loaded from plugin directory"
+        agent.mode = "subagent"
+      })
+    })
+  },
+})

package/test/config/plugin.test.ts

@@ -0,0 +1,248 @@
+import path from "path"
+import { describe, expect } from "bun:test"
+import { Effect, Schema } from "effect"
+import { AgentV2 } from "@neurocode-ai/core/agent"
+import { Config } from "@neurocode-ai/core/config"
+import { ConfigExternalPlugin } from "@neurocode-ai/core/config/plugin/external"
+import { FSUtil } from "@neurocode-ai/core/fs-util"
+import { Location } from "@neurocode-ai/core/location"
+import { Npm } from "@neurocode-ai/core/npm"
+import { PluginV2 } from "@neurocode-ai/core/plugin"
+import { PluginHost } from "@neurocode-ai/core/plugin/host"
+import { AbsolutePath } from "@neurocode-ai/core/schema"
+import { testEffect } from "../lib/effect"
+import { PluginTestLayer } from "../plugin/fixture"
+
+const it = testEffect(PluginTestLayer)
+const decode = Schema.decodeUnknownSync(Config.Info)
+
+describe("ConfigExternalPlugin", () => {
+  it.live("resolves and loads a configured Promise plugin with options", () =>
+    Effect.gen(function* () {
+      const plugins = yield* PluginV2.Service
+      const agents = yield* AgentV2.Service
+      const fs = yield* FSUtil.Service
+      const location = yield* Location.Service
+      const npm = yield* Npm.Service
+      const host = yield* PluginHost.make(plugins)
+      const document = path.join(import.meta.dir, "neurocode.json")
+
+      yield* ConfigExternalPlugin.Plugin.effect(host).pipe(
+        Effect.provideService(PluginV2.Service, plugins),
+        Effect.provideService(FSUtil.Service, fs),
+        Effect.provideService(Location.Service, location),
+        Effect.provideService(Npm.Service, npm),
+        Effect.provideService(
+          Config.Service,
+          Config.Service.of({
+            entries: () =>
+              Effect.succeed([
+                new Config.Document({
+                  type: "document",
+                  path: document,
+                  info: decode({
+                    plugins: [
+                      {
+                        package: "../plugin/fixtures/config-promise-plugin.ts",
+                        options: { description: "Loaded from config" },
+                      },
+                    ],
+                  }),
+                }),
+              ]),
+          }),
+        ),
+      )
+
+      expect(yield* waitForAgent(agents, "configured")).toMatchObject({
+        description: "Loaded from config",
+        mode: "subagent",
+      })
+    }),
+  )
+
+  it.live("loads a configured Effect plugin with options", () =>
+    Effect.gen(function* () {
+      const plugins = yield* PluginV2.Service
+      const agents = yield* AgentV2.Service
+      const fs = yield* FSUtil.Service
+      const location = yield* Location.Service
+      const npm = yield* Npm.Service
+      const host = yield* PluginHost.make(plugins)
+
+      yield* ConfigExternalPlugin.Plugin.effect(host).pipe(
+        Effect.provideService(PluginV2.Service, plugins),
+        Effect.provideService(FSUtil.Service, fs),
+        Effect.provideService(Location.Service, location),
+        Effect.provideService(Npm.Service, npm),
+        Effect.provideService(
+          Config.Service,
+          Config.Service.of({
+            entries: () =>
+              Effect.succeed([
+                new Config.Document({
+                  type: "document",
+                  path: path.join(import.meta.dir, "neurocode.json"),
+                  info: decode({
+                    plugins: [
+                      {
+                        package: "../plugin/fixtures/config-effect-plugin.ts",
+                        options: { description: "Effect plugin from config" },
+                      },
+                    ],
+                  }),
+                }),
+              ]),
+          }),
+        ),
+      )
+
+      expect(yield* waitForAgent(agents, "effect-configured")).toMatchObject({
+        description: "Effect plugin from config",
+        mode: "subagent",
+      })
+    }),
+  )
+
+  it.live("ignores invalid plugins and continues loading", () =>
+    Effect.gen(function* () {
+      const plugins = yield* PluginV2.Service
+      const agents = yield* AgentV2.Service
+      const fs = yield* FSUtil.Service
+      const location = yield* Location.Service
+      const npm = yield* Npm.Service
+      const host = yield* PluginHost.make(plugins)
+
+      yield* ConfigExternalPlugin.Plugin.effect(host).pipe(
+        Effect.provideService(PluginV2.Service, plugins),
+        Effect.provideService(FSUtil.Service, fs),
+        Effect.provideService(Location.Service, location),
+        Effect.provideService(Npm.Service, npm),
+        Effect.provideService(
+          Config.Service,
+          Config.Service.of({
+            entries: () =>
+              Effect.succeed([
+                new Config.Document({
+                  type: "document",
+                  path: path.join(import.meta.dir, "neurocode.json"),
+                  info: decode({
+                    plugins: [
+                      "../plugin/fixtures/missing-plugin.ts",
+                      "../plugin/fixtures/invalid-plugin.ts",
+                      {
+                        package: "../plugin/fixtures/config-promise-plugin.ts",
+                        options: { description: "Loaded after invalid plugins" },
+                      },
+                    ],
+                  }),
+                }),
+              ]),
+          }),
+        ),
+      )
+
+      expect(yield* waitForAgent(agents, "configured")).toMatchObject({
+        description: "Loaded after invalid plugins",
+      })
+    }),
+  )
+
+  it.live("installs and resolves npm plugin packages", () =>
+    Effect.gen(function* () {
+      const plugins = yield* PluginV2.Service
+      const agents = yield* AgentV2.Service
+      const fs = yield* FSUtil.Service
+      const location = yield* Location.Service
+      const host = yield* PluginHost.make(plugins)
+      let installed: string | undefined
+      const npm = Npm.Service.of({
+        add: (spec) =>
+          Effect.sync(() => {
+            installed = spec
+            return {
+              directory: import.meta.dir,
+              entrypoint: path.join(import.meta.dir, "../plugin/fixtures/config-promise-plugin.ts"),
+            }
+          }),
+        install: () => Effect.void,
+        which: () => Effect.succeed(undefined),
+      })
+
+      yield* ConfigExternalPlugin.Plugin.effect(host).pipe(
+        Effect.provideService(PluginV2.Service, plugins),
+        Effect.provideService(FSUtil.Service, fs),
+        Effect.provideService(Location.Service, location),
+        Effect.provideService(Npm.Service, npm),
+        Effect.provideService(
+          Config.Service,
+          Config.Service.of({
+            entries: () =>
+              Effect.succeed([
+                new Config.Document({
+                  type: "document",
+                  info: decode({
+                    plugins: [
+                      {
+                        package: "example-plugin@1.0.0",
+                        options: { description: "Installed from npm" },
+                      },
+                    ],
+                  }),
+                }),
+              ]),
+          }),
+        ),
+      )
+
+      expect(yield* waitForAgent(agents, "configured")).toMatchObject({
+        description: "Installed from npm",
+      })
+      expect(installed).toBe("example-plugin@1.0.0")
+    }),
+  )
+
+  it.live("loads plugin files from config directories", () =>
+    Effect.gen(function* () {
+      const plugins = yield* PluginV2.Service
+      const agents = yield* AgentV2.Service
+      const fs = yield* FSUtil.Service
+      const location = yield* Location.Service
+      const npm = yield* Npm.Service
+      const host = yield* PluginHost.make(plugins)
+
+      yield* ConfigExternalPlugin.Plugin.effect(host).pipe(
+        Effect.provideService(PluginV2.Service, plugins),
+        Effect.provideService(FSUtil.Service, fs),
+        Effect.provideService(Location.Service, location),
+        Effect.provideService(Npm.Service, npm),
+        Effect.provideService(
+          Config.Service,
+          Config.Service.of({
+            entries: () =>
+              Effect.succeed([
+                new Config.Directory({
+                  type: "directory",
+                  path: AbsolutePath.make(path.join(import.meta.dir, "fixtures")),
+                }),
+              ]),
+          }),
+        ),
+      )
+
+      expect(yield* waitForAgent(agents, "directory")).toMatchObject({
+        description: "Loaded from plugin directory",
+        mode: "subagent",
+      })
+    }),
+  )
+})
+
+const waitForAgent = Effect.fnUntraced(function* (agents: AgentV2.Interface, id: string) {
+  for (let attempt = 0; attempt < 100; attempt++) {
+    const agent = yield* agents.get(AgentV2.ID.make(id))
+    if (agent) return agent
+    yield* Effect.sleep("10 millis")
+  }
+  return yield* Effect.die(`Timed out waiting for agent ${id}`)
+})

package/test/config/provider-options.test.ts

@@ -0,0 +1,224 @@
+import { describe, expect, test } from "bun:test"
+import { ConfigProviderOptionsV1 } from "@neurocode-ai/core/v1/config/provider-options"
+
+describe("ConfigProviderOptionsV1", () => {
+  test("keeps raw provider and request options unchanged", () => {
+    const lowerer = ConfigProviderOptionsV1.get("custom-provider")
+
+    expect(lowerer.provider({ apiKey: "secret", headers: { "x-test": "1" }, nested: { camelCase: true } })).toEqual({
+      body: { apiKey: "secret", headers: { "x-test": "1" }, nested: { camelCase: true } },
+    })
+    expect(lowerer.request({ nested: { camelCase: true } })).toEqual({ nested: { camelCase: true } })
+  })
+
+  test("falls back to raw lowering for prototype property package names", () => {
+    expect(ConfigProviderOptionsV1.get("toString").provider({ enabled: true })).toEqual({ body: { enabled: true } })
+  })
+
+  test("lowers OpenAI provider and request options", () => {
+    const lowerer = ConfigProviderOptionsV1.get("@ai-sdk/openai")
+
+    expect(
+      lowerer.provider({
+        apiKey: "secret",
+        baseURL: "https://openai.example/v1",
+        organization: "org",
+        project: "project",
+        headers: { "x-test": "1" },
+        body: { store: true },
+        timeout: 1000,
+      }),
+    ).toEqual({
+      url: "https://openai.example/v1",
+      headers: {
+        Authorization: "Bearer secret",
+        "OpenAI-Organization": "org",
+        "OpenAI-Project": "project",
+        "x-test": "1",
+      },
+      body: { store: true },
+      settings: { timeout: 1000 },
+    })
+    expect(
+      lowerer.request({
+        reasoningEffort: "high",
+        reasoningSummary: "auto",
+        reasoning: { encryptedContent: true },
+        textVerbosity: "low",
+        text: { outputFormat: "plain" },
+        nestedValue: { camelCase: true },
+      }),
+    ).toEqual({
+      reasoning: { encrypted_content: true, effort: "high", summary: "auto" },
+      text: { output_format: "plain", verbosity: "low" },
+      nested_value: { camel_case: true },
+    })
+  })
+
+  test("lowers Anthropic provider and request options", () => {
+    const lowerer = ConfigProviderOptionsV1.get("@ai-sdk/anthropic")
+
+    expect(
+      lowerer.provider({
+        apiKey: "secret",
+        authToken: "token",
+        baseURL: "https://anthropic.example",
+        headers: { "x-test": "1" },
+        body: { beta: true },
+        generateId: "custom",
+      }),
+    ).toEqual({
+      url: "https://anthropic.example",
+      headers: { "x-api-key": "secret", Authorization: "Bearer token", "x-test": "1" },
+      body: { beta: true },
+      settings: { generateId: "custom" },
+    })
+    expect(
+      lowerer.request({
+        effort: "high",
+        taskBudget: 1024,
+        metadata: { userId: "user", traceId: "trace" },
+        nestedValue: { camelCase: true },
+      }),
+    ).toEqual({
+      output_config: { effort: "high", task_budget: 1024 },
+      metadata: { user_id: "user", trace_id: "trace" },
+      nested_value: { camel_case: true },
+    })
+  })
+
+  test("lowers Google provider and request options", () => {
+    const lowerer = ConfigProviderOptionsV1.get("@ai-sdk/google")
+
+    expect(
+      lowerer.provider({
+        apiKey: "secret",
+        baseURL: "https://google.example",
+        headers: { "x-test": "1" },
+        body: { trace: true },
+        project: "project",
+      }),
+    ).toEqual({
+      url: "https://google.example",
+      headers: { "x-goog-api-key": "secret", "x-test": "1" },
+      body: { trace: true },
+      settings: { project: "project" },
+    })
+    expect(
+      lowerer.request({
+        thinkingConfig: { thinkingBudget: 1024 },
+        responseModalities: ["TEXT"],
+        mediaResolution: "high",
+        imageConfig: { aspectRatio: "16:9" },
+        safetySettings: ["safe"],
+      }),
+    ).toEqual({
+      safetySettings: ["safe"],
+      generationConfig: {
+        thinkingConfig: { thinkingBudget: 1024 },
+        responseModalities: ["TEXT"],
+        mediaResolution: "high",
+        imageConfig: { aspectRatio: "16:9" },
+      },
+    })
+  })
+
+  test("lowers Azure provider options and uses OpenAI request lowering", () => {
+    const lowerer = ConfigProviderOptionsV1.get("@ai-sdk/azure")
+
+    expect(
+      lowerer.provider({
+        apiKey: "secret",
+        baseURL: "https://azure.example",
+        headers: { "x-test": "1" },
+        body: { trace: true },
+        resourceName: "resource",
+      }),
+    ).toEqual({
+      url: "https://azure.example",
+      headers: { "api-key": "secret", "x-test": "1" },
+      body: { trace: true },
+      settings: { resourceName: "resource" },
+    })
+    expect(lowerer.request({ reasoningEffort: "high", reasoningSummary: "auto", textVerbosity: "low" })).toEqual({
+      reasoning: { effort: "high", summary: "auto" },
+      text: { verbosity: "low" },
+    })
+  })
+
+  test("lowers Amazon Bedrock provider and request options", () => {
+    const lowerer = ConfigProviderOptionsV1.get("@ai-sdk/amazon-bedrock")
+
+    expect(
+      lowerer.provider({
+        headers: { "x-test": "1" },
+        body: { trace: true },
+        region: "us-east-1",
+        profile: "dev",
+      }),
+    ).toEqual({
+      headers: { "x-test": "1" },
+      body: { trace: true },
+      settings: { region: "us-east-1", profile: "dev" },
+    })
+    expect(lowerer.request({ temperature: 0.2 })).toEqual({
+      additionalModelRequestFields: { temperature: 0.2 },
+    })
+  })
+
+  test("lowers OpenAI-compatible provider and request options", () => {
+    const lowerer = ConfigProviderOptionsV1.get("@ai-sdk/openai-compatible")
+
+    expect(
+      lowerer.provider({
+        baseURL: "https://compatible.example/v1",
+        headers: { "x-test": "1" },
+        body: { trace: true },
+        apiKey: "secret",
+      }),
+    ).toEqual({
+      url: "https://compatible.example/v1",
+      headers: { "x-test": "1" },
+      body: { trace: true },
+      settings: { apiKey: "secret" },
+    })
+    expect(lowerer.request({ reasoningEffort: "high", serviceTier: "priority" })).toEqual({
+      reasoning_effort: "high",
+      serviceTier: "priority",
+    })
+  })
+
+  test.each([
+    "@ai-sdk/cerebras",
+    "@ai-sdk/deepinfra",
+    "@ai-sdk/groq",
+    "@ai-sdk/mistral",
+    "@ai-sdk/togetherai",
+    "@ai-sdk/xai",
+    "@openrouter/ai-sdk-provider",
+    "ai-gateway-provider",
+    "venice-ai-sdk-provider",
+  ])("uses OpenAI-compatible lowering for %s", (packageName) => {
+    const lowerer = ConfigProviderOptionsV1.get(packageName)
+
+    expect(lowerer.provider({ baseURL: "https://example.test", apiKey: "secret" })).toEqual({
+      url: "https://example.test",
+      headers: undefined,
+      body: undefined,
+      settings: { apiKey: "secret" },
+    })
+    expect(lowerer.request({ reasoningEffort: "high" })).toEqual({ reasoning_effort: "high" })
+  })
+
+  test.each(["@ai-sdk/google-vertex", "@ai-sdk/google-vertex/anthropic"])(
+    "uses provider family lowering for %s",
+    (packageName) => {
+      const lowerer = ConfigProviderOptionsV1.get(packageName)
+
+      expect(lowerer.provider({ baseURL: "https://example.test", profile: "dev" })).toMatchObject({
+        url: "https://example.test",
+        settings: { profile: "dev" },
+      })
+    },
+  )
+})