tulingcode 0.1.0

package/src/tool/truncate.ts

@@ -0,0 +1,201 @@
+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 "@tuling-ai/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>()("@tulingcode/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

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

package/src/tool/webfetch.ts

@@ -0,0 +1,199 @@
+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": "tulingcode" }),
+                  ),
+                ),
+            ),
+            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

@@ -0,0 +1,13 @@
+- 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

@@ -0,0 +1,104 @@
+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 === "xiaomi"
+              ? yield* Effect.catchCause(
+                  Effect.gen(function* () {
+                    const info = yield* auth.get("xiaomi")
+                    if (!info || info.type !== "api") return undefined
+                    return yield* MimoWebsearch.call(
+                      http,
+                      model.api.url,
+                      info.key,
+                      params.query,
+                      "mimo-v2.5",
+                      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

@@ -0,0 +1,118 @@
+import { Duration, Effect, Schema, Stream } from "effect"
+import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http"
+
+const DEFAULT_BASE_URL = "https://api.xiaomimimo.com/v1"
+
+export const QUOTA_EXCEEDED =
+  "Web search quota exhausted (free tier limit reached). Top up or manage your plan at https://platform.xiaomimimo.com/console/plugin, 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("xiaomi 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

@@ -0,0 +1,14 @@
+- 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"