@miaws/miaw 1.18.5 → 1.18.6

package/test/tool/tool-define.test.ts

@@ -1,153 +0,0 @@
-import { describe, expect } from "bun:test"
-import { Cause, Effect, Exit, Layer, Schema } from "effect"
-import { Agent } from "../../src/agent/agent"
-import { MessageID, SessionID } from "../../src/session/schema"
-import { Tool } from "@/tool/tool"
-import { Truncate } from "@/tool/truncate"
-import { testEffect } from "../lib/effect"
-
-const it = testEffect(Layer.mergeAll(Truncate.defaultLayer, Agent.defaultLayer))
-
-const params = Schema.Struct({ input: Schema.String })
-
-function makeCtx(): Tool.Context {
-  return {
-    sessionID: SessionID.descending(),
-    messageID: MessageID.ascending(),
-    agent: "build",
-    abort: new AbortController().signal,
-    messages: [],
-    metadata() {
-      return Effect.void
-    },
-    ask() {
-      return Effect.void
-    },
-  }
-}
-
-function makeTool(id: string, executeFn?: () => void) {
-  return {
-    description: "test tool",
-    parameters: params,
-    execute() {
-      executeFn?.()
-      return Effect.succeed({ title: "test", output: "ok", metadata: {} })
-    },
-  }
-}
-
-describe("Tool.define", () => {
-  it.effect("object-defined tool does not mutate the original init object", () =>
-    Effect.gen(function* () {
-      const original = makeTool("test")
-      const originalExecute = original.execute
-
-      const info = yield* Tool.define("test-tool", Effect.succeed(original))
-
-      yield* info.init()
-      yield* info.init()
-      yield* info.init()
-
-      expect(original.execute).toBe(originalExecute)
-    }),
-  )
-
-  it.effect("effect-defined tool returns fresh objects and is unaffected", () =>
-    Effect.gen(function* () {
-      const info = yield* Tool.define(
-        "test-fn-tool",
-        Effect.succeed(() => Effect.succeed(makeTool("test"))),
-      )
-
-      const first = yield* info.init()
-      const second = yield* info.init()
-
-      expect(first).not.toBe(second)
-    }),
-  )
-
-  it.effect("object-defined tool returns distinct objects per init() call", () =>
-    Effect.gen(function* () {
-      const info = yield* Tool.define("test-copy", Effect.succeed(makeTool("test")))
-
-      const first = yield* info.init()
-      const second = yield* info.init()
-
-      expect(first).not.toBe(second)
-    }),
-  )
-
-  it.effect("execute receives decoded parameters", () =>
-    Effect.gen(function* () {
-      const parameters = Schema.Struct({
-        count: Schema.NumberFromString.pipe(Schema.optional, Schema.withDecodingDefaultType(Effect.succeed(5))),
-      })
-      const calls: Array<Schema.Schema.Type<typeof parameters>> = []
-      const info = yield* Tool.define(
-        "test-decoded",
-        Effect.succeed({
-          description: "test tool",
-          parameters,
-          execute(args: Schema.Schema.Type<typeof parameters>) {
-            calls.push(args)
-            return Effect.succeed({ title: "test", output: "ok", metadata: { truncated: false } })
-          },
-        }),
-      )
-      const ctx = makeCtx()
-      const tool = yield* info.init()
-      const execute = tool.execute as unknown as (args: unknown, ctx: Tool.Context) => ReturnType<typeof tool.execute>
-
-      yield* execute({}, ctx)
-      yield* execute({ count: "7" }, ctx)
-
-      expect(calls).toEqual([{ count: 5 }, { count: 7 }])
-    }),
-  )
-
-  // Regression for #28438: the wrap is the canonical "untyped → typed" boundary.
-  // When the LLM emits a tool call with a payload that fails the parameter
-  // schema, the wrap must surface a typed `Tool.InvalidArgumentsError` whose
-  // `.message` is the actionable prose the AI SDK feeds back to the model.
-  it.effect("invalid args surface as Tool.InvalidArgumentsError with friendly message and JSON path", () =>
-    Effect.gen(function* () {
-      const parameters = Schema.Struct({
-        questions: Schema.Array(
-          Schema.Struct({
-            question: Schema.String,
-            options: Schema.Array(Schema.String),
-          }),
-        ),
-      })
-      const info = yield* Tool.define(
-        "qtest",
-        Effect.succeed({
-          description: "test tool",
-          parameters,
-          execute() {
-            return Effect.succeed({ title: "ok", output: "ok", metadata: { truncated: false } })
-          },
-        }),
-      )
-      const tool = yield* info.init()
-      const execute = tool.execute as unknown as (args: unknown, ctx: Tool.Context) => ReturnType<typeof tool.execute>
-
-      // Missing required `question` field on the first questions[] entry.
-      const exit = yield* execute({ questions: [{ options: ["a"] }] }, makeCtx()).pipe(Effect.exit)
-      expect(Exit.isFailure(exit)).toBe(true)
-      if (!Exit.isFailure(exit)) return
-
-      // The wrap ends with Effect.orDie, so the failure lives in the cause as a
-      // defect. Recover the typed instance from there.
-      const die = exit.cause.reasons.find(Cause.isDieReason)
-      const error = die?.defect
-      expect(error).toBeInstanceOf(Tool.InvalidArgumentsError)
-      const args = error as Tool.InvalidArgumentsError
-      expect(args.tool).toBe("qtest")
-      expect(args.message).toContain("qtest tool was called with invalid arguments")
-      expect(args.message).toContain("Please rewrite the input")
-      expect(args.message).toContain(`["questions"][0]["question"]`)
-    }),
-  )
-})

package/test/tool/truncation.test.ts

@@ -1,266 +0,0 @@
-import { describe, test, expect } from "bun:test"
-import { ConfigV1 } from "@miaw/core/v1/config/config"
-import { NodeFileSystem } from "@effect/platform-node"
-import { FSUtil } from "@miaw/core/fs-util"
-import { Effect, FileSystem, Layer } from "effect"
-import { Truncate } from "@/tool/truncate"
-import { Config } from "@/config/config"
-import { Identifier } from "../../src/id/id"
-import { Process } from "@/util/process"
-import path from "path"
-import { testEffect } from "../lib/effect"
-import { writeFileStringScoped } from "../lib/filesystem"
-import { TestConfig } from "../fixture/config"
-
-const FIXTURES_DIR = path.join(import.meta.dir, "fixtures")
-const ROOT = path.resolve(import.meta.dir, "..", "..")
-
-const it = testEffect(Layer.mergeAll(Truncate.defaultLayer, NodeFileSystem.layer, FSUtil.defaultLayer))
-
-const configuredLayer = (cfg: ConfigV1.Info) =>
-  Layer.mergeAll(
-    Truncate.defaultLayer,
-    NodeFileSystem.layer,
-    FSUtil.defaultLayer,
-    TestConfig.layer({ get: () => Effect.succeed(cfg) }),
-  )
-const configuredIt = (cfg: ConfigV1.Info) => testEffect(configuredLayer(cfg))
-
-describe("Truncate", () => {
-  describe("output", () => {
-    it.live("truncates large json file by bytes", () =>
-      Effect.gen(function* () {
-        const svc = yield* Truncate.Service
-        const fsys = yield* FSUtil.Service
-        const content = yield* fsys.readFileString(path.join(FIXTURES_DIR, "models-api.json"))
-        const result = yield* svc.output(content)
-
-        expect(result.truncated).toBe(true)
-        expect(result.content).toContain("truncated...")
-        if (result.truncated) expect(result.outputPath).toBeDefined()
-      }),
-    )
-
-    it.live("returns content unchanged when under limits", () =>
-      Effect.gen(function* () {
-        const svc = yield* Truncate.Service
-        const content = "line1\nline2\nline3"
-        const result = yield* svc.output(content)
-
-        expect(result.truncated).toBe(false)
-        expect(result.content).toBe(content)
-      }),
-    )
-
-    it.live("truncates by line count", () =>
-      Effect.gen(function* () {
-        const svc = yield* Truncate.Service
-        const lines = Array.from({ length: 100 }, (_, i) => `line${i}`).join("\n")
-        const result = yield* svc.output(lines, { maxLines: 10 })
-
-        expect(result.truncated).toBe(true)
-        expect(result.content).toContain("...90 lines truncated...")
-      }),
-    )
-
-    it.live("truncates by byte count", () =>
-      Effect.gen(function* () {
-        const svc = yield* Truncate.Service
-        const content = "a".repeat(1000)
-        const result = yield* svc.output(content, { maxBytes: 100 })
-
-        expect(result.truncated).toBe(true)
-        expect(result.content).toContain("truncated...")
-      }),
-    )
-
-    it.live("truncates from head by default", () =>
-      Effect.gen(function* () {
-        const svc = yield* Truncate.Service
-        const lines = Array.from({ length: 10 }, (_, i) => `line${i}`).join("\n")
-        const result = yield* svc.output(lines, { maxLines: 3 })
-
-        expect(result.truncated).toBe(true)
-        expect(result.content).toContain("line0")
-        expect(result.content).toContain("line1")
-        expect(result.content).toContain("line2")
-        expect(result.content).not.toContain("line9")
-      }),
-    )
-
-    it.live("truncates from tail when direction is tail", () =>
-      Effect.gen(function* () {
-        const svc = yield* Truncate.Service
-        const lines = Array.from({ length: 10 }, (_, i) => `line${i}`).join("\n")
-        const result = yield* svc.output(lines, { maxLines: 3, direction: "tail" })
-
-        expect(result.truncated).toBe(true)
-        expect(result.content).toContain("line7")
-        expect(result.content).toContain("line8")
-        expect(result.content).toContain("line9")
-        expect(result.content).not.toContain("line0")
-      }),
-    )
-
-    test("uses default MAX_LINES and MAX_BYTES", () => {
-      expect(Truncate.MAX_LINES).toBe(2000)
-      expect(Truncate.MAX_BYTES).toBe(50 * 1024)
-    })
-
-    it.live("limits() falls back to MAX_LINES/MAX_BYTES when Config is not provided", () =>
-      Effect.gen(function* () {
-        const svc = yield* Truncate.Service
-        const resolved = yield* svc.limits()
-        expect(resolved.maxLines).toBe(Truncate.MAX_LINES)
-        expect(resolved.maxBytes).toBe(Truncate.MAX_BYTES)
-      }),
-    )
-
-    describe("with tool_output config", () => {
-      const limitsIt = configuredIt({ tool_output: { max_lines: 123, max_bytes: 456 } })
-      limitsIt.live("limits() reflects config overrides", () =>
-        Effect.gen(function* () {
-          const resolved = yield* (yield* Truncate.Service).limits()
-          expect(resolved.maxLines).toBe(123)
-          expect(resolved.maxBytes).toBe(456)
-        }),
-      )
-
-      // Huge byte budget isolates line truncation. 100 lines against max_lines: 10
-      // proves the configured line limit is what `output()` enforces.
-      const lineIt = configuredIt({ tool_output: { max_lines: 10, max_bytes: 1024 * 1024 } })
-      lineIt.live("output() truncates to configured max_lines", () =>
-        Effect.gen(function* () {
-          const content = Array.from({ length: 100 }, (_, i) => `line${i}`).join("\n")
-          const result = yield* (yield* Truncate.Service).output(content)
-          expect(result.truncated).toBe(true)
-          expect(result.content).toContain("...90 lines truncated...")
-        }),
-      )
-
-      // Huge line budget isolates byte truncation.
-      const byteIt = configuredIt({ tool_output: { max_lines: 1_000_000, max_bytes: 100 } })
-      byteIt.live("output() truncates to configured max_bytes", () =>
-        Effect.gen(function* () {
-          const content = "a".repeat(1000)
-          const result = yield* (yield* Truncate.Service).output(content)
-          expect(result.truncated).toBe(true)
-          expect(result.content).toContain("bytes truncated...")
-        }),
-      )
-
-      const overrideIt = configuredIt({ tool_output: { max_lines: 10, max_bytes: 100 } })
-      overrideIt.live("per-call options still override config", () =>
-        Effect.gen(function* () {
-          const content = Array.from({ length: 50 }, (_, i) => `line${i}`).join("\n")
-          const result = yield* (yield* Truncate.Service).output(content, {
-            maxLines: 1000,
-            maxBytes: 1024 * 1024,
-          })
-          expect(result.truncated).toBe(false)
-        }),
-      )
-    })
-
-    it.live("large single-line file truncates with byte message", () =>
-      Effect.gen(function* () {
-        const svc = yield* Truncate.Service
-        const fsys = yield* FSUtil.Service
-        const content = yield* fsys.readFileString(path.join(FIXTURES_DIR, "models-api.json"))
-        const result = yield* svc.output(content)
-
-        expect(result.truncated).toBe(true)
-        expect(result.content).toContain("bytes truncated...")
-        expect(Buffer.byteLength(content, "utf-8")).toBeGreaterThan(Truncate.MAX_BYTES)
-      }),
-    )
-
-    it.live("writes full output to file when truncated", () =>
-      Effect.gen(function* () {
-        const svc = yield* Truncate.Service
-        const lines = Array.from({ length: 100 }, (_, i) => `line${i}`).join("\n")
-        const result = yield* svc.output(lines, { maxLines: 10 })
-
-        expect(result.truncated).toBe(true)
-        expect(result.content).toContain("The tool call succeeded but the output was truncated")
-        expect(result.content).toContain("Grep")
-        if (!result.truncated) throw new Error("expected truncated")
-        expect(result.outputPath).toBeDefined()
-        expect(result.outputPath).toContain("tool_")
-
-        const fsys = yield* FSUtil.Service
-        const written = yield* fsys.readFileString(result.outputPath!)
-        expect(written).toBe(lines)
-      }),
-    )
-
-    it.live("suggests Task tool when agent has task permission", () =>
-      Effect.gen(function* () {
-        const svc = yield* Truncate.Service
-        const lines = Array.from({ length: 100 }, (_, i) => `line${i}`).join("\n")
-        const agent = { permission: [{ permission: "task", pattern: "*", action: "allow" as const }] }
-        const result = yield* svc.output(lines, { maxLines: 10 }, agent as any)
-
-        expect(result.truncated).toBe(true)
-        expect(result.content).toContain("Grep")
-        expect(result.content).toContain("Task tool")
-      }),
-    )
-
-    it.live("omits Task tool hint when agent lacks task permission", () =>
-      Effect.gen(function* () {
-        const svc = yield* Truncate.Service
-        const lines = Array.from({ length: 100 }, (_, i) => `line${i}`).join("\n")
-        const agent = { permission: [{ permission: "task", pattern: "*", action: "deny" as const }] }
-        const result = yield* svc.output(lines, { maxLines: 10 }, agent as any)
-
-        expect(result.truncated).toBe(true)
-        expect(result.content).toContain("Grep")
-        expect(result.content).not.toContain("Task tool")
-      }),
-    )
-
-    it.live("does not write file when not truncated", () =>
-      Effect.gen(function* () {
-        const svc = yield* Truncate.Service
-        const content = "short content"
-        const result = yield* svc.output(content)
-
-        expect(result.truncated).toBe(false)
-        if (result.truncated) throw new Error("expected not truncated")
-        expect("outputPath" in result).toBe(false)
-      }),
-    )
-
-    test("loads truncate effect in a fresh process", async () => {
-      const out = await Process.run([process.execPath, "run", path.join(ROOT, "src", "tool", "truncate.ts")], {
-        cwd: ROOT,
-      })
-
-      expect(out.code).toBe(0)
-    }, 20000)
-  })
-
-  describe("cleanup", () => {
-    const DAY_MS = 24 * 60 * 60 * 1000
-
-    it.live("deletes files older than 7 days and preserves recent files", () =>
-      Effect.gen(function* () {
-        const svc = yield* Truncate.Service
-        const fs = yield* FileSystem.FileSystem
-
-        yield* fs.makeDirectory(Truncate.DIR, { recursive: true })
-
-        const old = path.join(Truncate.DIR, Identifier.create("tool", "ascending", Date.now() - 10 * DAY_MS))
-        const recent = path.join(Truncate.DIR, Identifier.create("tool", "ascending", Date.now() - 3 * DAY_MS))
-
-        yield* writeFileStringScoped(old, "old content")
-        yield* writeFileStringScoped(recent, "recent content")
-        yield* svc.cleanup()
-
-        expect(yield* fs.exists(old)).toBe(false)
-        expect(yield* fs.exists(recent)).toBe(true)
-      }),
-    )
-  })
-})

package/test/tool/webfetch.test.ts

@@ -1,113 +0,0 @@
-import { describe, expect } from "bun:test"
-import { Effect, Layer } from "effect"
-import { FetchHttpClient } from "effect/unstable/http"
-import { Agent } from "../../src/agent/agent"
-import { Truncate } from "@/tool/truncate"
-import { WebFetchTool } from "../../src/tool/webfetch"
-import { SessionID, MessageID } from "../../src/session/schema"
-import { Tool } from "@/tool/tool"
-import { testEffect } from "../lib/effect"
-
-const it = testEffect(Layer.mergeAll(FetchHttpClient.layer, Truncate.defaultLayer, Agent.defaultLayer))
-
-const ctx = {
-  sessionID: SessionID.make("ses_test"),
-  messageID: MessageID.make("msg_message"),
-  callID: "",
-  agent: "build",
-  abort: AbortSignal.any([]),
-  messages: [],
-  metadata: () => Effect.void,
-  ask: () => Effect.void,
-}
-
-const withFetch = <A, E, R>(
-  fetch: (req: Request) => Response | Promise<Response>,
-  fn: (url: URL) => Effect.Effect<A, E, R>,
-) =>
-  Effect.acquireUseRelease(
-    Effect.sync(() => Bun.serve({ port: 0, fetch })),
-    (server) => fn(server.url),
-    (server) => Effect.sync(() => server.stop(true)),
-  )
-
-const exec = Effect.fn("WebFetchToolTest.exec")(function* (args: Tool.InferParameters<typeof WebFetchTool>) {
-  const info = yield* WebFetchTool
-  const tool = yield* info.init()
-  return yield* tool.execute(args, ctx)
-})
-
-describe("tool.webfetch", () => {
-  it.instance("returns image responses as file attachments", () =>
-    Effect.gen(function* () {
-      const bytes = new Uint8Array([137, 80, 78, 71, 13, 10, 26, 10])
-      yield* withFetch(
-        () => new Response(bytes, { status: 200, headers: { "content-type": "IMAGE/PNG; charset=binary" } }),
-        (url) =>
-          Effect.gen(function* () {
-            const result = yield* exec({ url: new URL("/image.png", url).toString(), format: "markdown" })
-            expect(result.output).toBe("Image fetched successfully")
-            expect(result.attachments).toBeDefined()
-            expect(result.attachments?.length).toBe(1)
-            expect(result.attachments?.[0].type).toBe("file")
-            expect(result.attachments?.[0].mime).toBe("image/png")
-            expect(result.attachments?.[0].url.startsWith("data:image/png;base64,")).toBe(true)
-            expect(result.attachments?.[0]).not.toHaveProperty("id")
-            expect(result.attachments?.[0]).not.toHaveProperty("sessionID")
-            expect(result.attachments?.[0]).not.toHaveProperty("messageID")
-          }),
-      )
-    }),
-  )
-
-  it.instance("keeps svg as text output", () =>
-    withFetch(
-      () =>
-        new Response('<svg xmlns="http://www.w3.org/2000/svg"><text>hello</text></svg>', {
-          status: 200,
-          headers: { "content-type": "image/svg+xml; charset=UTF-8" },
-        }),
-      (url) =>
-        Effect.gen(function* () {
-          const result = yield* exec({ url: new URL("/image.svg", url).toString(), format: "html" })
-          expect(result.output).toContain("<svg")
-          expect(result.attachments).toBeUndefined()
-        }),
-    ),
-  )
-
-  it.instance("keeps text responses as text output", () =>
-    withFetch(
-      () =>
-        new Response("hello from webfetch", {
-          status: 200,
-          headers: { "content-type": "text/plain; charset=utf-8" },
-        }),
-      (url) =>
-        Effect.gen(function* () {
-          const result = yield* exec({ url: new URL("/file.txt", url).toString(), format: "text" })
-          expect(result.output).toBe("hello from webfetch")
-          expect(result.attachments).toBeUndefined()
-        }),
-    ),
-  )
-
-  it.instance("extracts text from html without scripts or styles", () =>
-    withFetch(
-      () =>
-        new Response(
-          "<html><head><style>.hidden{}</style><script>alert('x')</script></head><body>Hello <b>world</b></body></html>",
-          {
-            status: 200,
-            headers: { "content-type": "text/html; charset=utf-8" },
-          },
-        ),
-      (url) =>
-        Effect.gen(function* () {
-          const result = yield* exec({ url: new URL("/page.html", url).toString(), format: "text" })
-          expect(result.output).toBe("Hello world")
-          expect(result.attachments).toBeUndefined()
-        }),
-    ),
-  )
-})

package/test/tool/websearch.test.ts

@@ -1,99 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { Effect } from "effect"
-import { parseResponse } from "../../src/tool/mcp-websearch"
-import { selectWebSearchProvider, webSearchModelName, webSearchProviderLabel } from "../../src/tool/websearch"
-
-import { webSearchEnabled } from "../../src/tool/registry"
-import { it } from "../lib/effect"
-import { ProviderV2 } from "@miaw/core/provider"
-
-const SESSION_ID = "ses_0196aabbccddeeff001122334455"
-
-describe("websearch provider", () => {
-  test("selects a stable provider per session", () => {
-    expect(selectWebSearchProvider(SESSION_ID)).toBe(selectWebSearchProvider(SESSION_ID))
-  })
-
-  test("supports an operational override", () => {
-    const original = process.env.MIAW_WEBSEARCH_PROVIDER
-
-    try {
-      process.env.MIAW_WEBSEARCH_PROVIDER = "parallel"
-      expect(selectWebSearchProvider(SESSION_ID)).toBe("parallel")
-
-      process.env.MIAW_WEBSEARCH_PROVIDER = "exa"
-      expect(selectWebSearchProvider(SESSION_ID)).toBe("exa")
-    } finally {
-      if (original === undefined) delete process.env.MIAW_WEBSEARCH_PROVIDER
-      else process.env.MIAW_WEBSEARCH_PROVIDER = original
-    }
-  })
-
-  test("routes to Exa when the Exa flag is enabled", () => {
-    expect(selectWebSearchProvider(SESSION_ID, { exa: true, parallel: false })).toBe("exa")
-  })
-
-  test("routes to Parallel when the Parallel flag is enabled", () => {
-    expect(selectWebSearchProvider(SESSION_ID, { exa: false, parallel: true })).toBe("parallel")
-  })
-
-  test("is only enabled for miaw or explicit websearch provider flags", () => {
-    expect(webSearchEnabled(ProviderV2.ID.miaw, { exa: false, parallel: false })).toBe(true)
-    expect(webSearchEnabled(ProviderV2.ID.openai, { exa: false, parallel: false })).toBe(false)
-    expect(webSearchEnabled(ProviderV2.ID.openai, { exa: true, parallel: false })).toBe(true)
-    expect(webSearchEnabled(ProviderV2.ID.openai, { exa: false, parallel: true })).toBe(true)
-  })
-
-  test("uses branded labels", () => {
-    expect(webSearchProviderLabel("parallel")).toBe("Parallel Web Search")
-    expect(webSearchProviderLabel("exa")).toBe("Exa Web Search")
-    expect(webSearchProviderLabel(undefined)).toBe("Web Search")
-  })
-
-  test("uses the provider API model id for Parallel analytics", () => {
-    expect(
-      webSearchModelName({
-        model: {
-          id: "claude-opus-4-7",
-          api: { id: "claude-opus-4.7" },
-        },
-      }),
-    ).toBe("claude-opus-4.7")
-  })
-})
-
-describe("websearch MCP response parser", () => {
-  const payload = JSON.stringify({
-    jsonrpc: "2.0",
-    id: 1,
-    result: {
-      content: [
-        {
-          type: "text",
-          text: "search results",
-        },
-      ],
-    },
-  })
-
-  it.effect("parses plain JSON-RPC responses", () =>
-    Effect.gen(function* () {
-      const result = yield* parseResponse(payload)
-      expect(result).toBe("search results")
-    }),
-  )
-
-  it.effect("parses SSE JSON-RPC responses", () =>
-    Effect.gen(function* () {
-      const result = yield* parseResponse(`event: message\ndata: ${payload}\n\n`)
-      expect(result).toBe("search results")
-    }),
-  )
-
-  it.effect("ignores non-JSON SSE data frames", () =>
-    Effect.gen(function* () {
-      const result = yield* parseResponse(`data: [DONE]\ndata: ${payload}\n\n`)
-      expect(result).toBe("search results")
-    }),
-  )
-})