@evandu/super-pi 0.1.130 → 0.1.132

package/dist/server/store.d.ts

@@ -1,5 +1,6 @@
 import type { AppStateRepository } from "./persistence/app-state-repository.js";
 import { defaultJsonStatePath } from "./persistence/json-state-repository.js";
+import type { ScheduledTask } from "./scheduled-tasks.js";
 import type { WorkflowRun } from "./workflow.js";
 import type { AppState, Conversation, Message, MessageDelivery, MessageImage, ModelSelection, SubagentRun, SubagentRunUpdate, TodoItem, ToolCallQuestion, ToolCallArg, ToolCallBlock, ToolResultSummary, Workspace } from "./types.js";
 /** Mints the id a forked conversation will have, BEFORE its Pi transcript exists.
@@ -45,6 +46,14 @@ export declare const SUBAGENT_RUN_RETENTION = 100;
  * request that needed several specialists rather than a unit of work.
  */
 export declare const WORKFLOW_RETENTION = 50;
+/**
+ * How many scheduled tasks are kept.
+ *
+ * A task is a standing arrangement, not a record of something that happened, so the bound here is much
+ * looser than the run retention: a person who keeps a daily task for a year has one task, and the
+ * hundredth is already a sign that the list is being used as a log rather than as a list of intentions.
+ */
+export declare const SCHEDULED_TASK_RETENTION = 100;
 /**
  * Everything a revert decided, before anything is changed.
  *
@@ -688,6 +697,27 @@ export declare class Store {
     setBackgroundTask(summary: AppState["backgroundTasks"][number]): Promise<void>;
     removeBackgroundTask(id: string): Promise<void>;
     clearBackgroundTasks(): Promise<void>;
+    /**
+     * Writes a scheduled task - new or changed - and persists it.
+     *
+     * ONE METHOD FOR BOTH, because the two are the same write. A task that has not run and a task that
+     * has run are the same kind of thing with different field values, and splitting them into
+     * "create" and "update" would leave the caller to decide which of two paths a given change takes -
+     * which is exactly the kind of decision that ends up made twice, differently, in two places.
+     *
+     * The value is cloned on the way in and on the way out, like every other store method that hands a
+     * record back: the caller mutates its own copy freely, and the copy on disk is the copy that was
+     * written.
+     */
+    setScheduledTask(task: ScheduledTask): Promise<ScheduledTask>;
+    /**
+     * Removes a scheduled task, and persists the removal.
+     *
+     * AN EMPTY LIST IS STORED AS ABSENCE, for the same reason `setTodos` stores an empty todo list as
+     * the absence of the key: a state file that says "scheduledTasks: []" claims the user considered a
+     * schedule and found none, and a fresh install has never considered anything.
+     */
+    removeScheduledTask(id: string): Promise<void>;
     /**
      * Applies the fields a run's life can change, and nothing else.
      *

package/dist/server/store.js

@@ -245,6 +245,27 @@ function trimWorkflows(workflows) {
     }
     workflows.splice(0, workflows.length, ...workflows.filter((plan) => !doomed.has(plan.id)));
 }
+/**
+ * How many scheduled tasks are kept.
+ *
+ * A task is a standing arrangement, not a record of something that happened, so the bound here is much
+ * looser than the run retention: a person who keeps a daily task for a year has one task, and the
+ * hundredth is already a sign that the list is being used as a log rather than as a list of intentions.
+ */
+export const SCHEDULED_TASK_RETENTION = 100;
+/** Evicts the OLDEST scheduled tasks once there are more than `SCHEDULED_TASK_RETENTION`. */
+function trimScheduledTasks(tasks) {
+    const excess = tasks.length - SCHEDULED_TASK_RETENTION;
+    if (excess <= 0)
+        return;
+    const doomed = new Set();
+    for (const task of [...tasks].sort((a, b) => a.createdAt - b.createdAt)) {
+        if (doomed.size >= excess)
+            break;
+        doomed.add(task.id);
+    }
+    tasks.splice(0, tasks.length, ...tasks.filter((task) => !doomed.has(task.id)));
+}
 /**
  * Why a plan the previous process left `running` is stopped rather than resumed, in the same spirit and
  * for the same audience as `ORPHANED_RUN_ERROR`.
@@ -576,9 +597,15 @@ export class Store {
             // it is repaired again on every single boot - and until it is, anything reading the file sees the
             // un-normalised shape rather than the one the store is actually running on.
             const defaulted = ["workspaces", "conversations", "subagentRuns"].filter((key) => !Array.isArray(state[key])).length > 0
-                || !Array.isArray(state.backgroundTasks);
+                || !Array.isArray(state.backgroundTasks)
+                || (state.scheduledTasks !== undefined && !Array.isArray(state.scheduledTasks));
             if (!Array.isArray(state.backgroundTasks))
                 state.backgroundTasks = [];
+            // A scheduled-task list that is not a list is not a list of tasks. The key is dropped rather than
+            // coerced, so a corrupted file reads as "this install has no scheduled tasks" - the same thing a
+            // fresh install reads - instead of crashing the panel on every poll.
+            if (state.scheduledTasks !== undefined && !Array.isArray(state.scheduledTasks))
+                delete state.scheduledTasks;
             // Every sweep runs before the store is constructed, so a single persist below publishes them together.
             // Reconciling them in separate writes would put a file on disk in which one kind of orphan was fixed
             // and the other was not - a half-repaired state that still needs a second restart to finish.
@@ -1970,6 +1997,50 @@ export class Store {
         this.state.backgroundTasks = [];
         await this.persistCollections("backgroundTasks");
     }
+    /**
+     * Writes a scheduled task - new or changed - and persists it.
+     *
+     * ONE METHOD FOR BOTH, because the two are the same write. A task that has not run and a task that
+     * has run are the same kind of thing with different field values, and splitting them into
+     * "create" and "update" would leave the caller to decide which of two paths a given change takes -
+     * which is exactly the kind of decision that ends up made twice, differently, in two places.
+     *
+     * The value is cloned on the way in and on the way out, like every other store method that hands a
+     * record back: the caller mutates its own copy freely, and the copy on disk is the copy that was
+     * written.
+     */
+    async setScheduledTask(task) {
+        if (!this.state.scheduledTasks)
+            this.state.scheduledTasks = [];
+        const stored = structuredClone(task);
+        const index = this.state.scheduledTasks.findIndex((item) => item?.id === stored.id);
+        if (index < 0)
+            this.state.scheduledTasks.push(stored);
+        else
+            this.state.scheduledTasks[index] = stored;
+        trimScheduledTasks(this.state.scheduledTasks);
+        await this.persistCollections("scheduledTasks");
+        return structuredClone(stored);
+    }
+    /**
+     * Removes a scheduled task, and persists the removal.
+     *
+     * AN EMPTY LIST IS STORED AS ABSENCE, for the same reason `setTodos` stores an empty todo list as
+     * the absence of the key: a state file that says "scheduledTasks: []" claims the user considered a
+     * schedule and found none, and a fresh install has never considered anything.
+     */
+    async removeScheduledTask(id) {
+        if (!this.state.scheduledTasks)
+            return;
+        const remaining = this.state.scheduledTasks.filter((item) => item?.id !== id);
+        if (remaining.length === this.state.scheduledTasks.length)
+            return;
+        if (remaining.length)
+            this.state.scheduledTasks = remaining;
+        else
+            delete this.state.scheduledTasks;
+        await this.persistCollections("scheduledTasks");
+    }
     /**
      * Applies the fields a run's life can change, and nothing else.
      *
@@ -2063,7 +2134,15 @@ export class Store {
             await this.persist();
     }
     async persistCollections(key) {
-        await this.persistTransaction({ kind: "collections.replace", values: { [key]: structuredClone(this.state[key]) } });
+        const value = this.state[key];
+        // A collection that is EMPTY is absent from the state, and an absent collection has no row to
+        // write. The row is removed instead, because a repository that can only write rows would have to
+        // store `[]` - which is a different claim from "the user never made one".
+        if (value === undefined) {
+            await this.persistTransaction({ kind: "collections.remove", name: key });
+            return;
+        }
+        await this.persistTransaction({ kind: "collections.replace", values: { [key]: structuredClone(value) } });
     }
     async persistMetadata(conversationId) {
         const { messages: _messages, ...metadata } = this.requireConversation(conversationId);

package/dist/server/subagents.js

@@ -6,6 +6,7 @@ import { agentSpawnArgs, readAgents } from "./agents.js";
 import { resolvePiCommand, shellQuote } from "./pi-command.js";
 import { buildExtensionUiResponse, describeExtensionUiRequest, killTree, } from "./runtime.js";
 import { RpcChannel } from "./rpc-channel.js";
+import { InlineThinkingSplitter, stripInlineThinking } from "./inline-thinking.js";
 import { describeToolCall, TOOL_DETAIL_CAP } from "./tool-calls.js";
 /**
  * The tool-call derivation now lives in `tool-calls.js`, because the primary agent's runtime needs the
@@ -284,6 +285,15 @@ export class SubagentSupervisor {
         let current = "";
         /** The last assistant message's text, which is the run's output. */
         let finalText = "";
+        /**
+         * THE CHILD'S OWN REASONING, taken out of its answer.
+         *
+         * A model that has no reasoning channel writes its thinking into the answer, marked up with
+         * `<think>…</think>`. This supervisor's contract is `finalText` - the child's OUTPUT - and the
+         * reasoning is not part of it, so the tags and what they wrap never reach the card. The splitter
+         * is per child, because what it holds back belongs to one child's stream and to nothing else.
+         */
+        const inlineThinking = new InlineThinkingSplitter();
         const usage = { ...NO_USAGE };
         /** Set rather than thrown so a child's own failure is reported AFTER its output has been drained. */
         let failed;
@@ -420,10 +430,18 @@ export class SubagentSupervisor {
                         // three messages would report all three concatenated as one answer.
                         if (event?.type === "text_delta") {
                             const delta = event.delta ?? "";
-                            streamed += delta;
-                            current += delta;
+                            // THE REASONING COMES OUT FIRST. What the card shows is the child's answer, and a model
+                            // that thinks inside its answer would otherwise hand it a string that opens with
+                            // `<think>` - the markup of a reasoning trace where the child's result belongs.
+                            const answer = inlineThinking.push(delta)
+                                .filter((segment) => segment.kind === "text")
+                                .map((segment) => segment.text)
+                                .join("");
+                            streamed += answer;
+                            current += answer;
                             enter("turn");
-                            onTextDelta?.(delta);
+                            if (answer)
+                                onTextDelta?.(answer);
                         }
                         else if (event?.type === "start") {
                             current = "";
@@ -432,16 +450,18 @@ export class SubagentSupervisor {
                         else if (event?.type === "done") {
                             // `done` carries the AUTHORITATIVE message, so its text wins over what the deltas added up
                             // to; the accumulated text stays as the fallback for a child that streams without a `done`.
-                            current = assistantText(event.message) || current;
+                            // The authoritative text is stripped the same way the deltas were: a child whose answer
+                            // ends in a reasoning region must not turn that region into its result.
+                            current = stripInlineThinking(assistantText(event.message)) || current;
                             finalText = current;
                             addUsage(usage, record.usage);
                             enter("turn");
                             const reason = event.message?.stopReason ?? event.reason;
                             if (reason === "error" || reason === "aborted")
-                                failed ??= `sub-agent ${agentId} (${id}) stopped with reason ${reason}: ${assistantText(event.message) || "no output"}`;
+                                failed ??= `sub-agent ${agentId} (${id}) stopped with reason ${reason}: ${stripInlineThinking(assistantText(event.message)) || "no output"}`;
                         }
                         else if (event?.type === "error") {
-                            failed ??= `sub-agent ${agentId} (${id}) reported ${event.reason ?? "an error"}: ${assistantText(event.message) || "no detail from Pi"}`;
+                            failed ??= `sub-agent ${agentId} (${id}) reported ${event.reason ?? "an error"}: ${stripInlineThinking(assistantText(event.message)) || "no detail from Pi"}`;
                         }
                         else if (event?.type === "thinking_delta") {
                             // CONSUMED, not discarded. A reasoning model spends the first seconds of every turn here,
@@ -524,6 +544,13 @@ export class SubagentSupervisor {
                 throw new Error(failed);
             // No `done` at all is a child that streamed and vanished; the deltas are then the best answer there
             // is, and returning them beats returning "" for work that demonstrably happened.
+            //
+            // THE SPLITTER IS RELEASED FIRST. It may still be holding back the beginning of a tag, and that
+            // text belongs to the child: a run that ended mid-word must not lose the word.
+            for (const segment of inlineThinking.flush()) {
+                if (segment.kind === "text")
+                    streamed += segment.text;
+            }
             return { id, sessionId: id, finalText: finalText || streamed, usage };
         }
         finally {

package/dist/server/task-tool.d.ts

@@ -173,6 +173,24 @@ export declare const TODO_TOOL_NAME = "todowrite";
  * tool then refuses in words instead of posting somewhere that does not exist.
  */
 export declare const TODO_ENDPOINT_ENV = "SUPER_PI_TODO_ENDPOINT";
+/**
+ * The name the model calls to manage the SCHEDULED TASKS.
+ *
+ * `scheduled_task`, with an underscore, because this is not one of OpenCode's tools and there is no
+ * prior name to match. The name says what it is: a task that runs on a schedule.
+ */
+export declare const SCHEDULED_TASK_TOOL_NAME = "scheduled_task";
+/**
+ * The endpoint the `scheduled_task` tool dials. Another name in the same wire, written out on both
+ * sides for the same reason `TODO_ENDPOINT_ENV` states: `agents/super-pi-task/core.ts` is loaded by
+ * Pi's module loader and this file by tsc, so the two copies have to agree by hand -
+ * `scripts/scheduled-task-tool.test.mjs` asserts that they do.
+ *
+ * A SEPARATE variable rather than a path derived from `TODO_ENDPOINT_ENV`, for the reason that one
+ * states: a Pi can legitimately have one and not the other, and a derived path could not tell those
+ * apart from a misconfiguration.
+ */
+export declare const SCHEDULED_TASK_ENDPOINT_ENV = "SUPER_PI_SCHEDULED_TASK_ENDPOINT";
 /**
  * How many todos may be stored, and how long one may be.
  *

package/dist/server/task-tool.js

@@ -230,6 +230,24 @@ export const TODO_TOOL_NAME = "todowrite";
  * tool then refuses in words instead of posting somewhere that does not exist.
  */
 export const TODO_ENDPOINT_ENV = "SUPER_PI_TODO_ENDPOINT";
+/**
+ * The name the model calls to manage the SCHEDULED TASKS.
+ *
+ * `scheduled_task`, with an underscore, because this is not one of OpenCode's tools and there is no
+ * prior name to match. The name says what it is: a task that runs on a schedule.
+ */
+export const SCHEDULED_TASK_TOOL_NAME = "scheduled_task";
+/**
+ * The endpoint the `scheduled_task` tool dials. Another name in the same wire, written out on both
+ * sides for the same reason `TODO_ENDPOINT_ENV` states: `agents/super-pi-task/core.ts` is loaded by
+ * Pi's module loader and this file by tsc, so the two copies have to agree by hand -
+ * `scripts/scheduled-task-tool.test.mjs` asserts that they do.
+ *
+ * A SEPARATE variable rather than a path derived from `TODO_ENDPOINT_ENV`, for the reason that one
+ * states: a Pi can legitimately have one and not the other, and a derived path could not tell those
+ * apart from a misconfiguration.
+ */
+export const SCHEDULED_TASK_ENDPOINT_ENV = "SUPER_PI_SCHEDULED_TASK_ENDPOINT";
 /**
  * How many todos may be stored, and how long one may be.
  *

package/dist/server/types.d.ts

@@ -5,6 +5,7 @@ export type ModelFilterRule = {
     label?: string;
 };
 import type { WorkflowRun } from "./workflow.js";
+import type { ScheduledTask } from "./scheduled-tasks.js";
 /**
  * The lifecycle states a `Conversation.status` moves through while a turn is in flight. `waiting` is the
  * gap between "prompt handed to the LLM" and "the first response token arrived" - holding it apart from
@@ -835,6 +836,7 @@ export type AppState = {
     backgroundTasks: BackgroundTaskSummary[];
     todosByConversation?: Record<string, TodoItem[]>;
     workflows?: WorkflowRun[];
+    scheduledTasks?: ScheduledTask[];
     customAgentDirs?: string[];
 };
 export type TodoItem = {
@@ -1372,6 +1374,60 @@ export type ClientCommandBody =
 /** Restarts the Super Pi server by spawning the same restart script used by the auto-updater. */
  | {
     type: "super_pi.restart";
+}
+/**
+ * A scheduled task is created.
+ *
+ * The schedule arrives as an opaque value and is validated on the SERVER, in the one place that owns
+ * what a schedule means. The browser cannot send a half-valid schedule, because it does not know
+ * what a half-valid schedule is; it sends the fields the panel collected and the server decides
+ * whether they describe a schedule.
+ */
+ | {
+    type: "scheduledTask.create";
+    name?: string;
+    prompt: string;
+    schedule: unknown;
+    workspaceId: string;
+    model?: ModelSelection | null;
+    agentId?: string | null;
+}
+/**
+ * A scheduled task is changed. Every field is optional, and the ones that are absent are the ones
+ * that do not change - a panel that sends the whole task back would fight the scheduler's own
+ * bookkeeping over `nextRunAt`, which is not the panel's to write.
+ */
+ | {
+    type: "scheduledTask.update";
+    id: string;
+    name?: string;
+    prompt?: string;
+    schedule?: unknown;
+    model?: ModelSelection | null;
+    agentId?: string | null;
+}
+/** A scheduled task is removed. Its conversation and the answers it produced stay. */
+ | {
+    type: "scheduledTask.delete";
+    id: string;
+}
+/**
+ * A scheduled task runs NOW, once, without touching its schedule.
+ *
+ * It is a separate command rather than a flag on `update` because it is a different act: `update`
+ * changes what the task IS, and this changes what the task DID. The one thing it shares with the
+ * clock is the run itself - it goes through the same path, so a manual run and a scheduled run
+ * behave identically.
+ */
+ | {
+    type: "scheduledTask.trigger";
+    id: string;
+}
+/** A scheduled task is turned on or off. */
+ | {
+    type: "scheduledTask.toggle";
+    id: string;
+    enabled: boolean;
 } | ({
     type: "extension.ui.answer";
     conversationId: string;

package/dist/server/web.d.ts

@@ -0,0 +1,24 @@
+export declare const WEB_SEARCH_TOOL_NAME = "web_search";
+export declare const WEB_FETCH_TOOL_NAME = "web_fetch";
+export declare const MAX_WEB_REQUEST_BYTES: number;
+export type WebSearchResult = {
+    title: string;
+    url: string;
+    snippet: string;
+};
+export type WebFetchResult = {
+    title: string;
+    url: string;
+    text: string;
+    truncated: boolean;
+    contentType: string;
+};
+/** Parse Bing's ordinary result page. Kept separate so captured fixtures can guard markup changes. */
+export declare function parseBingResults(html: string, limit?: number): WebSearchResult[];
+export declare class WebService {
+    search(query: string, limit?: number, signal?: AbortSignal): Promise<{
+        query: string;
+        results: WebSearchResult[];
+    }>;
+    fetch(url: string, signal?: AbortSignal): Promise<WebFetchResult>;
+}

package/dist/server/web.js

@@ -0,0 +1,180 @@
+import { isIP } from "node:net";
+import { lookup } from "node:dns/promises";
+import { request as httpRequest } from "node:http";
+import { request as httpsRequest } from "node:https";
+import { brotliDecompressSync, gunzipSync, inflateSync } from "node:zlib";
+export const WEB_SEARCH_TOOL_NAME = "web_search";
+export const WEB_FETCH_TOOL_NAME = "web_fetch";
+export const MAX_WEB_REQUEST_BYTES = 64 * 1024;
+const SEARCH_LIMIT = 10;
+const RESPONSE_LIMIT = 2 * 1024 * 1024;
+const TEXT_LIMIT = 30_000;
+const REDIRECT_LIMIT = 5;
+const TIMEOUT_MS = 15_000;
+const USER_AGENT = "Mozilla/5.0 (compatible; SuperPi/1.0; +https://www.npmjs.com/package/@evandu/super-pi)";
+function decodeEntities(value) {
+    const named = { amp: "&", quot: '"', apos: "'", lt: "<", gt: ">", nbsp: " " };
+    return value.replace(/&(#x[\da-f]+|#\d+|[a-z]+);/gi, (_all, entity) => {
+        if (entity[0] === "#") {
+            const code = entity[1]?.toLowerCase() === "x" ? Number.parseInt(entity.slice(2), 16) : Number.parseInt(entity.slice(1), 10);
+            return Number.isFinite(code) ? String.fromCodePoint(code) : "";
+        }
+        return named[entity.toLowerCase()] ?? `&${entity};`;
+    });
+}
+function plainText(html) {
+    return decodeEntities(html.replace(/<script\b[^>]*>[\s\S]*?<\/script>/gi, " ").replace(/<style\b[^>]*>[\s\S]*?<\/style>/gi, " ").replace(/<[^>]+>/g, " "))
+        .replace(/\s+/g, " ").trim();
+}
+/** Parse Bing's ordinary result page. Kept separate so captured fixtures can guard markup changes. */
+export function parseBingResults(html, limit = 5) {
+    const results = [];
+    const blocks = html.match(/<li\b[^>]*class=["'][^"']*\bb_algo\b[^"']*["'][^>]*>[\s\S]*?<\/li>/gi) ?? [];
+    for (const block of blocks) {
+        const anchor = /<h2\b[^>]*>[\s\S]*?<a\b[^>]*href=["']([^"']+)["'][^>]*>([\s\S]*?)<\/a>/i.exec(block);
+        if (!anchor)
+            continue;
+        let url;
+        try {
+            url = new URL(decodeEntities(anchor[1]));
+        }
+        catch {
+            continue;
+        }
+        if (!/^https?:$/.test(url.protocol))
+            continue;
+        const caption = /<p\b[^>]*>([\s\S]*?)<\/p>/i.exec(block)?.[1] ?? "";
+        results.push({ title: plainText(anchor[2]), url: url.href, snippet: plainText(caption) });
+        if (results.length >= Math.min(SEARCH_LIMIT, Math.max(1, limit)))
+            break;
+    }
+    return results;
+}
+function blockedAddress(address) {
+    if (address === "::" || address === "::1")
+        return true;
+    const v4 = address.startsWith("::ffff:") ? address.slice(7) : address;
+    if (isIP(v4) === 4) {
+        const [a, b] = v4.split(".").map(Number);
+        return a === 0 || a === 10 || a === 127 || (a === 169 && b === 254) || (a === 172 && b >= 16 && b <= 31) || (a === 192 && b === 168) || a >= 224;
+    }
+    const normalized = address.toLowerCase();
+    return normalized.startsWith("fc") || normalized.startsWith("fd") || normalized.startsWith("fe8") || normalized.startsWith("fe9") || normalized.startsWith("fea") || normalized.startsWith("feb") || normalized.startsWith("ff");
+}
+async function publicAddress(hostname) {
+    if (hostname.toLowerCase() === "localhost" || hostname.endsWith(".localhost"))
+        throw new Error("不允许访问本机或私网地址");
+    const records = isIP(hostname) ? [{ address: hostname, family: isIP(hostname) }] : await lookup(hostname, { all: true, verbatim: true });
+    const record = records.find(item => !blockedAddress(item.address));
+    if (!record || records.some(item => blockedAddress(item.address)))
+        throw new Error("不允许访问本机或私网地址");
+    return record;
+}
+async function download(input, signal, redirects = 0) {
+    const url = new URL(input);
+    if (!/^https?:$/.test(url.protocol) || url.username || url.password)
+        throw new Error("只允许无凭据的 HTTP/HTTPS URL");
+    if (redirects > REDIRECT_LIMIT)
+        throw new Error("网页重定向次数过多");
+    const resolved = await publicAddress(url.hostname);
+    const requester = url.protocol === "https:" ? httpsRequest : httpRequest;
+    // Node may ask a custom lookup for one address or an array (`all: true`). Honor both overloads;
+    // returning the wrong shape makes net.connect report the misleading "Invalid IP address: undefined".
+    const pinnedLookup = ((_hostname, options, callback) => {
+        if (options?.all)
+            callback(null, [resolved]);
+        else
+            callback(null, resolved.address, resolved.family);
+    });
+    return new Promise((resolve, reject) => {
+        const req = requester(url, {
+            headers: { "user-agent": USER_AGENT, accept: "text/html,text/plain,application/xhtml+xml", "accept-encoding": "gzip, deflate, br" },
+            lookup: pinnedLookup,
+            servername: url.hostname,
+            timeout: TIMEOUT_MS,
+            signal,
+        }, response => {
+            const status = response.statusCode ?? 0;
+            const location = response.headers.location;
+            if (status >= 300 && status < 400 && location) {
+                response.resume();
+                download(new URL(location, url).href, signal, redirects + 1).then(resolve, reject);
+                return;
+            }
+            if (status < 200 || status >= 300) {
+                response.resume();
+                reject(new Error(`网页请求失败（HTTP ${status}）`));
+                return;
+            }
+            const chunks = [];
+            let bytes = 0;
+            response.on("data", chunk => {
+                bytes += chunk.length;
+                if (bytes > RESPONSE_LIMIT) {
+                    req.destroy(new Error("网页响应超过 2 MB 限制"));
+                    return;
+                }
+                chunks.push(chunk);
+            });
+            response.on("end", () => {
+                try {
+                    let body = Buffer.concat(chunks);
+                    const encoding = String(response.headers["content-encoding"] ?? "").toLowerCase();
+                    if (encoding === "gzip")
+                        body = gunzipSync(body);
+                    else if (encoding === "deflate")
+                        body = inflateSync(body);
+                    else if (encoding === "br")
+                        body = brotliDecompressSync(body);
+                    resolve({ url: url.href, body, contentType: String(response.headers["content-type"] ?? "application/octet-stream") });
+                }
+                catch (error) {
+                    reject(error);
+                }
+            });
+        });
+        req.on("timeout", () => req.destroy(new Error("网页请求超时")));
+        req.on("error", reject);
+        req.end();
+    });
+}
+function extractHtml(html) {
+    const title = plainText(/<title\b[^>]*>([\s\S]*?)<\/title>/i.exec(html)?.[1] ?? "");
+    let body = /<article\b[^>]*>([\s\S]*?)<\/article>/i.exec(html)?.[1]
+        ?? /<main\b[^>]*>([\s\S]*?)<\/main>/i.exec(html)?.[1]
+        ?? /<body\b[^>]*>([\s\S]*?)<\/body>/i.exec(html)?.[1]
+        ?? html;
+    body = body.replace(/<(nav|aside|footer|form|noscript|svg)\b[^>]*>[\s\S]*?<\/\1>/gi, " ")
+        .replace(/<(br|p|div|li|h[1-6]|tr)\b[^>]*>/gi, "\n")
+        .replace(/<script\b[^>]*>[\s\S]*?<\/script>/gi, " ").replace(/<style\b[^>]*>[\s\S]*?<\/style>/gi, " ")
+        .replace(/<[^>]+>/g, " ");
+    const text = decodeEntities(body).replace(/[ \t]+/g, " ").replace(/\n\s*/g, "\n").replace(/\n{3,}/g, "\n\n").trim();
+    return { title, text };
+}
+export class WebService {
+    async search(query, limit = 5, signal) {
+        const clean = query.trim();
+        if (!clean)
+            throw new Error("搜索词不能为空");
+        if (clean.length > 500)
+            throw new Error("搜索词不能超过 500 个字符");
+        const url = new URL("https://www.bing.com/search");
+        url.searchParams.set("q", clean);
+        url.searchParams.set("count", String(Math.min(SEARCH_LIMIT, Math.max(1, Math.floor(limit)))));
+        url.searchParams.set("setlang", "zh-Hans");
+        const response = await download(url.href, signal);
+        const results = parseBingResults(response.body.toString("utf8"), limit);
+        if (!results.length)
+            throw new Error("搜索引擎没有返回可解析的结果，可能暂时限流或页面格式已变化");
+        return { query: clean, results };
+    }
+    async fetch(url, signal) {
+        const response = await download(url, signal);
+        if (!/^(text\/html|application\/xhtml\+xml|text\/plain)\b/i.test(response.contentType))
+            throw new Error(`不支持的网页类型：${response.contentType}`);
+        const decoded = response.body.toString("utf8");
+        const extracted = /^text\/plain\b/i.test(response.contentType) ? { title: "", text: decoded.trim() } : extractHtml(decoded);
+        const truncated = extracted.text.length > TEXT_LIMIT;
+        return { title: extracted.title, url: response.url, text: extracted.text.slice(0, TEXT_LIMIT), truncated, contentType: response.contentType };
+    }
+}