@botconnector/bccli 0.4.0-beta.9 → 0.4.1

package/dist/agent.d.ts

@@ -0,0 +1,143 @@
+import type { PermissionRequest, Permissions } from './permissions';
+import { type ChatMessage, type Provider, type Usage } from './provider';
+import type { ReasoningLevel } from './reasoning';
+import { type HookEvent, type HooksConfig } from './hooks';
+import type { Tool } from './tools/types';
+import { type UsageCap } from './budget';
+export type AgentEvent = {
+    type: 'text';
+    delta: string;
+} | {
+    type: 'thinking';
+    delta: string;
+} | {
+    type: 'textReplace';
+    text: string;
+} | {
+    type: 'toolStart';
+    id: string;
+    tool: string;
+    target: string;
+} | {
+    type: 'toolEnd';
+    id: string;
+    tool: string;
+    output: string;
+    display?: string;
+    isError: boolean;
+} | {
+    type: 'usage';
+    inputTokens: number;
+    outputTokens: number;
+    cachedInputTokens?: number;
+    cacheWriteTokens?: number;
+} | {
+    type: 'compacted';
+} | {
+    type: 'stepLimit';
+    maxSteps: number;
+} | {
+    type: 'budgetExceeded';
+    kind: 'tokens' | 'usd';
+    used: number;
+    limit: number;
+} | {
+    type: 'aborted';
+} | {
+    type: 'error';
+    message: string;
+} | {
+    type: 'done';
+} | {
+    type: 'subagent';
+    parentId: string;
+    agent: string;
+    event: AgentEvent;
+};
+export type PermissionAnswer = 'yes' | 'session' | 'all' | 'no';
+export type PermissionAsk = PermissionRequest & {
+    preview?: string;
+    sessionRules?: string[];
+    agent?: string;
+};
+export type AskPermission = (req: PermissionAsk) => Promise<PermissionAnswer>;
+export interface AgentOptions {
+    provider: Provider;
+    tools: Tool[];
+    permissions: Permissions;
+    systemPrompt: string;
+    cwd: string;
+    history?: ChatMessage[];
+    maxSteps?: number | null;
+    contextWindow?: number;
+    onMessage?: (message: ChatMessage) => void;
+    onReset?: () => void;
+    /** Per-turn token usage delta (provider-reported or estimated); the session persists it for stats. */
+    onUsage?: (usage: Usage) => void;
+    /** Marks the start of a user turn (undo boundary). */
+    onTurnStart?: () => void;
+    checkpoint?: (absPath: string) => Promise<void>;
+    /** Subagent name, shown on its permission prompts. */
+    label?: string;
+    reasoning?: ReasoningLevel;
+    /** Tool/session hooks (global config only). */
+    hooks?: HooksConfig;
+    /** In-process plugin observers fired alongside the shell hooks (global config plugins). */
+    pluginEmit?: (event: HookEvent, payload?: {
+        tool?: string;
+        input?: unknown;
+        output?: string;
+    }) => Promise<void>;
+    /** Base environment handed to hook processes (defaults to the process env at spawn). */
+    env?: NodeJS.ProcessEnv;
+    /** Per-session token/USD budget (global config usageCap); blocks model calls once exceeded. */
+    usageCap?: UsageCap;
+    /** Model ref used to match usageCap.prices keys. */
+    budgetModel?: string;
+}
+export declare class Agent {
+    private readonly opts;
+    provider: Provider;
+    permissions: Permissions;
+    messages: ChatMessage[];
+    totalUsage: Usage;
+    lastInputTokens: number;
+    onEvent: (event: AgentEvent) => void;
+    reasoning: ReasoningLevel;
+    askPermission: AskPermission;
+    tools: Tool[];
+    private definitions;
+    private turnTools;
+    private turnDefinitions;
+    private readonly readFiles;
+    private readonly webBudget;
+    private readonly maxSteps?;
+    private contextWindow;
+    private systemPrompt;
+    constructor(opts: AgentOptions);
+    setSystemPrompt(text: string): void;
+    setContextWindow(window: number): void;
+    setTools(tools: Tool[]): void;
+    private isParallelSafe;
+    private push;
+    /** Swaps in another conversation (resume, new session) without writing to the session log. */
+    load(messages: ChatMessage[]): void;
+    clear(): void;
+    compact(signal: AbortSignal): Promise<void>;
+    /**
+     * Events of one tool execution. A cancelled turn gives up on a tool that does not stop, and whatever that tool
+     * reports later must not reach the screen or a newer turn, so this is per execution and not per call id (ids repeat).
+     */
+    private report;
+    run(text: string, signal: AbortSignal): Promise<void>;
+    /** Current cap status; undefined means the budget is not exhausted. */
+    private overBudget;
+    /** Every tool call needs an answer in the history, or the next request to the model is rejected. */
+    private cancelCalls;
+    /**
+     * Every tool call must resolve with text: a rejected one would leave the assistant tool_calls
+     * without answers, and the next request to the model would be rejected until a restart.
+     */
+    private runTool;
+    private executeTool;
+}

package/dist/agents.d.ts

@@ -0,0 +1,4 @@
+import type { AgentDef } from './extensions';
+export declare const EXPLORE_PROMPT = "You are a read-only research agent working for another agent. Search and read the codebase to answer the request. You cannot edit files or run commands. Reply with a concise report: the answer, the relevant file paths with line numbers, and nothing else.";
+export declare const GENERAL_PROMPT = "You are an agent handling a delegated task for another agent. Complete the task end to end with the tools you have, verify the result, and reply with a short report of what you did and what you found.";
+export declare const BUILTIN_AGENTS: AgentDef[];

package/dist/args-W6BNKY7K.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+import {
+  helpText,
+  parseCliArgs
+} from "./chunk-XV7ZVL4J.js";
+import "./chunk-MHIYLXJC.js";
+import "./chunk-BLOYFIAD.js";
+import "./chunk-FLQPE4S5.js";
+import "./chunk-UZWJQF67.js";
+export {
+  helpText,
+  parseCliArgs
+};

package/dist/args.d.ts

@@ -0,0 +1,51 @@
+import { type PermissionMode } from './config';
+import { type ReasoningLevel } from './reasoning';
+import { type Lang } from './i18n';
+export interface CliArgs {
+    command: 'run' | 'login' | 'models' | 'update' | 'acp' | 'serve' | 'plugins' | 'gh-bot' | 'provider' | 'mcp' | 'connect' | 'disconnect' | 'integrations' | 'completion' | 'stats' | 'export' | 'import' | 'pr';
+    subArgs: string[];
+    url?: string;
+    name?: string;
+    keyEnv?: string;
+    values: string[];
+    prompt?: string;
+    print: boolean;
+    model?: string;
+    reasoning?: ReasoningLevel;
+    lang?: Lang;
+    continue: boolean;
+    resume: boolean;
+    allowAll: boolean;
+    allowedTools: string[];
+    worktree?: string;
+    outputFormat?: 'text' | 'json' | 'stream-json';
+    permissionMode?: PermissionMode;
+    help: boolean;
+    version: boolean;
+    loginProvider?: string;
+    /** `bccli login` — pakai prompt API key lama, bukan OAuth. */
+    key: boolean;
+    /** `bccli login` — hapus credential tersimpan (hanya openrouter via OAuth path). */
+    logout: boolean;
+    /** `bccli serve` listener port (0 = ephemeral). */
+    port?: number;
+    /** `bccli serve` bind address — loopback only. */
+    host?: string;
+    /** `bccli serve` bearer token override. */
+    token?: string;
+    /** Base URL override for `bccli mcp serve`. */
+    baseUrl?: string;
+    /** `bccli stats` — only count sessions from the last N days (default 7). */
+    days?: number;
+    /** `bccli stats` - cap the tool-usage list to the top N tools. */
+    tools?: number;
+    /** `bccli stats [--models [N|all]]` - show per-model token usage (top N or all). */
+    models?: string;
+    /** `bccli stats --project <slug>` - filter rows; empty string = current project. */
+    project?: string;
+    /** `bccli pr` — explicit owner/name repo when cwd is not a git checkout of the PR. */
+    repo?: string;
+}
+/** Help text in the current language (call it after the language is set). */
+export declare const helpText: () => string;
+export declare function parseCliArgs(argv: string[]): CliArgs;

package/dist/budget.d.ts

@@ -0,0 +1,23 @@
+export interface UsageCap {
+    /** Total tokens (input + output) per session. */
+    tokens?: number;
+    /** Total USD per session; requires `prices`. */
+    usd?: number;
+    /** USD per 1M tokens, keyed by a substring of the model ref (first match wins). */
+    prices?: Record<string, {
+        input: number;
+        output: number;
+    }>;
+}
+export declare function priceFor(cap: UsageCap, model: string): {
+    input: number;
+    output: number;
+} | undefined;
+export declare function budgetStatus(usage: {
+    inputTokens: number;
+    outputTokens: number;
+}, cap: UsageCap | undefined, model: string): {
+    kind: 'tokens' | 'usd';
+    used: number;
+    limit: number;
+} | undefined;

package/dist/checkpoints.d.ts

@@ -0,0 +1,34 @@
+interface UndoResult {
+    restored: string[];
+    deleted: string[];
+    skipped: string[];
+    failed: string[];
+}
+export declare class CheckpointStore {
+    private readonly history;
+    private current;
+    private pendingRedo;
+    beginTurn(): void;
+    /** Call before writing a file; only the first snapshot per file per turn is kept. */
+    snapshot(path: string): Promise<void>;
+    turns(): number;
+    /** Total entries including empty ones; used to align file snapshots with conversation turns. */
+    entries(): number;
+    undo(): Promise<UndoResult | undefined>;
+    /**
+     * Revert every snapshot taken at or after the `keep`-th entry, newest first, so the files
+     * end in the state from before the turn that created entry `keep`. Used by /rewind, which
+     * pairs conversation turns with the entry count recorded when each turn started.
+     */
+    undoTo(keep: number): Promise<UndoResult | undefined>;
+    /**
+     * Re-apply the file state captured right before the last undo/undoTo.
+     * Only file edits are redone, never conversation history. Invalidated by
+     * any new snapshot turn or clear(), so redo can't resurrect stale content.
+     */
+    redo(): Promise<UndoResult | undefined>;
+    /** Records the on-disk state of a turn's paths so redo() can put it back. */
+    private captureFor;
+    clear(): void;
+}
+export {};

package/dist/{chunk-BFZXRKW5.js → chunk-24JN75FZ.js}

@@ -1,12 +1,34 @@
 #!/usr/bin/env node
 import {
-  ConfigError
-} from "./chunk-2MGINW4O.js";
+  ConfigError,
+  writeFileAtomic
+} from "./chunk-FLQPE4S5.js";
+import {
+  t
+} from "./chunk-UZWJQF67.js";
 
 // src/mcp/config.ts
 import { createHash } from "crypto";
-import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { existsSync, mkdirSync, readFileSync } from "fs";
 import { dirname, join, resolve } from "path";
+var ENV_REF = /\$\{([A-Za-z_][A-Za-z0-9_]*)(?::-([^}]*))?\}/g;
+function expandEnvVars(config, env) {
+  const expand = (value) => value.replace(ENV_REF, (match, name, fallback) => {
+    const resolved = env[name];
+    if (resolved !== void 0) return resolved;
+    return fallback !== void 0 ? fallback : match;
+  });
+  const expandMap = (map) => Object.fromEntries(Object.entries(map).map(([k, v]) => [k, expand(v)]));
+  if (config.type === "http") {
+    return { ...config, url: expand(config.url), ...config.headers ? { headers: expandMap(config.headers) } : {} };
+  }
+  return {
+    ...config,
+    command: expand(config.command),
+    ...config.args ? { args: config.args.map(expand) } : {},
+    ...config.env ? { env: expandMap(config.env) } : {}
+  };
+}
 var globalMcpPath = (home) => join(home, "mcp.json");
 var projectMcpPath = (cwd) => join(cwd, ".bccli", "mcp.json");
 var trustPath = (home) => join(home, "trusted-mcp.json");
@@ -15,14 +37,13 @@ function readJson(path, fallback) {
   try {
     return JSON.parse(readFileSync(path, "utf8"));
   } catch (error) {
-    throw new ConfigError(`File MCP tidak valid: ${path} (${error.message})`);
+    throw new ConfigError(t("Invalid MCP file: {path} ({error})", { path, error: error.message }));
   }
 }
 function writePrivate(path, data) {
   mkdirSync(dirname(path), { recursive: true });
-  writeFileSync(path, `${JSON.stringify(data, null, 2)}
-`, { mode: 384 });
-  chmodSync(path, 384);
+  writeFileAtomic(path, `${JSON.stringify(data, null, 2)}
+`, 384);
 }
 function readMcpFile(path) {
   return readJson(path, {}).mcpServers ?? {};
@@ -58,6 +79,7 @@ function serversToStart(home, cwd) {
 }
 
 export {
+  expandEnvVars,
   globalMcpPath,
   projectMcpPath,
   readMcpFile,

package/dist/chunk-45SDLMTV.js

@@ -0,0 +1,341 @@
+#!/usr/bin/env node
+import {
+  defineTool
+} from "./chunk-PSO7R5AD.js";
+import {
+  t
+} from "./chunk-UZWJQF67.js";
+
+// src/tools/websearch.ts
+import { z } from "zod";
+var clean = (items, max) => (Array.isArray(items) ? items : []).filter((r) => typeof r?.url === "string" && /^https?:\/\//.test(r.url)).slice(0, max).map((r) => ({
+  title: String(r.title || r.url).slice(0, 200),
+  url: r.url,
+  snippet: String(r.snippet || r.description || "").replace(/\s+/g, " ").trim().slice(0, 600)
+}));
+async function postJson(url, body, headers, signal) {
+  const res = await fetch(url, {
+    method: "POST",
+    headers: { "content-type": "application/json", ...headers },
+    body: JSON.stringify(body),
+    signal: AbortSignal.any([signal, AbortSignal.timeout(3e4)])
+  });
+  if (!res.ok) throw new Error(`HTTP ${res.status}`);
+  return res.json();
+}
+function createWebSearchTool(opts) {
+  const keenableURL = opts.keenableURL ?? "https://api.keenable.ai/v1/search/public";
+  return defineTool({
+    name: "web_search",
+    description: "Search the web. Returns titles, URLs and short snippets. Use it to find the right pages instead of guessing URLs; then fetch a result URL when you need the full page.",
+    schema: z.object({
+      query: z.string().min(1).max(500).describe("Search query"),
+      max_results: z.number().int().min(1).max(10).optional().describe("Number of results (default 6)")
+    }),
+    kind: "read",
+    target: (input) => input.query,
+    parallelSafe: () => true,
+    async run(input, ctx) {
+      const max = input.max_results ?? 6;
+      const errors = [];
+      let results = [];
+      const bc = opts.botconnector();
+      if (bc) {
+        try {
+          const data = await postJson(`${bc.baseURL.replace(/\/+$/, "")}/web/search`, { query: input.query, max_results: max }, { authorization: `Bearer ${bc.apiKey}` }, ctx.signal);
+          results = clean(data.results, max);
+        } catch (error) {
+          errors.push(`BotConnector: ${error.message}`);
+        }
+      }
+      if (!results.length) {
+        try {
+          const data = await postJson(keenableURL, { query: input.query }, { "x-keenable-title": "BotConnector" }, ctx.signal);
+          results = clean(data.results, max);
+        } catch (error) {
+          errors.push(`Keenable: ${error.message}`);
+        }
+      }
+      if (!results.length) {
+        return { output: errors.length ? `Web search failed (${errors.join("; ")}).` : "No results.", isError: errors.length > 0 };
+      }
+      const output = results.map((r, i) => `${i + 1}. ${r.title}
+   ${r.url}${r.snippet ? `
+   ${r.snippet}` : ""}`).join("\n");
+      return { output, display: t("{n} results", { n: results.length }) };
+    }
+  });
+}
+
+// src/tools/fetch.ts
+import { lookup as dnsCbLookup } from "dns";
+import { lookup as dnsLookup } from "dns/promises";
+import { isIP } from "net";
+import { Agent, fetch as undiciFetch } from "undici";
+import { z as z2 } from "zod";
+var MAX_CHARS = 12e3;
+var FOCUS_CHUNKS = 3;
+var FOCUS_SIZE = 800;
+var CACHE_MAX = 16;
+var CACHE_TTL_MS = 15 * 6e4;
+var CACHE_MAX_CHARS = 2e6;
+var MAX_BYTES = 5 * 1024 * 1024;
+async function readCapped(res) {
+  const reader = res.body?.getReader();
+  if (!reader) return { text: "", truncated: false };
+  const chunks = [];
+  let size = 0;
+  for (; ; ) {
+    const { done, value } = await reader.read();
+    if (done) return { text: Buffer.concat(chunks).toString("utf8"), truncated: false };
+    size += value.length;
+    if (size > MAX_BYTES) {
+      chunks.push(value.subarray(0, value.length - (size - MAX_BYTES)));
+      await reader.cancel();
+      return { text: Buffer.concat(chunks).toString("utf8"), truncated: true };
+    }
+    chunks.push(value);
+  }
+}
+function htmlToText(html) {
+  return html.replace(/<(script|style|noscript)[\s\S]*?<\/\1>/gi, "").replace(/<(br|\/p|\/div|\/h[1-6]|\/li|\/tr)\s*\/?>/gi, "\n").replace(/<[^>]+>/g, "").replace(/&nbsp;/g, " ").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&amp;/g, "&").split("\n").map((l) => l.replace(/\s+/g, " ").trim()).filter(Boolean).join("\n");
+}
+function describeFetchError(error) {
+  const cause = error.cause;
+  const code = cause?.code ?? "";
+  const detail = cause?.message ?? error.message;
+  if (error.name === "TimeoutError") return "no response within 30 seconds";
+  if (code === "ENOTFOUND" || code === "EAI_AGAIN") return `${detail} \u2014 DNS could not find the host (typo, offline, or blocked by DNS/ISP)`;
+  if (/CERT|SELF_SIGNED|UNABLE_TO/.test(code)) {
+    return `${detail} \u2014 TLS certificate rejected; often caused by an antivirus or proxy that inspects HTTPS. Try running with NODE_OPTIONS=--use-system-ca`;
+  }
+  if (/ECONNRESET|ECONNREFUSED|ETIMEDOUT|EHOSTUNREACH|ENETUNREACH|UND_ERR_CONNECT_TIMEOUT|UND_ERR_SOCKET/.test(code)) {
+    return `${detail} \u2014 connection failed (firewall, proxy, or the site is blocked by the network)`;
+  }
+  return code ? `${detail} (${code})` : detail;
+}
+var tokensOf = (text) => Math.ceil(text.length / 4);
+function isPrivateHost(host) {
+  const h = host.toLowerCase().replace(/^\[|\]$/g, "");
+  if (h === "localhost" || /\.(local|internal|lan|localdomain|home\.arpa)$/.test(h)) return true;
+  if (h.includes(":")) return /^(::1?$|f[cd]|fe[89ab]|::ffff:)/.test(h);
+  const v4 = h.match(/^(\d+)\.(\d+)\.\d+\.\d+$/);
+  if (v4) {
+    const [a, b] = [Number(v4[1]), Number(v4[2])];
+    return a === 0 || a === 10 || a === 127 || a === 169 && b === 254 || a === 172 && b >= 16 && b <= 31 || a === 192 && b === 168 || a === 100 && b >= 64 && b <= 127;
+  }
+  return !h.includes(".");
+}
+var words = (s) => s.toLowerCase().match(/[\p{L}\p{N}]{2,}/gu) ?? [];
+function pinLookup(pinned) {
+  return (hostname, options, callback) => {
+    const opts = typeof options === "object" && options !== null ? options : {};
+    const family = typeof options === "number" ? options : opts.family;
+    const realDns = () => dnsCbLookup(hostname, typeof options === "number" ? { family: options } : opts, callback);
+    if (!pinned.length) return realDns();
+    const list = family ? pinned.filter((a) => a.family === family) : pinned;
+    if (!list.length) {
+      callback(Object.assign(new Error(`no pinned address for family ${family}`), { code: "ENOTFOUND" }), "");
+      return;
+    }
+    if (opts.all) callback(null, list);
+    else callback(null, list[0].address, list[0].family);
+  };
+}
+function pickRelevant(text, query, count = FOCUS_CHUNKS, size = FOCUS_SIZE) {
+  const chunks = [];
+  let cur = "";
+  for (const line of text.split("\n")) {
+    for (let i = 0; i < Math.max(line.length, 1); i += size) {
+      cur += `${line.slice(i, i + size)}
+`;
+      if (cur.length >= size) {
+        chunks.push(cur.trimEnd());
+        cur = "";
+      }
+    }
+  }
+  if (cur.trim()) chunks.push(cur.trimEnd());
+  const q = [...new Set(words(query))];
+  const docs = chunks.map(words);
+  const avg = docs.reduce((n, d) => n + d.length, 0) / (docs.length || 1) || 1;
+  const idf = q.map((t2) => {
+    const df = docs.filter((d) => d.includes(t2)).length;
+    return Math.log(1 + (docs.length - df + 0.5) / (df + 0.5));
+  });
+  const scored = docs.map((d, i) => ({
+    i,
+    score: q.reduce((sum, t2, k) => {
+      const tf = d.filter((w) => w === t2).length;
+      return sum + idf[k] * tf * 2.2 / (tf + 1.2 * (0.25 + 0.75 * d.length / avg));
+    }, 0)
+  })).filter((c) => c.score > 0).sort((a, b) => b.score - a.score).slice(0, count).sort((a, b) => a.i - b.i);
+  return scored.length ? scored.map((c) => chunks[c.i]).join("\n\u2026\n") : null;
+}
+var cache = /* @__PURE__ */ new Map();
+function remember(key, value, size) {
+  if (size > CACHE_MAX_CHARS) return;
+  cache.delete(key);
+  cache.set(key, value);
+  if (cache.size > CACHE_MAX) cache.delete(cache.keys().next().value);
+}
+function recall(key) {
+  const hit = cache.get(key);
+  if (typeof hit === "object" && Date.now() - hit.at > CACHE_TTL_MS) {
+    cache.delete(key);
+    return void 0;
+  }
+  return hit;
+}
+var ACCEPT = "text/markdown, text/html;q=0.9, text/plain;q=0.8, */*;q=0.5";
+var withCost = (text, what) => `${what} \xB7 ${t("~{n} tokens", { n: tokensOf(text) })}`;
+function createFetchTool(opts = {}) {
+  const keenableURL = opts.keenableURL === void 0 ? "https://api.keenable.ai/v1/fetch/public" : opts.keenableURL;
+  const isPrivate = opts.isPrivate ?? isPrivateHost;
+  const lookup = opts.lookup ?? ((hostname) => dnsLookup(hostname, { all: true }));
+  return defineTool({
+    name: "fetch",
+    description: `Fetch a URL (http/https) as text/markdown. Costs the user tokens, so ask for as little as you need:
+- Pass \`prompt\` (what you want to know from the page) to get only the relevant excerpt instead of the whole page. Prefer this whenever you are looking for specific facts.
+- Without \`prompt\` you get the first ${MAX_CHARS} characters; the reply tells you the \`offset\` to continue from.
+- Fetching a page that is already in this conversation is wasteful; reuse what you have.`,
+    schema: z2.object({
+      url: z2.string().describe("Absolute http(s) URL"),
+      prompt: z2.string().max(2e3).optional().describe("What to look for in the page; returns only the relevant excerpt"),
+      offset: z2.number().int().min(0).optional().describe("Start reading at this character (to continue a truncated page)")
+    }),
+    kind: "fetch",
+    target: (input) => input.url,
+    async run(input, ctx) {
+      if (!/^https?:\/\//i.test(input.url)) return { output: "URL must start with http:// or https://", isError: true };
+      const target = new URL(input.url);
+      let pinned;
+      if (!isPrivate(target.hostname) && isIP(target.hostname) === 0) {
+        try {
+          const addresses = await lookup(target.hostname);
+          const internal = addresses.find((a) => isPrivate(a.address));
+          if (internal) {
+            return {
+              output: t("Blocked: {host} resolves to a private address ({addr}). Fetching an internal host through a public DNS name is not allowed.", { host: target.hostname, addr: internal.address }),
+              isError: true
+            };
+          }
+          pinned = addresses;
+        } catch {
+        }
+      }
+      const prompt = input.prompt?.trim();
+      const askKeenable = !!prompt && !input.offset && !!keenableURL && !target.username && !target.password && !isPrivate(target.hostname);
+      if (askKeenable) {
+        const key = `x
+${input.url}
+${prompt}`;
+        const hit = recall(key);
+        if (hit) {
+          ctx.refundFetch?.();
+          return { output: hit, display: withCost(hit, t("focused excerpt \xB7 cache")) };
+        }
+        const out = await extractWithKeenable(keenableURL, input.url, prompt, ctx.signal);
+        if (out) {
+          const output2 = `[Excerpt from ${input.url} for "${prompt}" (extracted by Keenable). If it says the answer is not there, try fetch without a prompt.]
+${out}`;
+          remember(key, output2, output2.length);
+          return { output: output2, display: withCost(output2, t("focused excerpt (Keenable)")) };
+        }
+      }
+      let page = recall(`p
+${input.url}`);
+      const cached = !!page;
+      if (cached) ctx.refundFetch?.();
+      if (!page) {
+        const loaded = await loadPage(input.url, ctx.signal, pinned, opts.fetchPage);
+        if ("error" in loaded) return { output: loaded.error, isError: true };
+        page = loaded;
+        remember(`p
+${input.url}`, page, page.text.length);
+      }
+      const { text, truncated } = page;
+      const via = cached ? " \xB7 cache" : "";
+      if (prompt && !input.offset) {
+        const picked = pickRelevant(text, prompt);
+        if (picked) {
+          const output2 = `[Most relevant excerpt from ${input.url} for "${prompt}" (${text.length} characters total). Full page: fetch without a prompt.]
+${picked}`;
+          return { output: output2, display: withCost(output2, `${t("focused excerpt (local)")}${via}`) };
+        }
+      }
+      const offset = input.offset ?? 0;
+      if (offset >= text.length && text.length > 0) {
+        return { output: `offset ${offset} is past the end of the page (${text.length} characters).`, isError: true };
+      }
+      const end = Math.min(offset + MAX_CHARS, text.length);
+      let output = text.slice(offset, end);
+      if (end < text.length || truncated) {
+        const total = truncated ? `${text.length}+` : text.length;
+        output += `
+\u2026 [truncated: characters ${offset}-${end} of ${total}. Continue with offset=${end}, or use prompt for a focused excerpt.]`;
+      }
+      const size = truncated ? t("over 5 MB, truncated") : t("{n} characters", { n: text.length });
+      return { output, display: withCost(output, `${size}${via}`) };
+    }
+  });
+}
+async function extractWithKeenable(endpoint, url, prompt, signal) {
+  try {
+    const u = new URL(endpoint);
+    u.searchParams.set("url", url);
+    u.searchParams.set("prompt", prompt);
+    u.searchParams.set("live", "true");
+    u.searchParams.set("max_chars", String(MAX_CHARS));
+    const res = await fetch(u, { headers: { "X-Keenable-Title": "BotConnector" }, signal: AbortSignal.any([signal, AbortSignal.timeout(25e3)]) });
+    if (!res.ok) return void 0;
+    const content = (await res.json()).content;
+    return typeof content === "string" && content.trim() ? content.slice(0, MAX_CHARS) : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function loadPage(inputUrl, signal, pinned, fetchPage) {
+  let url = new URL(inputUrl);
+  const dispatcher = pinned?.length ? new Agent({ connect: { lookup: pinLookup(pinned) } }) : void 0;
+  const doFetch = fetchPage ?? (dispatcher ? undiciFetch : fetch);
+  try {
+    let res;
+    for (let hop = 0; hop < 5; hop++) {
+      res = await doFetch(url, {
+        headers: { accept: ACCEPT },
+        signal: AbortSignal.any([signal, AbortSignal.timeout(3e4)]),
+        redirect: "manual",
+        ...dispatcher ? { dispatcher } : {}
+      });
+      const location = res.status >= 300 && res.status < 400 ? res.headers.get("location") : null;
+      if (!location) break;
+      const next = new URL(location, url);
+      if (next.host !== url.host) {
+        await res.body?.cancel();
+        return { error: `Redirect to another host: ${next.href}. Call fetch again with that URL if needed (permission will be requested).` };
+      }
+      await res.body?.cancel();
+      url = next;
+    }
+    if (!res) return { error: `Failed to fetch ${inputUrl}` };
+    const { text: body, truncated } = await readCapped(res);
+    const type = res.headers.get("content-type") ?? "";
+    const text = type.includes("html") ? htmlToText(body) : body;
+    if (!res.ok) return { error: `HTTP ${res.status} from ${inputUrl}: ${text.slice(0, 500)}` };
+    return { text, truncated, at: Date.now() };
+  } catch (error) {
+    return { error: `Failed to fetch ${inputUrl}: ${describeFetchError(error)}` };
+  } finally {
+    await dispatcher?.close().catch(() => {
+    });
+  }
+}
+var fetchTool = createFetchTool();
+
+export {
+  isPrivateHost,
+  createFetchTool,
+  fetchTool,
+  createWebSearchTool
+};