thincoder 0.9.0 → 0.11.0

package/src/provider/google.mjs

@@ -0,0 +1,197 @@
+/**
+ * provider/google.mjs — Google Gemini API transport
+ * Endpoint: POST https://generativelanguage.googleapis.com/v1beta/models/{model}:streamGenerateContent
+ * Docs: https://ai.google.dev/gemini-api/docs
+ */
+
+import { proxyFetch } from "../proxy.mjs"
+
+/** Convert OpenAI-format tools to Gemini format */
+export function normalizeTools(tools) {
+  if (!tools?.length) return null
+  return [{
+    functionDeclarations: tools.map((t) => ({
+      name: t.function.name,
+      description: t.function.description || "",
+      parameters: t.function.parameters || { type: "object", properties: {} },
+    })),
+  }]
+}
+
+/**
+ * Convert OpenAI-format messages to Gemini contents array.
+ * Gemini: [{ role: "user"|"model", parts: [{ text }] }]
+ * system → systemInstruction (top-level in request body)
+ */
+function convertMessages(messages) {
+  const contents = []
+  for (const m of messages) {
+    const role = m.role === "assistant" ? "model" : "user"
+    if (role === "system") continue
+
+    const parts = []
+    if (typeof m.content === "string") {
+      parts.push({ text: m.content })
+    } else if (Array.isArray(m.content)) {
+      for (const part of m.content) {
+        if (part.type === "text") parts.push({ text: part.text })
+        else if (part.type === "image_url") {
+          const url = part.image_url?.url || ""
+          const mimeMatch = url.match(/^data:([^;]+);base64,(.+)$/)
+          if (mimeMatch) {
+            parts.push({ inlineData: { mimeType: mimeMatch[1], data: mimeMatch[2] } })
+          }
+        }
+      }
+    }
+    if (parts.length === 0) continue
+
+    // Gemini doesn't allow consecutive same-role messages; merge
+    const last = contents[contents.length - 1]
+    if (last?.role === role) {
+      last.parts.push(...parts)
+    } else {
+      contents.push({ role, parts })
+    }
+  }
+  return contents
+}
+
+/** Build and send a Gemini chat request. Returns the same shape as core.mjs chat. */
+export async function chat(provider, { messages, tools, onToken, onReasoning, signal }) {
+  const systemMessages = messages.filter((m) => m.role === "system")
+  const contents = convertMessages(messages)
+
+  const body = {
+    contents,
+    generationConfig: {
+      ...(provider.temperature != null ? { temperature: provider.temperature } : {}),
+      ...(provider.maxTokens ? { maxOutputTokens: provider.maxTokens } : {}),
+    },
+    safetySettings: [
+      { category: "HARM_CATEGORY_HARASSMENT", threshold: "BLOCK_NONE" },
+      { category: "HARM_CATEGORY_HATE_SPEECH", threshold: "BLOCK_NONE" },
+      { category: "HARM_CATEGORY_SEXUALLY_EXPLICIT", threshold: "BLOCK_NONE" },
+      { category: "HARM_CATEGORY_DANGEROUS_CONTENT", threshold: "BLOCK_NONE" },
+    ],
+  }
+  if (systemMessages.length > 0) {
+    body.systemInstruction = {
+      parts: [{ text: systemMessages.map((m) => m.content).join("\n\n") }],
+    }
+  }
+  if (tools?.length) body.tools = tools
+
+  const FETCH_TIMEOUT_MS = 600_000
+  // Gemini uses API key as query parameter
+  const url = `${provider.baseURL}/models/${provider.model}:streamGenerateContent?alt=sse&key=${encodeURIComponent(provider.apiKey)}`
+
+  if (signal?.aborted) throw Object.assign(new DOMException("Aborted", "AbortError"), { reason: signal.reason })
+
+  const response = await proxyFetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body),
+    signal: signal
+      ? AbortSignal.any([signal, AbortSignal.timeout(FETCH_TIMEOUT_MS)])
+      : AbortSignal.timeout(FETCH_TIMEOUT_MS),
+  }, provider.proxyUri)
+
+  if (!response.ok) {
+    const text = await response.text().catch(() => "")
+    throw new Error(`Gemini API error ${response.status}: ${text}`)
+  }
+
+  const result = await parseGeminiStream(response, { onToken, onReasoning, signal })
+
+  const usage = result.usage
+  if (usage) {
+    return {
+      content: result.content,
+      reasoning: result.reasoning,
+      usage: {
+        prompt_tokens: usage.prompt_tokens ?? 0,
+        completion_tokens: usage.completion_tokens ?? 0,
+        total_tokens: usage.total_tokens ?? 0,
+      },
+      toolCalls: result.toolCalls,
+    }
+  }
+
+  return { content: result.content, reasoning: result.reasoning, toolCalls: result.toolCalls }
+}
+
+/**
+ * Parse Gemini SSE stream.
+ * Format: data: {...}\n\n (each line is a complete JSON object)
+ */
+async function parseGeminiStream(response, { onToken, onReasoning, signal }) {
+  const result = { content: "", reasoning: "", toolCalls: [], usage: null }
+  const decoder = new TextDecoder()
+  let buffer = ""
+
+  const processData = (data) => {
+    let json
+    try { json = JSON.parse(data) } catch { return }
+    if (!json) return
+
+    if (json.usageMetadata) {
+      result.usage = {
+        prompt_tokens: json.usageMetadata.promptTokenCount || 0,
+        completion_tokens: json.usageMetadata.candidatesTokenCount || 0,
+        total_tokens: json.usageMetadata.totalTokenCount || 0,
+      }
+    }
+
+    const candidate = json.candidates?.[0]
+    if (!candidate) return
+
+    const parts = candidate.content?.parts || []
+    for (const part of parts) {
+      if (part.thought === true && part.text) {
+        result.reasoning += part.text
+        onReasoning?.(part.text)
+      } else if (part.text) {
+        result.content += part.text
+        onToken?.(part.text)
+      } else if (part.functionCall) {
+        const existing = result.toolCalls.find((tc) => tc.name === part.functionCall.name)
+        if (!existing) {
+          result.toolCalls.push({
+            id: part.functionCall.name + "_" + result.toolCalls.length,
+            name: part.functionCall.name,
+            arguments: JSON.stringify(part.functionCall.args || {}),
+          })
+        }
+      }
+    }
+  }
+
+  if (!response.body) throw new Error("No stream response body")
+  for await (const chunk of response.body) {
+    if (signal?.aborted) {
+      const e = new DOMException("Aborted", "AbortError")
+      e.reason = signal.reason
+      throw e
+    }
+    buffer += decoder.decode(chunk, { stream: true })
+    const lines = buffer.split("\n")
+    buffer = lines.pop()
+
+    for (const line of lines) {
+      if (!line.startsWith("data:")) continue
+      const data = line.slice(5).trim()
+      if (!data || data === "[DONE]") continue
+      processData(data)
+    }
+  }
+  buffer += decoder.decode()
+  for (const line of buffer.split("\n")) {
+    if (!line.startsWith("data:")) continue
+    const data = line.slice(5).trim()
+    if (!data || data === "[DONE]") continue
+    processData(data)
+  }
+
+  return result
+}

package/src/proxy.mjs

@@ -0,0 +1,236 @@
+/**
+ * proxy.mjs — Shared proxy tunnel for websearch, fetch, and provider calls.
+ * Zero dependencies: Node built-ins only (net, tls, http, url).
+ */
+import { connect } from "node:net";
+import { connect as tlsConnect } from "node:tls";
+import { PassThrough } from "node:stream";
+import { URL } from "node:url";
+
+const FETCH_TIMEOUT = 15_000
+
+/**
+ * Resolve proxy URI.
+ * New format: { proxy: { uri: "http://host:port", web: true, model: false } }
+ * Old format: { proxy: "http://host:port" } — backwards compatible, web=true model=false
+ * Env vars: HTTPS_PROXY, HTTP_PROXY, ALL_PROXY
+ *
+ * @returns {{ uri: string|null, web: boolean, model: boolean }}
+ */
+export function resolveProxyConfig(ctx) {
+  const cfgProxy = ctx?.agent?.config?.proxy
+  if (!cfgProxy) {
+    const uri = process.env.HTTPS_PROXY || process.env.HTTP_PROXY || process.env.ALL_PROXY || null
+    return { uri, web: !!uri, model: false }
+  }
+  if (typeof cfgProxy === "string") {
+    // Backward compat: bare string → web only
+    return { uri: cfgProxy, web: true, model: false }
+  }
+  return {
+    uri: cfgProxy.uri || cfgProxy.url || null,
+    web: cfgProxy.web !== false,
+    model: cfgProxy.model === true,
+  }
+}
+
+/** Convenience: resolve proxy URI for web tools (websearch/fetch) */
+export function resolveWebProxy(ctx) {
+  const cfg = resolveProxyConfig(ctx)
+  return (cfg.uri && cfg.web) ? cfg.uri : null
+}
+
+/**
+ * Inject the resolved proxy URI into each provider as provider.proxyUri
+ * (consumed by chat() in provider/core.mjs).
+ * Model 请求走代理需要双重开启：per-provider `proxy: true` 且全局 `config.proxy.model === true`（默认关）。
+ */
+export function injectProxy(providers, config) {
+  const { uri, model } = resolveProxyConfig({ agent: { config } })
+  for (const p of providers ?? []) {
+    p.proxyUri = p.proxy && model ? (uri ?? undefined) : undefined
+  }
+}
+
+function abortError(signal) {
+  const e = new DOMException("The operation was aborted", "AbortError")
+  e.reason = signal?.reason
+  return e
+}
+
+/**
+ * 在已建立的 socket 上发 HTTP 请求，响应头到齐即 resolve（流式）。
+ * 返回 Response-like: { ok, status, headers: Headers, body: PassThrough(异步迭代), text(): Promise<string> }
+ * body 边收边吐（SSE 流式消费方可逐 chunk 读取）；text() 消费流到底（非流式调用方用）。
+ * opts.signal 全程有效：abort 即 destroy socket 并 reject/终止流。
+ * absoluteForm: 请求行发绝对 URI（http:// 目标的经典代理转发用），默认发 origin-form。
+ * 导出供测试（裸 socket，无需 TLS/CONNECT）；生产路径走 tunnelHttps / proxyFetch。
+ */
+export function streamHttpResponse(sock, urlStr, opts = {}, timeout = FETCH_TIMEOUT, absoluteForm = false) {
+  return new Promise((resolve, reject) => {
+    const target = new URL(urlStr)
+    const method = opts.method ?? "GET"
+    const headers = opts.headers ?? {}
+    const signal = opts.signal
+
+    if (signal?.aborted) { sock.destroy(); return reject(abortError(signal)) }
+
+    const body = new PassThrough()
+    let settled = false
+    let headerBuf = ""
+
+    const timer = setTimeout(() => fail(new Error("Response timeout")), timeout)
+    const onAbort = () => { sock.destroy(); fail(abortError(signal)) }
+    signal?.addEventListener("abort", onAbort, { once: true })
+
+    function cleanup() {
+      clearTimeout(timer)
+      signal?.removeEventListener("abort", onAbort)
+    }
+    /** 头部阶段失败 reject；resolve 后失败则终止 body 流（for-await 抛出，不挂起） */
+    function fail(err) {
+      cleanup()
+      if (!settled) { settled = true; reject(err) }
+      else body.destroy(err)
+    }
+
+    sock.on("data", (d) => {
+      if (settled) return // 理论上不会发生（settle 后摘掉本监听器），防御
+      headerBuf += d.toString("utf8")
+      const idx = headerBuf.indexOf("\r\n\r\n")
+      if (idx < 0) return
+
+      const headerText = headerBuf.slice(0, idx)
+      const statusMatch = headerText.match(/^HTTP\/\d\.\d (\d+)/)
+      const status = statusMatch ? Number(statusMatch[1]) : 502
+      const respHeaders = {}
+      for (const line of headerText.split("\r\n").slice(1)) {
+        const ci = line.indexOf(":")
+        if (ci > 0) respHeaders[line.slice(0, ci).trim().toLowerCase()] = line.slice(ci + 1).trim()
+      }
+
+      // 头到齐：摘掉头阶段监听，剩余字节推入 body，后续数据直接 pipe
+      sock.removeAllListeners("data")
+      settled = true
+      cleanup()
+      const remaining = headerBuf.slice(idx + 4)
+      if (remaining) body.write(Buffer.from(remaining, "utf8"))
+      sock.pipe(body)
+      // body 结束后才移除 abort 监听（流式中途 abort 要能终止流）
+      body.on("close", () => signal?.removeEventListener("abort", onAbort))
+      signal?.addEventListener("abort", onAbort, { once: true })
+
+      resolve({
+        ok: status >= 200 && status < 400,
+        status,
+        headers: new Headers(respHeaders),
+        body,
+        text: async () => {
+          const chunks = []
+          for await (const c of body) chunks.push(c)
+          return Buffer.concat(chunks).toString("utf8")
+        },
+      })
+    })
+    sock.on("close", () => {
+      if (!settled) fail(new Error("Connection closed before response"))
+      else body.end()
+    })
+    // 头部阶段的传输错误统一包装为稳定契约（对端 RST 会抛原生 ECONNRESET，调用方难判别）；
+    // resolve 后的 body 阶段保留原始错误终止流
+    sock.on("error", (e) => {
+      if (!settled) fail(new Error(`Connection closed before response (${e.code ?? e.message})`))
+      else fail(e)
+    })
+
+    // 写请求（absoluteForm：代理转发时请求行为绝对 URI）
+    const requestTarget = absoluteForm ? urlStr : `${target.pathname}${target.search}`
+    const lines = [`${method} ${requestTarget} HTTP/1.1`]
+    for (const [k, v] of Object.entries({ ...headers, Host: target.hostname })) lines.push(`${k}: ${v}`)
+    lines.push("Connection: close", "", "")
+    sock.write(lines.join("\r\n"))
+    if (opts.body) sock.write(opts.body)
+  })
+}
+
+/**
+ * HTTPS request through HTTP CONNECT proxy tunnel.
+ * CONNECT + TLS 建立后交给 streamHttpResponse — 响应头到齐即 resolve，body 为流式。
+ */
+export function tunnelHttps(urlStr, opts, proxyUri, timeout = FETCH_TIMEOUT) {
+  return new Promise((resolve, reject) => {
+    const target = new URL(urlStr)
+    const proxy = new URL(proxyUri)
+    const signal = opts?.signal
+
+    if (signal?.aborted) return reject(abortError(signal))
+
+    const sock = connect({ host: proxy.hostname, port: Number(proxy.port) || 3128 })
+    const timer = setTimeout(() => { sock.destroy(); reject(new Error("Proxy CONNECT timeout")) }, timeout)
+    const onAbort = () => { sock.destroy(); reject(abortError(signal)) }
+    signal?.addEventListener("abort", onAbort, { once: true })
+    sock.on("connect", () => sock.write(`CONNECT ${target.hostname}:${target.port || 443} HTTP/1.1\r\nHost: ${target.hostname}\r\n\r\n`))
+
+    let buf = ""
+    sock.on("data", d => {
+      buf += d.toString()
+      const end = buf.indexOf("\r\n\r\n")
+      if (end < 0) return
+      const statusLine = buf.slice(0, end).split("\r\n")[0]
+      buf = buf.slice(end + 4)
+      if (!statusLine.includes("200")) { sock.destroy(); clearTimeout(timer); return reject(new Error(`Proxy CONNECT: ${statusLine}`)) }
+      sock.removeAllListeners("data"); clearTimeout(timer)
+
+      const tlsSock = tlsConnect({ socket: sock, servername: target.hostname, rejectUnauthorized: false, timeout })
+      if (buf) tlsSock.unshift(Buffer.from(buf))
+      tlsSock.on("secureConnect", () => {
+        // TLS 之后的请求/响应阶段：abort 交由 streamHttpResponse 接管
+        signal?.removeEventListener("abort", onAbort)
+        streamHttpResponse(tlsSock, urlStr, opts, timeout).then(resolve, reject)
+      })
+      tlsSock.on("error", e => { sock.destroy(); reject(e) })
+    })
+    sock.on("error", e => { clearTimeout(timer); reject(new Error(`Proxy CONNECT failed (${e.code ?? e.message})`)) })
+    // 代理干净 FIN 关闭（无 error）时也要 reject，不能卡满超时
+    sock.on("close", () => { clearTimeout(timer); reject(new Error("Proxy connection closed before tunnel established")) })
+  })
+}
+
+/** TCP 直连代理（http:// 目标的经典转发用）：超时/abort/对端关闭都有稳定 reject */
+function tcpConnectProxy(proxyUri, signal, timeout) {
+  return new Promise((resolve, reject) => {
+    const proxy = new URL(proxyUri)
+    const sock = connect({ host: proxy.hostname, port: Number(proxy.port) || 3128 })
+    if (signal?.aborted) { sock.destroy(); return reject(abortError(signal)) }
+    const onAbort = () => sock.destroy()
+    signal?.addEventListener("abort", onAbort, { once: true })
+    const timer = setTimeout(() => { sock.destroy(); reject(new Error("Proxy CONNECT timeout")) }, timeout)
+    const onError = (e) => { clearTimeout(timer); reject(new Error(`Proxy CONNECT failed (${e.code ?? e.message})`)) }
+    const onClose = () => {
+      clearTimeout(timer)
+      reject(signal?.aborted ? abortError(signal) : new Error("Proxy connection closed before tunnel established"))
+    }
+    sock.once("connect", () => {
+      clearTimeout(timer)
+      signal?.removeEventListener("abort", onAbort)
+      sock.removeListener("error", onError)
+      sock.removeListener("close", onClose)
+      resolve(sock)
+    })
+    sock.once("error", onError)
+    sock.once("close", onClose)
+  })
+}
+
+/**
+ * Generic fetch with proxy support.
+ * No proxy → native fetch. Proxy + HTTPS → CONNECT tunnel. Proxy + HTTP → 经典代理转发（绝对 URI 请求行）。
+ */
+export async function proxyFetch(urlStr, opts, proxyUri) {
+  if (!proxyUri) return globalThis.fetch(urlStr, opts)
+  const target = new URL(urlStr)
+  if (target.protocol === "https:") return tunnelHttps(urlStr, opts, proxyUri)
+  // http:// 目标：TCP 直连代理，请求行发绝对 URI（GET http://host/path HTTP/1.1）
+  const sock = await tcpConnectProxy(proxyUri, opts?.signal, FETCH_TIMEOUT)
+  return streamHttpResponse(sock, urlStr, opts, FETCH_TIMEOUT, true)
+}

package/src/tools/codemode.mjs

@@ -0,0 +1,178 @@
+/**
+ * tools/codemode.mjs — CodeMode: sandboxed JS execution tool
+ *
+ * Gives the model an `execute` tool backed by Node.js vm.Script.runInNewContext.
+ * Multiple tool calls can be composed into a single script, reducing API round-trips
+ * and keeping large intermediate results out of context.
+ *
+ * Sandbox API (all sync, no callbacks):
+ *   readFile(path)      — read a file relative to cwd, return string
+ *   writeFile(path, c)  — write content to a file (auto-creates parent dirs)
+ *   glob(pattern)        — return array of matching paths
+ *   grep(pattern, file)  — return array of matching lines
+ *   log(...args)         — append to output buffer
+ *   fetch(url)           — HTTP GET, return string (SSRF-protected)
+ *
+ * Not available: require, import, process, child_process, setTimeout, any Node API.
+ *
+ * Limits:
+ *   timeout: 30s (configurable via timeoutMs param)
+ *   maxOutput: 50000 bytes
+ *   maxScriptSize: 50000 bytes
+ */
+
+import { Script, createContext } from "node:vm"
+import { readFileSync, writeFileSync, existsSync, mkdirSync, statSync, readdirSync } from "node:fs"
+import { join, dirname, relative, resolve } from "node:path"
+import { globToRegex, normalizeEOL } from "./shared.mjs"
+
+const MAX_OUTPUT = 50_000
+const MAX_SCRIPT = 50_000
+const DEFAULT_TIMEOUT = 30_000
+
+/** SSRF-safe fetch: only http/https, private IP rejection, 10s timeout */
+async function sandboxFetch(url) {
+  const parsed = new URL(url)
+  if (!["http:", "https:"].includes(parsed.protocol)) {
+    throw new Error(`CodeMode fetch: protocol not allowed: ${parsed.protocol}`)
+  }
+  // Block private/internal IPs
+  const hostname = parsed.hostname.toLowerCase()
+  if (hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1" ||
+      hostname.startsWith("192.168.") || hostname.startsWith("10.") ||
+      hostname.startsWith("172.16.") || hostname.startsWith("172.17.") ||
+      hostname.startsWith("172.18.") || hostname.startsWith("172.19.") ||
+      hostname.startsWith("172.20.") || hostname.startsWith("172.21.") ||
+      hostname.startsWith("172.22.") || hostname.startsWith("172.23.") ||
+      hostname.startsWith("172.24.") || hostname.startsWith("172.25.") ||
+      hostname.startsWith("172.26.") || hostname.startsWith("172.27.") ||
+      hostname.startsWith("172.28.") || hostname.startsWith("172.29.") ||
+      hostname.startsWith("172.30.") || hostname.startsWith("172.31.") ||
+      hostname === "0.0.0.0" || hostname.endsWith(".local")) {
+    throw new Error(`CodeMode fetch: private/internal host not allowed: ${hostname}`)
+  }
+  const ctrl = new AbortController()
+  const timer = setTimeout(() => ctrl.abort(), 10_000)
+  try {
+    const res = await fetch(url, { signal: ctrl.signal })
+    const text = await res.text()
+    return text.slice(0, 100_000)
+  } finally {
+    clearTimeout(timer)
+  }
+}
+
+export const codeModeTool = {
+  name: "execute",
+  description:
+    "Execute sandboxed JavaScript code. Use this to compose multiple file operations into one call — " +
+    "read, write, glob, grep, and log results. No network or system access. Max 30s timeout, 50KB output.",
+  parameters: {
+    type: "object",
+    properties: {
+      code: {
+        type: "string",
+        description: "JavaScript code to execute in the sandbox. Use provided functions: readFile(path), writeFile(path, content), glob(pattern), grep(pattern, file), log(...args).",
+      },
+      timeoutMs: {
+        type: "integer",
+        description: `Timeout in milliseconds (default ${DEFAULT_TIMEOUT}, max 60000)`,
+      },
+    },
+    required: ["code"],
+  },
+  readonly: false,
+
+  async execute(args, ctx) {
+    const cwd = ctx.cwd
+    const code = args.code ?? ""
+
+    if (code.length > MAX_SCRIPT) {
+      return `Error: script too large (${code.length} > ${MAX_SCRIPT} bytes). Split into smaller scripts or use individual tools.`
+    }
+
+    const output = []
+    const timeoutMs = Math.min(args.timeoutMs ?? DEFAULT_TIMEOUT, 60_000)
+
+    // File path guard: ensure paths are within cwd
+    function safePath(p) {
+      if (typeof p !== "string") throw new Error(`Path must be a string, got ${typeof p}`)
+      // Normalize and resolve
+      const abs = resolve(cwd, p)
+      // Check containment
+      const rel = relative(cwd, abs)
+      if (rel.startsWith("..") || (rel.includes("..") && process.platform === "win32")) {
+        throw new Error(`Path traversal denied: ${p}`)
+      }
+      return abs
+    }
+
+    const sandbox = createContext({
+      readFile: (p) => {
+        const abs = safePath(p)
+        if (!existsSync(abs)) throw new Error(`File not found: ${p}`)
+        const st = statSync(abs)
+        if (st.size > 5_000_000) throw new Error(`File too large: ${p} (${Math.round(st.size / 1000000)}MB)`)
+        return normalizeEOL(readFileSync(abs, "utf8"))
+      },
+      writeFile: (p, content) => {
+        const abs = safePath(p)
+        mkdirSync(dirname(abs), { recursive: true })
+        writeFileSync(abs, String(content), "utf8")
+      },
+      glob: (pattern) => {
+        if (typeof pattern !== "string") throw new Error("glob pattern must be a string")
+        const regex = globToRegex(pattern)
+        const results = []
+        function walk(dir, rel) {
+          let entries
+          try { entries = readdirSync(dir, { withFileTypes: true }) } catch { return }
+          for (const e of entries) {
+            if (e.name.startsWith(".") || e.name === "node_modules") continue
+            const relPath = rel ? `${rel}/${e.name}` : e.name
+            if (e.isDirectory()) { walk(join(dir, e.name), relPath) }
+            else if (regex.test(relPath)) results.push(relPath)
+          }
+        }
+        walk(cwd, "")
+        return results.slice(0, 200)
+      },
+      grep: (pattern, file) => {
+        if (typeof pattern !== "string") throw new Error("grep pattern must be a string")
+        if (typeof file !== "string") throw new Error("grep file must be a string")
+        const abs = safePath(file)
+        if (!existsSync(abs)) throw new Error(`File not found: ${file}`)
+        const content = normalizeEOL(readFileSync(abs, "utf8"))
+        const regex = new RegExp(pattern)
+        const lines = content.split("\n")
+        const matches = []
+        for (let i = 0; i < lines.length; i++) {
+          if (regex.test(lines[i])) matches.push(`${i + 1}: ${lines[i].slice(0, 200)}`)
+        }
+        return matches.slice(0, 100)
+      },
+      log: (...args) => {
+        const line = args.map((a) => typeof a === "object" ? JSON.stringify(a) : String(a)).join(" ")
+        output.push(line)
+        if (output.join("\n").length > MAX_OUTPUT) {
+          output.push("... (output truncated)")
+          throw new Error("CodeMode output limit exceeded")
+        }
+      },
+      fetch: sandboxFetch,
+    })
+
+    try {
+      const script = new Script(code, {
+        filename: "codemode.js",
+        timeout: timeoutMs,
+      })
+      script.runInContext(sandbox)
+      return output.join("\n") || "(no output)"
+    } catch (err) {
+      const out = output.join("\n")
+      const prefix = out ? `${out}\n\n` : ""
+      return `${prefix}Error: ${err.message}`
+    }
+  },
+}

package/src/tools/fetch.md

@@ -5,6 +5,7 @@ Parameters:
 
 Notes:
 - Follows redirects automatically
-- Timeout: 20 seconds
+- Timeout: 15 seconds
 - HTML pages are converted to plain text (scripts, styles, navigation stripped)
 - Non-HTML responses are returned as-is (truncated at ~50000 chars)
+- Proxy support: set `"proxy": {"uri": "http://host:port", "web": true}` in config.json or `HTTPS_PROXY` env var