@neurocode-ai/core 1.18.8

package/test/tool-question.test.ts

@@ -0,0 +1,162 @@
+import { describe, expect } from "bun:test"
+import { Effect, Exit, Fiber, Layer } from "effect"
+import { AppNodeBuilder } from "@neurocode-ai/core/effect/app-node-builder"
+import { LayerNode } from "@neurocode-ai/core/effect/layer-node"
+import { PermissionV2 } from "@neurocode-ai/core/permission"
+import { QuestionV2 } from "@neurocode-ai/core/question"
+import { SessionV2 } from "@neurocode-ai/core/session"
+import { ToolRegistry } from "@neurocode-ai/core/tool/registry"
+import { QuestionTool } from "@neurocode-ai/core/tool/question"
+import { ToolOutputStore } from "@neurocode-ai/core/tool-output-store"
+import { testEffect } from "./lib/effect"
+import { toolIdentity, executeTool, settleTool, toolDefinitions } from "./lib/tool"
+
+const sessionID = SessionV2.ID.make("ses_question_tool_test")
+const assertions: PermissionV2.AssertInput[] = []
+let captured: QuestionV2.AskInput | undefined
+let reject = false
+let deny = false
+const capturedInput = () => captured
+const permission = Layer.succeed(
+  PermissionV2.Service,
+  PermissionV2.Service.of({
+    assert: (input) =>
+      Effect.sync(() => assertions.push(input)).pipe(
+        Effect.andThen(deny ? Effect.fail(new PermissionV2.BlockedError({ rules: [] })) : Effect.void),
+      ),
+    ask: () => Effect.die("unused"),
+    reply: () => Effect.die("unused"),
+    get: () => Effect.die("unused"),
+    forSession: () => Effect.die("unused"),
+    list: () => Effect.die("unused"),
+  }),
+)
+const question = Layer.succeed(
+  QuestionV2.Service,
+  QuestionV2.Service.of({
+    ask: (input: QuestionV2.AskInput) =>
+      Effect.sync(() => {
+        captured = input
+      }).pipe(Effect.andThen(reject ? Effect.fail(new QuestionV2.RejectedError()) : Effect.succeed([["Build"], []]))),
+    reply: () => Effect.die("unused"),
+    reject: () => Effect.die("unused"),
+    list: () => Effect.die("unused"),
+  }),
+)
+const it = testEffect(
+  AppNodeBuilder.build(LayerNode.group([ToolRegistry.node, ToolRegistry.toolsNode, QuestionTool.node]), [
+    [PermissionV2.node, permission],
+    [QuestionV2.node, question],
+    [ToolOutputStore.node, ToolOutputStore.nodeWithoutConfig],
+  ]),
+)
+
+describe("QuestionTool", () => {
+  it.effect("omits a denied built-in question and terminally settles a stale call", () =>
+    Effect.gen(function* () {
+      captured = undefined
+      deny = true
+      const registry = yield* ToolRegistry.Service
+
+      expect(yield* toolDefinitions(registry, [{ action: "question", resource: "*", effect: "deny" }])).toEqual([])
+      expect(
+        yield* settleTool(registry, {
+          sessionID,
+          ...toolIdentity,
+          call: { type: "tool-call", id: "call-question-denied", name: "question", input: { questions: [] } },
+        }),
+      ).toEqual({ result: { type: "error", value: "Permission denied: question" } })
+      expect(capturedInput()).toBeUndefined()
+      deny = false
+    }),
+  )
+
+  it.effect("registers question and projects user answers without a permission assertion", () =>
+    Effect.gen(function* () {
+      assertions.length = 0
+      captured = undefined
+      reject = false
+      deny = false
+      const registry = yield* ToolRegistry.Service
+      const questions = [
+        {
+          question: "What should happen?",
+          header: "Action",
+          options: [{ label: "Build", description: "Build it" }],
+        },
+        {
+          question: "Which environment?",
+          header: "Environment",
+          options: [{ label: "Dev", description: "Development" }],
+        },
+      ]
+
+      expect((yield* toolDefinitions(registry)).map((definition) => definition.name)).toEqual(["question"])
+      expect(
+        yield* settleTool(registry, {
+          sessionID,
+          ...toolIdentity,
+          call: { type: "tool-call", id: "call-question", name: "question", input: { questions } },
+        }),
+      ).toEqual({
+        result: {
+          type: "text",
+          value:
+            'User has answered your questions: "What should happen?"="Build", "Which environment?"="Unanswered". You can now continue with the user\'s answers in mind.',
+        },
+        output: {
+          structured: { answers: [["Build"], []] },
+          content: [
+            {
+              type: "text",
+              text: 'User has answered your questions: "What should happen?"="Build", "Which environment?"="Unanswered". You can now continue with the user\'s answers in mind.',
+            },
+          ],
+        },
+      })
+      expect(assertions).toMatchObject([{ sessionID, action: "question", resources: ["*"] }])
+      expect(capturedInput()).toEqual({
+        sessionID,
+        questions,
+        tool: { messageID: toolIdentity.assistantMessageID, callID: "call-question" },
+      })
+    }),
+  )
+
+  it.effect("does not invent tool ownership metadata without a durable registry source", () =>
+    Effect.gen(function* () {
+      captured = undefined
+      reject = false
+      deny = false
+      const registryService = yield* ToolRegistry.Service
+
+      yield* executeTool(registryService, {
+        sessionID,
+        ...toolIdentity,
+        call: { type: "tool-call", id: "call-question", name: "question", input: { questions: [] } },
+      })
+      expect(capturedInput()).toEqual({
+        sessionID,
+        questions: [],
+        tool: { messageID: toolIdentity.assistantMessageID, callID: "call-question" },
+      })
+    }),
+  )
+
+  it.effect("keeps dismissed questions out of model-facing output", () =>
+    Effect.gen(function* () {
+      captured = undefined
+      reject = true
+      deny = false
+      const registryService = yield* ToolRegistry.Service
+      const fiber = yield* executeTool(registryService, {
+        sessionID,
+        ...toolIdentity,
+        call: { type: "tool-call", id: "call-question", name: "question", input: { questions: [] } },
+      }).pipe(Effect.forkScoped)
+
+      const exit = yield* Fiber.await(fiber)
+      expect(Exit.isFailure(exit)).toBe(true)
+    }),
+  )
+})

package/test/tool-read-filesystem.test.ts

@@ -0,0 +1,118 @@
+import { describe, expect } from "bun:test"
+import path from "path"
+import { Effect, FileSystem } from "effect"
+import { LayerNodePlatform } from "@neurocode-ai/core/effect/app-node-platform"
+import { LayerNode } from "@neurocode-ai/core/effect/layer-node"
+import { FSUtil } from "@neurocode-ai/core/fs-util"
+import { ReadToolFileSystem } from "@neurocode-ai/core/tool/read-filesystem"
+import { testEffect } from "./lib/effect"
+
+const it = testEffect(LayerNode.compile(LayerNode.group([FSUtil.node, LayerNodePlatform.filesystem])))
+const fixture = Effect.gen(function* () {
+  const fs = yield* FSUtil.Service
+  const files = yield* FileSystem.FileSystem
+  const directory = yield* files.makeTempDirectoryScoped()
+  return { fs, files, directory }
+})
+
+describe("ReadToolFileSystem", () => {
+  it.effect("fails with a typed filesystem error when a resolved file disappears", () =>
+    Effect.gen(function* () {
+      const { fs, directory } = yield* fixture
+      const file = path.join(directory, "missing.txt")
+
+      const error = yield* ReadToolFileSystem.read(fs, file, "missing.txt").pipe(Effect.flip)
+
+      expect(error).toMatchObject({ _tag: "PlatformError" })
+    }),
+  )
+
+  it.effect("fails when a file becomes the wrong path kind", () =>
+    Effect.gen(function* () {
+      const { fs, directory } = yield* fixture
+
+      const error = yield* ReadToolFileSystem.read(fs, directory, "folder").pipe(Effect.flip)
+
+      expect(error).toBeInstanceOf(ReadToolFileSystem.PathKindError)
+    }),
+  )
+
+  it.effect("fails with a typed filesystem error when directory listing fails", () =>
+    Effect.gen(function* () {
+      const { fs, files, directory } = yield* fixture
+      const file = path.join(directory, "file.txt")
+      yield* files.writeFileString(file, "hello")
+
+      const error = yield* ReadToolFileSystem.list(fs, file).pipe(Effect.flip)
+
+      expect(error).toBeInstanceOf(FSUtil.FileSystemError)
+      if (error instanceof FSUtil.FileSystemError) expect(error.method).toBe("readDirectoryEntries")
+    }),
+  )
+
+  it.effect("reports binary and malformed UTF-8 content as typed errors", () =>
+    Effect.gen(function* () {
+      const { fs, files, directory } = yield* fixture
+      const binary = path.join(directory, "archive.dat")
+      const malformed = path.join(directory, "malformed.txt")
+      yield* files.writeFile(binary, Uint8Array.of(0, 1, 2, 3))
+      const malformedContent = new Uint8Array(64 * 1024 + 1).fill(97)
+      malformedContent[64 * 1024] = 0x80
+      yield* files.writeFile(malformed, malformedContent)
+
+      const binaryError = yield* ReadToolFileSystem.read(fs, binary, "archive.dat").pipe(Effect.flip)
+      const malformedError = yield* ReadToolFileSystem.read(fs, malformed, "malformed.txt").pipe(Effect.flip)
+
+      expect(binaryError).toBeInstanceOf(ReadToolFileSystem.BinaryFileError)
+      expect(binaryError.message).toBe("Cannot read binary file: archive.dat")
+      expect(malformedError).toBeInstanceOf(ReadToolFileSystem.MalformedUtf8Error)
+    }),
+  )
+
+  it.effect("reports out-of-range pagination as a typed error", () =>
+    Effect.gen(function* () {
+      const { fs, files, directory } = yield* fixture
+      const file = path.join(directory, "short.txt")
+      yield* files.writeFileString(file, "one\n")
+
+      const error = yield* ReadToolFileSystem.read(fs, file, "short.txt", { offset: 2 }).pipe(Effect.flip)
+
+      expect(error).toBeInstanceOf(ReadToolFileSystem.OffsetOutOfRangeError)
+      expect(error.message).toBe("Offset 2 is out of range")
+    }),
+  )
+
+  it.effect("stops reading after the requested page is complete", () =>
+    Effect.gen(function* () {
+      const { fs, files, directory } = yield* fixture
+      const prefix = new TextEncoder().encode("one\n")
+      for (const [name, trailing] of [
+        ["malformed.txt", 0x80],
+        ["nul.txt", 0],
+      ] as const) {
+        const file = path.join(directory, name)
+        yield* files.writeFile(file, Uint8Array.from([...prefix, trailing]))
+
+        const result = yield* ReadToolFileSystem.read(fs, file, name, { limit: 1 })
+
+        expect(result).toMatchObject({ type: "text-page", content: "one", truncated: true, next: 2 })
+      }
+    }),
+  )
+
+  it.effect("preserves the media ingestion limit message", () =>
+    Effect.gen(function* () {
+      const { fs, files, directory } = yield* fixture
+      const file = path.join(directory, "oversized.png")
+      yield* files.writeFile(file, Uint8Array.of(0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a))
+      yield* files.truncate(file, ReadToolFileSystem.MAX_MEDIA_INGEST_BYTES + 1)
+
+      const error = yield* ReadToolFileSystem.read(fs, file, "oversized.png").pipe(Effect.flip)
+
+      expect(error).toBeInstanceOf(ReadToolFileSystem.MediaIngestLimitError)
+      expect(error.message).toBe(
+        `Media exceeds ${ReadToolFileSystem.MAX_MEDIA_INGEST_BYTES} byte ingestion limit: oversized.png`,
+      )
+    }),
+  )
+})