woozlit 2.3.0 → 2.3.2

package/src/tool/truncate.ts

@@ -1,201 +0,0 @@
-import { NodePath } from "@effect/platform-node"
-import { Cause, Duration, Effect, Layer, Schedule, Context } from "effect"
-import path from "path"
-import type { Agent } from "../agent/agent"
-import { AppFileSystem } from "@woozlit/shared/filesystem"
-import { evaluate } from "@/permission/evaluate"
-import { Identifier } from "../id/id"
-import { Log } from "../util"
-import { ToolID } from "./schema"
-import { TRUNCATION_DIR } from "./truncation-dir"
-
-const log = Log.create({ service: "truncation" })
-const RETENTION = Duration.days(7)
-
-export const MAX_LINES = 2000
-export const MAX_BYTES = 50 * 1024
-export const DIR = TRUNCATION_DIR
-export const GLOB = path.join(TRUNCATION_DIR, "*")
-
-const ERROR_PATTERN = /error|exception|failed|fatal|traceback|panic|exit code/i
-const TAIL_SCAN_CHARS = 2048
-
-export type Result = { content: string; truncated: false } | { content: string; truncated: true; outputPath: string }
-
-export interface Options {
-  maxLines?: number
-  maxBytes?: number
-  direction?: "head" | "tail" | "head+tail"
-  pressureCaps?: boolean
-}
-
-function hasActorTool(agent?: Agent.Info) {
-  if (!agent?.permission) return false
-  return evaluate("actor", "*", agent.permission).action !== "deny"
-}
-
-export interface Interface {
-  readonly cleanup: () => Effect.Effect<void>
-  readonly write: (text: string) => Effect.Effect<string>
-  /**
-   * Returns output unchanged when it fits within the limits, otherwise writes the full text
-   * to the truncation directory and returns a preview plus a hint to inspect the saved file.
-   */
-  readonly output: (text: string, options?: Options, agent?: Agent.Info) => Effect.Effect<Result>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@opencode/Truncate") {}
-
-export const layer = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const fs = yield* AppFileSystem.Service
-
-    const cleanup = Effect.fn("Truncate.cleanup")(function* () {
-      const cutoff = Identifier.timestamp(
-        Identifier.create("tool", "ascending", Date.now() - Duration.toMillis(RETENTION)),
-      )
-      const entries = yield* fs.readDirectory(TRUNCATION_DIR).pipe(
-        Effect.map((all) => all.filter((name) => name.startsWith("tool_"))),
-        Effect.catch(() => Effect.succeed([])),
-      )
-      for (const entry of entries) {
-        if (Identifier.timestamp(entry) >= cutoff) continue
-        yield* fs.remove(path.join(TRUNCATION_DIR, entry)).pipe(Effect.catch(() => Effect.void))
-      }
-    })
-
-    const write = Effect.fn("Truncate.write")(function* (text: string) {
-      const file = path.join(TRUNCATION_DIR, ToolID.ascending())
-      yield* fs.ensureDir(TRUNCATION_DIR).pipe(Effect.orDie)
-      yield* fs.writeFileString(file, text).pipe(Effect.orDie)
-      return file
-    })
-
-    const output = Effect.fn("Truncate.output")(function* (text: string, options: Options = {}, agent?: Agent.Info) {
-      let maxLines = options.maxLines ?? MAX_LINES
-      let maxBytes = options.maxBytes ?? MAX_BYTES
-      const direction = options.direction ?? "head+tail"
-      const pressureCaps = options.pressureCaps ?? false
-
-      if (pressureCaps) {
-        maxLines = Math.floor(maxLines / 2)
-        maxBytes = Math.floor(maxBytes / 2)
-      }
-
-      const lines = text.split("\n")
-      const totalBytes = Buffer.byteLength(text, "utf-8")
-
-      if (lines.length <= maxLines && totalBytes <= maxBytes) {
-        return { content: text, truncated: false } as const
-      }
-
-      if (direction === "head+tail") {
-        // Check if the last TAIL_SCAN_CHARS contain an error pattern
-        const tailScan = text.length > TAIL_SCAN_CHARS ? text.slice(-TAIL_SCAN_CHARS) : text
-        const hasErrors = ERROR_PATTERN.test(tailScan)
-
-        if (hasErrors) {
-          // Allocate 70% of budget to head, 30% to tail
-          const headMaxLines = Math.floor(maxLines * 0.7)
-          const headMaxBytes = Math.floor(maxBytes * 0.7)
-          const tailMaxLines = maxLines - headMaxLines
-          const tailMaxBytes = maxBytes - headMaxBytes
-
-          // Collect head lines
-          const headOut: string[] = []
-          let headBytes = 0
-          for (let i = 0; i < lines.length && headOut.length < headMaxLines; i++) {
-            const size = Buffer.byteLength(lines[i], "utf-8") + (i > 0 ? 1 : 0)
-            if (headBytes + size > headMaxBytes) break
-            headOut.push(lines[i])
-            headBytes += size
-          }
-
-          // Collect tail lines
-          const tailOut: string[] = []
-          let tailBytes = 0
-          for (let i = lines.length - 1; i >= 0 && tailOut.length < tailMaxLines; i--) {
-            const size = Buffer.byteLength(lines[i], "utf-8") + (tailOut.length > 0 ? 1 : 0)
-            if (tailBytes + size > tailMaxBytes) break
-            tailOut.unshift(lines[i])
-            tailBytes += size
-          }
-
-          const omitted = lines.length - headOut.length - tailOut.length
-          const file = yield* write(text)
-
-          const hintText = hasActorTool(agent)
-            ? `The tool call succeeded but the output was truncated. Full output saved to: ${file}\nUse the actor tool to have explore agent process this file with Grep and Read (with offset/limit). Do NOT read the full file yourself - delegate to save context.`
-            : `The tool call succeeded but the output was truncated. Full output saved to: ${file}\nUse Grep to search the full content or Read with offset/limit to view specific sections.`
-
-          return {
-            content: `${headOut.join("\n")}\n\n... ${omitted} lines omitted — showing head and tail ...\n\n${tailOut.join("\n")}\n\n${hintText}`,
-            truncated: true,
-            outputPath: file,
-          } as const
-        }
-        // No errors in tail: degrade to head behavior
-      }
-
-      const out: string[] = []
-      let i = 0
-      let bytes = 0
-      let hitBytes = false
-
-      if (direction === "head" || direction === "head+tail") {
-        for (i = 0; i < lines.length && i < maxLines; i++) {
-          const size = Buffer.byteLength(lines[i], "utf-8") + (i > 0 ? 1 : 0)
-          if (bytes + size > maxBytes) {
-            hitBytes = true
-            break
-          }
-          out.push(lines[i])
-          bytes += size
-        }
-      } else {
-        for (i = lines.length - 1; i >= 0 && out.length < maxLines; i--) {
-          const size = Buffer.byteLength(lines[i], "utf-8") + (out.length > 0 ? 1 : 0)
-          if (bytes + size > maxBytes) {
-            hitBytes = true
-            break
-          }
-          out.unshift(lines[i])
-          bytes += size
-        }
-      }
-
-      const removed = hitBytes ? totalBytes - bytes : lines.length - out.length
-      const unit = hitBytes ? "bytes" : "lines"
-      const preview = out.join("\n")
-      const file = yield* write(text)
-
-      const hintText = hasActorTool(agent)
-        ? `The tool call succeeded but the output was truncated. Full output saved to: ${file}\nUse the actor tool to have explore agent process this file with Grep and Read (with offset/limit). Do NOT read the full file yourself - delegate to save context.`
-        : `The tool call succeeded but the output was truncated. Full output saved to: ${file}\nUse Grep to search the full content or Read with offset/limit to view specific sections.`
-
-      return {
-        content:
-          direction === "head" || direction === "head+tail"
-            ? `${preview}\n\n...${removed} ${unit} truncated...\n\n${hintText}`
-            : `...${removed} ${unit} truncated...\n\n${hintText}\n\n${preview}`,
-        truncated: true,
-        outputPath: file,
-      } as const
-    })
-
-    yield* cleanup().pipe(
-      Effect.catchCause((cause) => {
-        log.error("truncation cleanup failed", { cause: Cause.pretty(cause) })
-        return Effect.void
-      }),
-      Effect.repeat(Schedule.spaced(Duration.hours(1))),
-      Effect.delay(Duration.minutes(1)),
-      Effect.forkScoped,
-    )
-
-    return Service.of({ cleanup, write, output })
-  }),
-)
-
-export const defaultLayer = layer.pipe(Layer.provide(AppFileSystem.defaultLayer), Layer.provide(NodePath.layer))

package/src/tool/truncation-dir.ts

@@ -1,4 +0,0 @@
-import path from "path"
-import { Global } from "../global"
-
-export const TRUNCATION_DIR = path.join(Global.Path.data, "tool-output")

package/src/tool/webfetch.ts

@@ -1,199 +0,0 @@
-import z from "zod"
-import { Effect } from "effect"
-import { HttpClient, HttpClientRequest } from "effect/unstable/http"
-import * as Tool from "./tool"
-import TurndownService from "turndown"
-import DESCRIPTION from "./webfetch.txt"
-import { isImageAttachment } from "@/util/media"
-
-const MAX_RESPONSE_SIZE = 5 * 1024 * 1024 // 5MB
-const DEFAULT_TIMEOUT = 30 * 1000 // 30 seconds
-const MAX_TIMEOUT = 120 * 1000 // 2 minutes
-
-const parameters = z.object({
-  url: z.string().describe("The URL to fetch content from"),
-  format: z
-    .enum(["text", "markdown", "html"])
-    .default("markdown")
-    .describe("The format to return the content in (text, markdown, or html). Defaults to markdown."),
-  timeout: z.number().describe("Optional timeout in seconds (max 120)").optional(),
-})
-
-export const WebFetchTool = Tool.define(
-  "webfetch",
-  Effect.gen(function* () {
-    const http = yield* HttpClient.HttpClient
-    const httpOk = HttpClient.filterStatusOk(http)
-
-    return {
-      description: DESCRIPTION,
-      parameters,
-      execute: (params: z.infer<typeof parameters>, ctx: Tool.Context) =>
-        Effect.gen(function* () {
-          if (!params.url.startsWith("http://") && !params.url.startsWith("https://")) {
-            throw new Error("URL must start with http:// or https://")
-          }
-
-          yield* ctx.ask({
-            permission: "webfetch",
-            patterns: [params.url],
-            always: ["*"],
-            metadata: {
-              url: params.url,
-              format: params.format,
-              timeout: params.timeout,
-            },
-          })
-
-          const timeout = Math.min((params.timeout ?? DEFAULT_TIMEOUT / 1000) * 1000, MAX_TIMEOUT)
-
-          // Build Accept header based on requested format with q parameters for fallbacks
-          let acceptHeader = "*/*"
-          switch (params.format) {
-            case "markdown":
-              acceptHeader = "text/markdown;q=1.0, text/x-markdown;q=0.9, text/plain;q=0.8, text/html;q=0.7, */*;q=0.1"
-              break
-            case "text":
-              acceptHeader = "text/plain;q=1.0, text/markdown;q=0.9, text/html;q=0.8, */*;q=0.1"
-              break
-            case "html":
-              acceptHeader =
-                "text/html;q=1.0, application/xhtml+xml;q=0.9, text/plain;q=0.8, text/markdown;q=0.7, */*;q=0.1"
-              break
-            default:
-              acceptHeader =
-                "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8"
-          }
-          const headers = {
-            "User-Agent":
-              "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36",
-            Accept: acceptHeader,
-            "Accept-Language": "en-US,en;q=0.9",
-          }
-
-          const request = HttpClientRequest.get(params.url).pipe(HttpClientRequest.setHeaders(headers))
-
-          // Retry with honest UA if blocked by Cloudflare bot detection (TLS fingerprint mismatch)
-          const response = yield* httpOk.execute(request).pipe(
-            Effect.catchIf(
-              (err) =>
-                err.reason._tag === "StatusCodeError" &&
-                err.reason.response.status === 403 &&
-                err.reason.response.headers["cf-mitigated"] === "challenge",
-              () =>
-                httpOk.execute(
-                  HttpClientRequest.get(params.url).pipe(
-                    HttpClientRequest.setHeaders({ ...headers, "User-Agent": "WOOZLIT_CODE" }),
-                  ),
-                ),
-            ),
-            Effect.timeoutOrElse({ duration: timeout, orElse: () => Effect.die(new Error("Request timed out")) }),
-          )
-
-          // Check content length
-          const contentLength = response.headers["content-length"]
-          if (contentLength && parseInt(contentLength) > MAX_RESPONSE_SIZE) {
-            throw new Error("Response too large (exceeds 5MB limit)")
-          }
-
-          const arrayBuffer = yield* response.arrayBuffer
-          if (arrayBuffer.byteLength > MAX_RESPONSE_SIZE) {
-            throw new Error("Response too large (exceeds 5MB limit)")
-          }
-
-          const contentType = response.headers["content-type"] || ""
-          const mime = contentType.split(";")[0]?.trim().toLowerCase() || ""
-          const title = `${params.url} (${contentType})`
-
-          if (isImageAttachment(mime)) {
-            const base64Content = Buffer.from(arrayBuffer).toString("base64")
-            return {
-              title,
-              output: "Image fetched successfully",
-              metadata: {},
-              attachments: [
-                {
-                  type: "file" as const,
-                  mime,
-                  url: `data:${mime};base64,${base64Content}`,
-                },
-              ],
-            }
-          }
-
-          const content = new TextDecoder().decode(arrayBuffer)
-
-          // Handle content based on requested format and actual content type
-          switch (params.format) {
-            case "markdown":
-              if (contentType.includes("text/html")) {
-                const markdown = convertHTMLToMarkdown(content)
-                return {
-                  output: markdown,
-                  title,
-                  metadata: {},
-                }
-              }
-              return { output: content, title, metadata: {} }
-
-            case "text":
-              if (contentType.includes("text/html")) {
-                const text = yield* Effect.promise(() => extractTextFromHTML(content))
-                return { output: text, title, metadata: {} }
-              }
-              return { output: content, title, metadata: {} }
-
-            case "html":
-              return { output: content, title, metadata: {} }
-
-            default:
-              return { output: content, title, metadata: {} }
-          }
-        }).pipe(Effect.orDie),
-    }
-  }),
-)
-
-async function extractTextFromHTML(html: string) {
-  let text = ""
-  let skipContent = false
-
-  const rewriter = new HTMLRewriter()
-    .on("script, style, noscript, iframe, object, embed", {
-      element() {
-        skipContent = true
-      },
-      text() {
-        // Skip text content inside these elements
-      },
-    })
-    .on("*", {
-      element(element) {
-        // Reset skip flag when entering other elements
-        if (!["script", "style", "noscript", "iframe", "object", "embed"].includes(element.tagName)) {
-          skipContent = false
-        }
-      },
-      text(input) {
-        if (!skipContent) {
-          text += input.text
-        }
-      },
-    })
-    .transform(new Response(html))
-
-  await rewriter.text()
-  return text.trim()
-}
-
-function convertHTMLToMarkdown(html: string): string {
-  const turndownService = new TurndownService({
-    headingStyle: "atx",
-    hr: "---",
-    bulletListMarker: "-",
-    codeBlockStyle: "fenced",
-    emDelimiter: "*",
-  })
-  turndownService.remove(["script", "style", "meta", "link"])
-  return turndownService.turndown(html)
-}

package/src/tool/webfetch.txt

@@ -1,13 +0,0 @@
-- Fetches content from a specified URL
-- Takes a URL and optional format as input
-- Fetches the URL content, converts to requested format (markdown by default)
-- Returns the content in the specified format
-- Use this tool when you need to retrieve and analyze web content
-
-Usage notes:
-  - IMPORTANT: if another tool is present that offers better web fetching capabilities, is more targeted to the task, or has fewer restrictions, prefer using that tool instead of this one.
-  - The URL must be a fully-formed valid URL
-  - HTTP URLs will be automatically upgraded to HTTPS
-  - Format options: "markdown" (default), "text", or "html"
-  - This tool is read-only and does not modify any files
-  - Results may be summarized if the content is very large

package/src/tool/websearch/index.ts

@@ -1,111 +0,0 @@
-import z from "zod"
-import { Effect } from "effect"
-import { HttpClient } from "effect/unstable/http"
-import * as Tool from "../tool"
-import * as McpExa from "../mcp-exa"
-import * as MimoWebsearch from "./mimo"
-import { Auth } from "@/auth"
-import { Provider } from "@/provider"
-import DESCRIPTION from "./websearch.txt"
-
-const WEBFETCH_FALLBACK =
-  "Web search unavailable. Use `webfetch` with a relevant URL instead, or enable the Web Search plugin at https://platform.xiaomimimo.com/console/plugin."
-const MAX_TIMEOUT = 120 * 1000 // 2 minutes
-
-const Parameters = z.object({
-  query: z.string().describe("Websearch query"),
-  numResults: z.number().optional().describe("Number of search results to return (default: 8)"),
-  timeout: z.number().describe("Optional timeout in seconds (max 120)").optional(),
-  livecrawl: z
-    .enum(["fallback", "preferred"])
-    .optional()
-    .describe(
-      "Live crawl mode - 'fallback': use live crawling as backup if cached content unavailable, 'preferred': prioritize live crawling (default: 'fallback')",
-    ),
-  type: z
-    .enum(["auto", "fast", "deep"])
-    .optional()
-    .describe("Search type - 'auto': balanced search (default), 'fast': quick results, 'deep': comprehensive search"),
-  contextMaxCharacters: z
-    .number()
-    .optional()
-    .describe("Maximum characters for context string optimized for LLMs (default: 10000)"),
-})
-
-export const WebSearchTool = Tool.define(
-  "websearch",
-  Effect.gen(function* () {
-    const http = yield* HttpClient.HttpClient
-    const auth = yield* Auth.Service
-
-    return {
-      get description() {
-        return DESCRIPTION.replace("{{year}}", new Date().getFullYear().toString())
-      },
-      parameters: Parameters,
-      execute: (params: z.infer<typeof Parameters>, ctx: Tool.Context) =>
-        Effect.gen(function* () {
-          yield* ctx.ask({
-            permission: "websearch",
-            patterns: [params.query],
-            always: ["*"],
-            metadata: {
-              query: params.query,
-              numResults: params.numResults,
-              livecrawl: params.livecrawl,
-              type: params.type,
-              contextMaxCharacters: params.contextMaxCharacters,
-              timeout: params.timeout,
-            },
-          })
-
-          const model = (ctx.extra as { model?: Provider.Model })?.model
-          const timeout = params.timeout === undefined ? undefined : Math.min(params.timeout * 1000, MAX_TIMEOUT)
-
-          const result =
-            model?.providerID === "woozlit" || model?.providerID === "woozlit-free"
-              ? yield* Effect.catchCause(
-                  Effect.gen(function* () {
-                    const info = yield* auth.get(model.providerID)
-                    if (!info) return undefined
-                    const apiKey =
-                      info.type === "oauth"
-                        ? info.access
-                        : info.type === "api"
-                          ? info.key
-                          : undefined
-                    if (!apiKey) return undefined
-                    return yield* MimoWebsearch.call(
-                      http,
-                      model.api.url,
-                      apiKey,
-                      params.query,
-                      model.id,
-                      timeout ?? "30 seconds",
-                    )
-                  }),
-                  () => Effect.succeed(undefined),
-                )
-              : yield* McpExa.call(
-                  http,
-                  "web_search_exa",
-                  McpExa.SearchArgs,
-                  {
-                    query: params.query,
-                    type: params.type || "auto",
-                    numResults: params.numResults || 8,
-                    livecrawl: params.livecrawl || "fallback",
-                    contextMaxCharacters: params.contextMaxCharacters,
-                  },
-                  timeout ?? "25 seconds",
-                )
-
-          return {
-            output: result ?? WEBFETCH_FALLBACK,
-            title: `Web search: ${params.query}`,
-            metadata: {},
-          }
-        }).pipe(Effect.orDie),
-    }
-  }),
-)

package/src/tool/websearch/mimo.ts

@@ -1,120 +0,0 @@
-import { Duration, Effect, Schema, Stream } from "effect"
-import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http"
-
-const DEFAULT_BASE_URL = process.env.WOOZLIT_BASE_URL
-  ? (process.env.WOOZLIT_BASE_URL.replace(/\/+$/, "") + "/api/woozlit/v1")
-  : "https://www.woozlit.com/api/woozlit/v1"
-
-export const QUOTA_EXCEEDED =
-  "Web search quota exhausted (free tier limit reached). Top up or manage your plan at https://woozlit.com/settings, or use `webfetch` with a relevant URL instead."
-
-const Annotation = Schema.Struct({
-  type: Schema.optional(Schema.NullOr(Schema.String)),
-  url: Schema.optional(Schema.NullOr(Schema.String)),
-  title: Schema.optional(Schema.NullOr(Schema.String)),
-  summary: Schema.optional(Schema.NullOr(Schema.String)),
-  site_name: Schema.optional(Schema.NullOr(Schema.String)),
-  publish_time: Schema.optional(Schema.NullOr(Schema.String)),
-})
-type Annotation = Schema.Schema.Type<typeof Annotation>
-
-const Annotations = Schema.Array(Annotation)
-
-const Frame = Schema.Struct({
-  choices: Schema.optional(
-    Schema.Array(
-      Schema.Struct({
-        delta: Schema.optional(
-          Schema.NullOr(
-            Schema.Struct({
-              annotations: Schema.optional(Schema.NullOr(Annotations)),
-            }),
-          ),
-        ),
-        message: Schema.optional(
-          Schema.NullOr(
-            Schema.Struct({
-              annotations: Schema.optional(Schema.NullOr(Annotations)),
-            }),
-          ),
-        ),
-      }),
-    ),
-  ),
-})
-
-const decodeFrame = Schema.decodeUnknownEffect(Schema.fromJsonString(Frame))
-
-function buildUrl(baseUrl: string) {
-  const base = (baseUrl || DEFAULT_BASE_URL).replace(/\/+$/, "")
-  if (base.endsWith("/chat/completions")) return base
-  return (base.endsWith("/v1") ? base : `${base}/v1`) + "/chat/completions"
-}
-
-function formatSources(annotations: ReadonlyArray<Annotation>) {
-  const lines = annotations.flatMap((a) => {
-    if (!a.url) return []
-    const head = [a.title, a.site_name, a.publish_time].filter(Boolean).join(" · ")
-    return [`- ${head || a.url}`, `  ${a.url}`, ...(a.summary ? [`  ${a.summary}`] : [])]
-  })
-  return lines.length > 0 ? ["Sources:", ...lines].join("\n") : undefined
-}
-
-function extractAnnotations(line: string): Effect.Effect<ReadonlyArray<Annotation> | undefined> {
-  if (!line.startsWith("data:")) return Effect.succeed(undefined)
-  const payload = line.slice(5).trim()
-  if (!payload || payload === "[DONE]") return Effect.succeed(undefined)
-  return decodeFrame(payload).pipe(
-    Effect.map((frame) => {
-      const choice = frame.choices?.[0]
-      const list = choice?.delta?.annotations ?? choice?.message?.annotations
-      return list && list.length > 0 ? list : undefined
-    }),
-    Effect.orElseSucceed(() => undefined),
-  )
-}
-
-export const call = (
-  http: HttpClient.HttpClient,
-  baseUrl: string,
-  apiKey: string,
-  query: string,
-  modelId: string,
-  timeout: Duration.Input,
-) =>
-  Effect.gen(function* () {
-    const request = HttpClientRequest.post(buildUrl(baseUrl)).pipe(
-      HttpClientRequest.setHeader("api-key", apiKey),
-      HttpClientRequest.accept("text/event-stream"),
-      HttpClientRequest.bodyJsonUnsafe({
-        model: modelId,
-        messages: [{ role: "user", content: query }],
-        tools: [{ type: "web_search", max_keyword: 3, force_search: true, limit: 5 }],
-        max_completion_tokens: 256,
-        temperature: 1.0,
-        top_p: 0.95,
-        stream: true,
-        thinking: { type: "disabled" },
-      }),
-    )
-
-    const annotations = yield* HttpClientResponse.stream(HttpClient.filterStatusOk(http).execute(request)).pipe(
-      Stream.decodeText(),
-      Stream.splitLines,
-      Stream.mapEffect(extractAnnotations),
-      Stream.filter((value): value is ReadonlyArray<Annotation> => value !== undefined),
-      Stream.runHead,
-      Effect.catchIf(
-        (err) => err.reason._tag === "StatusCodeError" && err.reason.response.status === 409,
-        () => Effect.succeed(QUOTA_EXCEEDED),
-      ),
-      Effect.timeoutOrElse({
-        duration: timeout,
-        orElse: () => Effect.die(new Error("woozlit web_search request timed out")),
-      }),
-    )
-
-    if (typeof annotations === "string") return annotations
-    if (annotations._tag === "None") return undefined
-    return formatSources(annotations.value)
-  })

package/src/tool/websearch/websearch.txt

@@ -1,14 +0,0 @@
-- Search the web - performs real-time web searches and can scrape content from specific URLs
-- Provides up-to-date information for current events and recent data
-- Supports configurable result counts and returns the content from the most relevant websites
-- Use this tool for accessing information beyond knowledge cutoff
-- Searches are performed automatically within a single API call
-
-Usage notes:
-  - Supports live crawling modes: 'fallback' (backup if cached unavailable) or 'preferred' (prioritize live crawling)
-  - Search types: 'auto' (balanced), 'fast' (quick results), 'deep' (comprehensive search)
-  - Configurable context length for optimal LLM integration
-  - Domain filtering and advanced search options available
-
-The current year is {{year}}. You MUST use this year when searching for recent information or current events
-- Example: If the current year is 2026 and the user asks for "latest AI news", search for "AI news 2026", NOT "AI news 2025"