@neurocode-ai/core 1.18.8

package/test/github-copilot/openai-responses-language-model.test.ts

@@ -0,0 +1,206 @@
+import { OpenAIResponsesLanguageModel } from "@neurocode-ai/core/github-copilot/responses/openai-responses-language-model"
+import { convertToOpenAIResponsesInput } from "@neurocode-ai/core/github-copilot/responses/convert-to-openai-responses-input"
+import { describe, test, expect, mock } from "bun:test"
+import type { LanguageModelV3Prompt } from "@ai-sdk/provider"
+
+const TEST_PROMPT: LanguageModelV3Prompt = [{ role: "user", content: [{ type: "text", text: "Hello" }] }]
+
+function createMockFetch(body: unknown) {
+  return mock(
+    async () => new Response(JSON.stringify(body), { status: 200, headers: { "Content-Type": "application/json" } }),
+  )
+}
+
+function createModel(fetchFn: ReturnType<typeof mock>) {
+  return new OpenAIResponsesLanguageModel("test-model", {
+    provider: "copilot",
+    url: () => "https://api.test.com/responses",
+    headers: () => ({ Authorization: "Bearer test-token" }),
+    fetch: fetchFn as any,
+  })
+}
+
+// GitHub Copilot's Responses model echoes item metadata (itemId, reasoningEncryptedContent,
+// responseId, ...) under the "copilot" providerOptions/providerMetadata namespace, matching the
+// namespace request options already use. It used to echo this metadata under "openai" (a leftover
+// from forking the OpenAI Responses model), which left it unreachable by anything reading the
+// "copilot" namespace and let stale itemIds slip past stripping meant for that namespace.
+describe("doGenerate", () => {
+  test("attaches item metadata under the copilot namespace, not openai", async () => {
+    const mockFetch = createMockFetch({
+      id: "resp_1",
+      created_at: 0,
+      model: "gpt-5.5",
+      output: [
+        {
+          type: "reasoning",
+          id: "rs_1",
+          encrypted_content: "enc_1",
+          summary: [{ type: "summary_text", text: "thinking..." }],
+        },
+        {
+          type: "message",
+          role: "assistant",
+          id: "msg_1",
+          content: [{ type: "output_text", text: "Hello there", annotations: [] }],
+        },
+        {
+          type: "function_call",
+          call_id: "call_1",
+          name: "bash",
+          arguments: "{}",
+          id: "fc_1",
+        },
+      ],
+      usage: { input_tokens: 10, output_tokens: 5 },
+    })
+    const model = createModel(mockFetch)
+
+    const { content, providerMetadata } = await model.doGenerate({
+      prompt: TEST_PROMPT,
+      includeRawChunks: false,
+    } as any)
+
+    const reasoning = content.find((part: any) => part.type === "reasoning") as any
+    expect(reasoning.providerMetadata?.copilot?.itemId).toBe("rs_1")
+    expect(reasoning.providerMetadata?.copilot?.reasoningEncryptedContent).toBe("enc_1")
+    expect(reasoning.providerMetadata?.openai).toBeUndefined()
+
+    const text = content.find((part: any) => part.type === "text") as any
+    expect(text.providerMetadata?.copilot?.itemId).toBe("msg_1")
+    expect(text.providerMetadata?.openai).toBeUndefined()
+
+    const toolCall = content.find((part: any) => part.type === "tool-call") as any
+    expect(toolCall.providerMetadata?.copilot?.itemId).toBe("fc_1")
+    expect(toolCall.providerMetadata?.openai).toBeUndefined()
+
+    expect(providerMetadata?.copilot?.responseId).toBe("resp_1")
+    expect(providerMetadata?.openai).toBeUndefined()
+  })
+})
+
+describe("convertToOpenAIResponsesInput", () => {
+  test("echoes a stale tool-call itemId from the copilot namespace as the function_call id", async () => {
+    const { input } = await convertToOpenAIResponsesInput({
+      prompt: [
+        {
+          role: "assistant",
+          content: [
+            {
+              type: "tool-call",
+              toolCallId: "call_1",
+              toolName: "bash",
+              input: { command: "ls" },
+              providerOptions: { copilot: { itemId: "fc_999" } },
+            },
+          ],
+        },
+      ],
+      systemMessageMode: "system",
+      store: false,
+    })
+
+    expect(input).toEqual([
+      {
+        type: "function_call",
+        call_id: "call_1",
+        name: "bash",
+        arguments: JSON.stringify({ command: "ls" }),
+        id: "fc_999",
+      },
+    ])
+  })
+
+  test("omits the function_call id once the stale copilot itemId has been stripped", async () => {
+    const { input } = await convertToOpenAIResponsesInput({
+      prompt: [
+        {
+          role: "assistant",
+          content: [
+            {
+              type: "tool-call",
+              toolCallId: "call_1",
+              toolName: "bash",
+              input: { command: "ls" },
+              providerOptions: {},
+            },
+          ],
+        },
+      ],
+      systemMessageMode: "system",
+      store: false,
+    })
+
+    expect((input[0] as any).id).toBeUndefined()
+  })
+
+  test("preserves reasoning items keyed by the copilot namespace instead of dropping them", async () => {
+    const { input, warnings } = await convertToOpenAIResponsesInput({
+      prompt: [
+        {
+          role: "assistant",
+          content: [
+            {
+              type: "reasoning",
+              text: "thinking...",
+              providerOptions: { copilot: { itemId: "rs_1", reasoningEncryptedContent: "enc_1" } },
+            },
+          ],
+        },
+      ],
+      systemMessageMode: "system",
+      store: false,
+    })
+
+    expect(warnings).toEqual([])
+    expect(input).toEqual([
+      {
+        type: "reasoning",
+        id: "rs_1",
+        encrypted_content: "enc_1",
+        summary: [{ type: "summary_text", text: "thinking..." }],
+      },
+    ])
+  })
+
+  test("drops reasoning items with no copilot itemId and warns, as before", async () => {
+    const { input, warnings } = await convertToOpenAIResponsesInput({
+      prompt: [
+        {
+          role: "assistant",
+          content: [{ type: "reasoning", text: "thinking...", providerOptions: {} }],
+        },
+      ],
+      systemMessageMode: "system",
+      store: false,
+    })
+
+    expect(input).toEqual([])
+    expect(warnings).toHaveLength(1)
+    expect(warnings[0]).toMatchObject({
+      message: expect.stringContaining("Non-OpenAI reasoning parts are not supported"),
+    })
+  })
+
+  test("reads imageDetail from the copilot namespace on user file parts", async () => {
+    const { input } = await convertToOpenAIResponsesInput({
+      prompt: [
+        {
+          role: "user",
+          content: [
+            {
+              type: "file",
+              mediaType: "image/png",
+              data: "aGVsbG8=",
+              providerOptions: { copilot: { imageDetail: "high" } },
+            },
+          ],
+        },
+      ],
+      systemMessageMode: "system",
+      store: false,
+    })
+
+    expect((input[0] as any).content[0].detail).toBe("high")
+  })
+})

package/test/global.test.ts

@@ -0,0 +1,16 @@
+import { describe, expect, test } from "bun:test"
+import fs from "fs/promises"
+import os from "os"
+import path from "path"
+import { Global } from "@neurocode-ai/core/global"
+
+describe("global paths", () => {
+  test("tmp path is under the system temp directory", () => {
+    expect(Global.Path.tmp).toBe(path.join(os.tmpdir(), "neurocode"))
+    expect(Global.make().tmp).toBe(Global.Path.tmp)
+  })
+
+  test("tmp path is created on module load", async () => {
+    expect((await fs.stat(Global.Path.tmp)).isDirectory()).toBe(true)
+  })
+})

package/test/instruction-context.test.ts

@@ -0,0 +1,323 @@
+import { describe, expect } from "bun:test"
+import { Effect, Layer } from "effect"
+import fs from "fs/promises"
+import path from "path"
+import { AppNodeBuilder } from "@neurocode-ai/core/effect/app-node-builder"
+import { LayerNode } from "@neurocode-ai/core/effect/layer-node"
+import { FSUtil } from "@neurocode-ai/core/fs-util"
+import { Global } from "@neurocode-ai/core/global"
+import { InstructionContext } from "@neurocode-ai/core/instruction-context"
+import { Location } from "@neurocode-ai/core/location"
+import { AbsolutePath } from "@neurocode-ai/core/schema"
+import { SystemContext } from "@neurocode-ai/core/system-context"
+import { SystemContextRegistry } from "@neurocode-ai/core/system-context/registry"
+import { location } from "./fixture/location"
+import { tmpdir } from "./fixture/tmpdir"
+import { testEffect } from "./lib/effect"
+
+const it = testEffect(Layer.empty)
+
+const instructionLayer = (input: {
+  config: string
+  locationServiceLayer: Layer.Layer<Location.Service>
+  filesystemLayer?: Layer.Layer<FSUtil.Service>
+}) =>
+  AppNodeBuilder.build(LayerNode.group([SystemContextRegistry.node, InstructionContext.node]), [
+    [Global.node, Global.layerWith({ config: input.config })],
+    [Location.node, input.locationServiceLayer],
+    ...(input.filesystemLayer ? [[FSUtil.node, input.filesystemLayer] as const] : []),
+  ])
+
+describe("InstructionContext", () => {
+  it.live("loads global and upward project AGENTS.md files as one aggregate context", () =>
+    Effect.acquireRelease(
+      Effect.promise(() => tmpdir()),
+      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
+    ).pipe(
+      Effect.flatMap((tmp) =>
+        Effect.gen(function* () {
+          const global = path.join(tmp.path, "global")
+          const project = path.join(tmp.path, "project")
+          const directory = path.join(project, "packages", "core")
+          const outside = path.join(tmp.path, "AGENTS.md")
+          const globalFile = path.join(global, "AGENTS.md")
+          const projectFile = path.join(project, "AGENTS.md")
+          const packageFile = path.join(directory, "AGENTS.md")
+          yield* Effect.promise(async () => {
+            await fs.mkdir(global, { recursive: true })
+            await fs.mkdir(directory, { recursive: true })
+            await fs.writeFile(outside, "outside")
+            await fs.writeFile(globalFile, "global")
+            await fs.writeFile(projectFile, "project")
+            await fs.writeFile(packageFile, "package")
+          })
+
+          const load = SystemContextRegistry.Service.pipe(
+            Effect.flatMap((service) => service.load()),
+            Effect.provide(
+              instructionLayer({
+                config: global,
+                locationServiceLayer: Layer.succeed(
+                  Location.Service,
+                  Location.Service.of(
+                    location(
+                      { directory: AbsolutePath.make(directory) },
+                      { projectDirectory: AbsolutePath.make(project) },
+                    ),
+                  ),
+                ),
+              }),
+            ),
+          )
+
+          const initialized = yield* SystemContext.initialize(yield* load)
+          expect(initialized.baseline).toBe(
+            [
+              `Instructions from: ${globalFile}\nglobal`,
+              `Instructions from: ${packageFile}\npackage`,
+              `Instructions from: ${projectFile}\nproject`,
+            ].join("\n\n"),
+          )
+          expect(initialized.baseline).not.toContain("outside")
+
+          yield* Effect.promise(() => fs.writeFile(packageFile, "changed"))
+          expect(yield* SystemContext.reconcile(yield* load, initialized.snapshot)).toMatchObject({
+            _tag: "Updated",
+            text: expect.stringContaining(`Instructions from: ${packageFile}\nchanged`),
+          })
+
+          yield* Effect.promise(() => fs.rm(packageFile))
+          const partial = yield* SystemContext.reconcile(yield* load, initialized.snapshot)
+          expect(partial).toEqual({
+            _tag: "Updated",
+            text: [
+              "These instructions replace all previously loaded ambient instructions.",
+              `Instructions from: ${globalFile}\nglobal`,
+              `Instructions from: ${projectFile}\nproject`,
+            ].join("\n\n"),
+            snapshot: expect.any(Object),
+          })
+
+          yield* Effect.promise(() => Promise.all([fs.rm(globalFile), fs.rm(projectFile)]))
+          expect(yield* SystemContext.reconcile(yield* load, initialized.snapshot)).toEqual({
+            _tag: "Updated",
+            text: "Previously loaded instructions no longer apply.",
+            snapshot: {},
+          })
+        }),
+      ),
+    ),
+  )
+
+  it.live("keeps an empty AGENTS.md as available context", () =>
+    Effect.acquireRelease(
+      Effect.promise(() => tmpdir()),
+      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
+    ).pipe(
+      Effect.flatMap((tmp) =>
+        Effect.gen(function* () {
+          const file = path.join(tmp.path, "AGENTS.md")
+          yield* Effect.promise(() => fs.writeFile(file, ""))
+          const context = yield* SystemContextRegistry.Service.pipe(
+            Effect.flatMap((service) => service.load()),
+            Effect.provide(
+              instructionLayer({
+                config: path.join(tmp.path, "global"),
+                locationServiceLayer: Layer.succeed(
+                  Location.Service,
+                  Location.Service.of(location({ directory: AbsolutePath.make(tmp.path) })),
+                ),
+              }),
+            ),
+          )
+
+          expect((yield* SystemContext.initialize(context)).baseline).toBe(`Instructions from: ${file}\n`)
+        }),
+      ),
+    ),
+  )
+
+  it.effect("preserves admitted instructions while observation is unavailable", () =>
+    Effect.gen(function* () {
+      const failingFS = Layer.effect(
+        FSUtil.Service,
+        FSUtil.Service.pipe(
+          Effect.map((fs) =>
+            FSUtil.Service.of({ ...fs, up: () => Effect.fail(new FSUtil.FileSystemError({ method: "up" })) }),
+          ),
+        ),
+      ).pipe(Layer.provide(LayerNode.compile(FSUtil.node)))
+      const context = yield* SystemContextRegistry.Service.pipe(
+        Effect.flatMap((service) => service.load()),
+        Effect.provide(
+          instructionLayer({
+            config: "/global",
+            filesystemLayer: failingFS,
+            locationServiceLayer: Layer.succeed(
+              Location.Service,
+              Location.Service.of(location({ directory: AbsolutePath.make("/repo") })),
+            ),
+          }),
+        ),
+      )
+
+      expect(
+        yield* SystemContext.reconcile(context, {
+          "core/instructions": {
+            value: [{ path: "/repo/AGENTS.md", content: "old" }],
+            removed: "Previously loaded instructions no longer apply.",
+          },
+        }),
+      ).toEqual({ _tag: "Unchanged" })
+    }),
+  )
+
+  it.effect("preserves admitted instructions when a discovered file disappears before read", () =>
+    Effect.gen(function* () {
+      const file = AbsolutePath.make("/repo/AGENTS.md")
+      const racingFS = Layer.effect(
+        FSUtil.Service,
+        FSUtil.Service.pipe(
+          Effect.map((fs) =>
+            FSUtil.Service.of({
+              ...fs,
+              up: () => Effect.succeed([file]),
+              readFileStringSafe: () => Effect.succeed(undefined),
+            }),
+          ),
+        ),
+      ).pipe(Layer.provide(LayerNode.compile(FSUtil.node)))
+      const context = yield* SystemContextRegistry.Service.pipe(
+        Effect.flatMap((service) => service.load()),
+        Effect.provide(
+          instructionLayer({
+            config: "/global",
+            filesystemLayer: racingFS,
+            locationServiceLayer: Layer.succeed(
+              Location.Service,
+              Location.Service.of(location({ directory: AbsolutePath.make("/repo") })),
+            ),
+          }),
+        ),
+      )
+
+      expect(
+        yield* SystemContext.reconcile(context, {
+          "core/instructions": {
+            value: [{ path: file, content: "old" }],
+            removed: "Previously loaded instructions no longer apply.",
+          },
+        }),
+      ).toEqual({ _tag: "Unchanged" })
+    }),
+  )
+
+  it.effect("canonicalizes upward discovery boundaries", () =>
+    Effect.gen(function* () {
+      let observed: { targets: string[]; start: string; stop?: string } | undefined
+      const observingFS = Layer.effect(
+        FSUtil.Service,
+        FSUtil.Service.pipe(
+          Effect.map((fs) =>
+            FSUtil.Service.of({
+              ...fs,
+              up: (options) =>
+                Effect.sync(() => {
+                  observed = options
+                  return []
+                }),
+            }),
+          ),
+        ),
+      ).pipe(Layer.provide(LayerNode.compile(FSUtil.node)))
+
+      yield* SystemContextRegistry.Service.pipe(
+        Effect.flatMap((service) => service.load()),
+        Effect.provide(
+          instructionLayer({
+            config: "/global",
+            filesystemLayer: observingFS,
+            locationServiceLayer: Layer.succeed(
+              Location.Service,
+              Location.Service.of(
+                location({ directory: AbsolutePath.make("/repo/") }, { projectDirectory: AbsolutePath.make("/repo") }),
+              ),
+            ),
+          }),
+        ),
+      )
+
+      expect(observed).toEqual({
+        targets: ["AGENTS.md"],
+        start: FSUtil.resolve("/repo"),
+        stop: FSUtil.resolve("/repo"),
+      })
+    }),
+  )
+
+  it.effect("honors the project instruction opt-out", () =>
+    Effect.gen(function* () {
+      const previous = process.env.NEUROCODE_DISABLE_PROJECT_CONFIG
+      let scanned = false
+      process.env.NEUROCODE_DISABLE_PROJECT_CONFIG = "1"
+
+      yield* SystemContextRegistry.Service.pipe(
+        Effect.flatMap((service) => service.load()),
+        Effect.provide(
+          instructionLayer({
+            config: "/global",
+            filesystemLayer: Layer.effect(
+              FSUtil.Service,
+              FSUtil.Service.pipe(
+                Effect.map((fs) => FSUtil.Service.of({ ...fs, up: () => Effect.sync(() => ((scanned = true), [])) })),
+              ),
+            ).pipe(Layer.provide(LayerNode.compile(FSUtil.node))),
+            locationServiceLayer: Layer.succeed(
+              Location.Service,
+              Location.Service.of(location({ directory: AbsolutePath.make("/repo") })),
+            ),
+          }),
+        ),
+        Effect.ensuring(
+          Effect.sync(() => {
+            if (previous === undefined) delete process.env.NEUROCODE_DISABLE_PROJECT_CONFIG
+            else process.env.NEUROCODE_DISABLE_PROJECT_CONFIG = previous
+          }),
+        ),
+      )
+
+      expect(scanned).toBe(false)
+    }),
+  )
+
+  it.effect("does not discover project instructions outside the canonical project root", () =>
+    Effect.gen(function* () {
+      let scanned = false
+      yield* SystemContextRegistry.Service.pipe(
+        Effect.flatMap((service) => service.load()),
+        Effect.provide(
+          instructionLayer({
+            config: "/global",
+            filesystemLayer: Layer.effect(
+              FSUtil.Service,
+              FSUtil.Service.pipe(
+                Effect.map((fs) => FSUtil.Service.of({ ...fs, up: () => Effect.sync(() => ((scanned = true), [])) })),
+              ),
+            ).pipe(Layer.provide(LayerNode.compile(FSUtil.node))),
+            locationServiceLayer: Layer.succeed(
+              Location.Service,
+              Location.Service.of(
+                location(
+                  { directory: AbsolutePath.make("/outside") },
+                  { projectDirectory: AbsolutePath.make("/repo") },
+                ),
+              ),
+            ),
+          }),
+        ),
+      )
+
+      expect(scanned).toBe(false)
+    }),
+  )
+})