@evandu/super-pi 0.1.130 → 0.1.132

package/dist/server/runtime.js

@@ -2,7 +2,10 @@ import { spawn } from "node:child_process";
 import { RpcChannel } from "./rpc-channel.js";
 export { RpcChannel } from "./rpc-channel.js";
 import { randomUUID } from "node:crypto";
-import { KNOWLEDGE_TOOL_NAME } from "./knowledge.js";
+import { KNOWLEDGE_IMPORT_TOOL_NAME, KNOWLEDGE_TOOL_NAME } from "./knowledge.js";
+import { DOCUMENT_READ_TOOL_NAME, DOCUMENT_WRITE_TOOL_NAME } from "./documents.js";
+import { FEISHU_READ_TOOL_NAME, FEISHU_WRITE_TOOL_NAME } from "./feishu-cli.js";
+import { WEB_FETCH_TOOL_NAME, WEB_SEARCH_TOOL_NAME } from "./web.js";
 import { existsSync } from "node:fs";
 import { mkdir, stat } from "node:fs/promises";
 import { forkSessionFile, truncateSessionFile } from "./session-repository.js";
@@ -18,10 +21,11 @@ import { describeDeliveredUserMessage, describePiQueue, handleSessionEvent, Turn
 // paths recognise a delivery identically. Re-exported because they were part of this module's surface.
 export { describeDeliveredUserMessage, describePiQueue } from "./pi-session-events.js";
 import { createPiSession, createSdkCatalog, piSdkAvailable, resolveTranscriptFile, superPiExtensionPaths } from "./pi-session.js";
-import { TASK_CONVERSATION_ENV, TASK_DEPTH_ENV, TASK_ENDPOINT_ENV, TASK_EXEC_ENDPOINT_ENV, TASK_ROSTER_ENV, TASK_TOOL_NAME, TODO_ENDPOINT_ENV, TODO_TOOL_NAME, WORKFLOW_ENDPOINT_ENV, WORKFLOW_TOOL_NAME, RUN_ASYNC_TOOL_NAME, rosterPayload, } from "./task-tool.js";
+import { TASK_CONVERSATION_ENV, TASK_DEPTH_ENV, TASK_ENDPOINT_ENV, TASK_EXEC_ENDPOINT_ENV, TASK_ROSTER_ENV, TASK_TOOL_NAME, TODO_ENDPOINT_ENV, TODO_TOOL_NAME, SCHEDULED_TASK_ENDPOINT_ENV, SCHEDULED_TASK_TOOL_NAME, WORKFLOW_ENDPOINT_ENV, WORKFLOW_TOOL_NAME, RUN_ASYNC_TOOL_NAME, rosterPayload, } from "./task-tool.js";
 import { BLOCKING_UI_METHODS, EXTENSION_UI_METHODS, } from "./types.js";
 import { loadConversationImages } from "./upload.js";
 import { describeToolCall, describeToolCallArgs, describeToolCallInProgress, extractPartialResultText, extractToolResultText, readQuestionCall } from "./tool-calls.js";
+import { InlineThinkingSplitter, stripInlineThinking } from "./inline-thinking.js";
 import { toolTargetPath } from "./file-changes.js";
 const traceLatency = (conversationId, phase, startedAt, extra = "") => {
     if (process.env.SUPER_PI_TRACE_LATENCY !== "1")
@@ -238,6 +242,23 @@ export const catalogKey = (selection) => (selection?.provider && selection.model
 export function taskExtensionPath(from = import.meta.dirname) {
     return resolve(from, "../../agents/super-pi-task/index.ts");
 }
+/**
+ * The document extension's file, resolved the same way the task extension's is: two `..` segments
+ * from `import.meta.dirname` reach the repository root both after `tsc -b` and under `tsx watch`.
+ */
+export function documentExtensionPath(from = import.meta.dirname) {
+    return resolve(from, "../../agents/super-pi-documents/index.ts");
+}
+/**
+ * The Feishu extension's file, resolved the same way the document extension's is.
+ *
+ * Named on both sides of the wire rather than imported by the extension, for the reason every one
+ * of these names is written out twice: `agents/` is loaded by Pi's module loader and `src/` by
+ * tsc, so a relative import across the two would resolve differently under each.
+ */
+export function feishuExtensionPath(from = import.meta.dirname) {
+    return resolve(from, "../../agents/super-pi-feishu/index.ts");
+}
 /** Bridges a Pi session to Super Pi through Pi's documented JSONL RPC protocol. */
 /**
  * The tool's name as far as the stream has revealed it so far, or an empty string while the model is
@@ -356,6 +377,10 @@ export class PiRpcRuntime {
     modelEpoch = 0;
     /** Latches the "no extension on disk" warning, so it is said once rather than once per turn. */
     warnedMissingExtension = false;
+    /** Latches the "the document extension is missing" warning, for the same reason. */
+    warnedMissingDocumentExtension = false;
+    /** Latches the "the Feishu extension is missing" warning, for the same reason. */
+    warnedMissingFeishuExtension = false;
     /** Latches the "Pi's SDK is not installed" warning, for the same reason. */
     warnedMissingSdk = false;
     /**
@@ -541,6 +566,52 @@ export class PiRpcRuntime {
         }
         return ["--extension", path];
     }
+    /**
+     * The document extension's spawn argument.
+     *
+     * IT IS MOUNTED UNCONDITIONALLY, unlike the knowledge extension. The knowledge extension is only
+     * worth mounting when the workspace HAS documents, because its tool returns nothing otherwise; the
+     * document tools are about the files in the workspace, and a workspace with no PDF in it is exactly
+     * the workspace where an agent might be asked to WRITE one.
+     *
+     * The endpoint is the gate: without it the extension returns without registering anything, so a
+     * runtime with no document endpoint mounts nothing rather than a tool whose every call fails.
+     */
+    documentExtensionArgs() {
+        if (!this.options.documentsEndpoint)
+            return [];
+        const path = documentExtensionPath();
+        if (!existsSync(path)) {
+            if (!this.warnedMissingDocumentExtension) {
+                this.warnedMissingDocumentExtension = true;
+                console.warn(`PiRpcRuntime: ${path} does not exist, so the primary agent cannot read or write PDF, Word and Excel files.`);
+            }
+            return [];
+        }
+        return ["--extension", path];
+    }
+    /**
+     * The Feishu extension's spawn argument.
+     *
+     * MOUNTED UNCONDITIONALLY, for the same reason the document tools are: the endpoint is the gate,
+     * and the extension registers nothing without it. The credential is NOT the gate - a user who
+     * has not configured an application yet still gets the tools, because the error those tools
+     * return is the one that tells the user what to do, and a tool that is simply absent cannot say
+     * anything at all.
+     */
+    feishuExtensionArgs() {
+        if (!process.env.SUPER_PI_FEISHU_ENDPOINT)
+            return [];
+        const path = feishuExtensionPath();
+        if (!existsSync(path)) {
+            if (!this.warnedMissingFeishuExtension) {
+                this.warnedMissingFeishuExtension = true;
+                console.warn(`PiRpcRuntime: ${path} does not exist, so the primary agent cannot read or write Feishu cloud documents.`);
+            }
+            return [];
+        }
+        return ["--extension", path];
+    }
     /**
      * The five values the extension reads out of its own environment. See `task-tool.ts` for why they are
      * written out on both sides rather than imported.
@@ -576,9 +647,23 @@ export class PiRpcRuntime {
             [TASK_CONVERSATION_ENV]: conversationId,
             [TASK_DEPTH_ENV]: "0",
             [TODO_ENDPOINT_ENV]: this.options.todoEndpoint ?? "",
+            [SCHEDULED_TASK_ENDPOINT_ENV]: this.options.scheduledTaskEndpoint ?? "",
             [WORKFLOW_ENDPOINT_ENV]: this.options.workflowEndpoint ?? "",
             SUPER_PI_QUESTION_ENDPOINT: this.options.questionEndpoint ?? "",
             SUPER_PI_TOOLS_ENDPOINT: this.options.toolsEndpoint ?? "",
+            // The document tools' endpoint and the conversation they act for. The CREDENTIAL is not here:
+            // it is the session's own capability, which the session pool adds to this environment when the
+            // session is born, and the document extension reads that same value. Minting a second
+            // credential for the same session would be a second thing to rotate and a second thing to
+            // forget to release.
+            SUPER_PI_DOCUMENTS_ENDPOINT: this.options.documentsEndpoint ?? "",
+            SUPER_PI_DOCUMENTS_CONVERSATION: conversationId,
+            SUPER_PI_WEB_ENDPOINT: process.env.SUPER_PI_WEB_ENDPOINT ?? "",
+            // The Feishu tools' endpoint and the conversation they act for. The CREDENTIAL is not here:
+            // it is the session's own capability, the same value the task dispatch uses, because a
+            // second credential for one session would be a second thing to rotate and to release.
+            SUPER_PI_FEISHU_ENDPOINT: process.env.SUPER_PI_FEISHU_ENDPOINT ?? "",
+            SUPER_PI_FEISHU_CONVERSATION: conversationId,
         };
     }
     /**
@@ -590,8 +675,7 @@ export class PiRpcRuntime {
      * here. A session lives for many turns, so its credential is minted when the session is created (see
      * `PiSessionPool.acquire`) and the server separately requires a running turn for it to be usable.
      */
-    async oneShotExtensionEnv(conversationId) {
-        const capability = mintCapability(conversationId);
+    async oneShotExtensionEnv(conversationId, capability) {
         return {
             ...(await this.taskExtensionEnv(conversationId)),
             [TASK_CAPABILITY_ENV]: capability,
@@ -1012,14 +1096,75 @@ export class PiRpcRuntime {
      * because `toolFlags` treats an explicit false as outranking a host extra.
      */
     extensionToolNames() {
-        const names = [TASK_TOOL_NAME, TODO_TOOL_NAME, WORKFLOW_TOOL_NAME, RUN_ASYNC_TOOL_NAME, "question", "tool_register"];
+        const names = [TASK_TOOL_NAME, TODO_TOOL_NAME, WORKFLOW_TOOL_NAME, RUN_ASYNC_TOOL_NAME, SCHEDULED_TASK_TOOL_NAME, "question", "tool_register"];
         if (this.memory)
             names.push("memory", "skill_manage", "session_search");
         if (this.knowledge)
-            names.push(KNOWLEDGE_TOOL_NAME);
+            names.push(KNOWLEDGE_TOOL_NAME, KNOWLEDGE_IMPORT_TOOL_NAME);
+        if (process.env.SUPER_PI_WEB_ENDPOINT)
+            names.push(WEB_SEARCH_TOOL_NAME, WEB_FETCH_TOOL_NAME);
+        // The document tools are named whenever the endpoint is configured, because that is what decides
+        // whether the extension registers them. An agent that declares `tools: {"*": false, read: true}`
+        // would otherwise get a loaded-but-undeclared tool - broken with no error to explain it.
+        if (this.options.documentsEndpoint)
+            names.push(DOCUMENT_READ_TOOL_NAME, DOCUMENT_WRITE_TOOL_NAME);
+        // The Feishu tools are named whenever the endpoint is configured, for the same reason the
+        // document tools are: the endpoint is what decides whether the extension registers them, and
+        // an agent that declares `tools: {"*": false, read: true}` would otherwise get a
+        // loaded-but-undeclared tool - broken with no error to explain it.
+        if (process.env.SUPER_PI_FEISHU_ENDPOINT)
+            names.push(FEISHU_READ_TOOL_NAME, FEISHU_WRITE_TOOL_NAME);
         return names;
     }
+    /**
+     * A TURN, WITH THE REASONING TAKEN OUT OF THE ANSWER.
+     *
+     * This is the ONE place every turn passes through, whichever path it runs on - the persistent
+     * session or a one-shot process - so it is where the model's own text is read once and read
+     * properly.
+     *
+     * WHAT IT DOES. A model that has no reasoning channel answers in one stream of text and marks its
+     * thinking up inside it with `<think>…</think>`. Pi's adapter passes that through as ordinary
+     * text, because Pi only knows the four reasoning FIELDS a provider can use and a tag is not one
+     * of them. Left alone, the reasoning would be drawn as part of the answer, unlabelled, with the
+     * tags in it.
+     *
+     * WHY IT IS HERE AND NOT IN THE USER'S `models.json`. The alternative is to tell every reader to
+     * go and set a vendor-specific switch in a file Super Pi owns but Pi reads. A user who never
+     * hears of it sees a broken transcript and has no way to find out why. Super Pi reads the tags
+     * itself, for every provider, so the transcript reads the same way whichever endpoint is behind
+     * it - and the reasoning goes where the reasoning goes: into a thinking block, over the same
+     * channel Pi's own reasoning events use, so the fold, the live indicator and the persisted
+     * transcript all work without knowing where the reasoning came from.
+     */
     async *answer(input) {
+        const splitter = new InlineThinkingSplitter();
+        for await (const chunk of this.answerTurn(input)) {
+            for (const segment of splitter.push(chunk)) {
+                if (segment.kind === "text")
+                    yield segment.text;
+                else if (segment.kind === "thinking")
+                    input.onThinking?.(segment.text);
+                else
+                    input.onThinkingEnd?.();
+            }
+        }
+        // THE END OF THE TURN. A model that was still thinking when the turn ended leaves an unclosed
+        // region behind, and it belongs in the block rather than in the answer.
+        for (const segment of splitter.flush()) {
+            if (segment.kind === "text")
+                yield segment.text;
+            else if (segment.kind === "thinking")
+                input.onThinking?.(segment.text);
+            else
+                input.onThinkingEnd?.();
+        }
+    }
+    /**
+     * THE TURN ITSELF, on whichever path it runs. See `answer`, which is the seam the reasoning is
+     * separated at.
+     */
+    async *answerTurn(input) {
         // The one-shot paths keep their own child process, and they are NOT the same thing as a conversation
         // turn: a memory review and a knowledge reranker have their own ids, their own tool sets and their own
         // lifetimes, and folding them into a conversation's session would give them that conversation's
@@ -1111,15 +1256,35 @@ export class PiRpcRuntime {
         const memoryToken = memoryEnabled ? this.memory.issue(validationId, { review: memoryReview }) : undefined;
         const memoryExtension = resolve(import.meta.dirname, "../../agents/super-pi-memory/index.ts");
         const memoryArgs = memoryEnabled ? ["--extension", memoryExtension] : [];
-        // Mounted only when the workspace actually HAS documents. An empty knowledge base would otherwise
-        // cost a catalogue round trip and one declared tool on every turn to tell the model there is
-        // nothing to find. Review turns never mount it: a background reflection has no business
-        // retrieving documents it was not asked about, and its `--tools` line is a closed list. A
-        // reranker never mounts it either - it must not be able to call the search it is ranking.
-        const knowledgeEnabled = !memoryReview && !knowledgeRerank && !!this.knowledge && await this.knowledge.hasDocuments(conversation.workspaceId).catch(() => false);
+        // Mounted on EVERY primary turn, empty base or not. The old condition (hasDocuments) saved a
+        // catalogue round trip and a tool slot when there was nothing to find, but it also made the one
+        // workspace where a user most plausibly says 「把这些文件加入知识库」 the one workspace whose
+        // agent had no import tool. knowledge_search on an empty base answers no hits and costs nothing;
+        // knowledge_import has to exist before the first document does. Review turns never mount it: a
+        // background reflection has no business reading or writing documents, and its `--tools` line is a
+        // closed list. A reranker never mounts it either - it must not be able to call what it ranks.
+        const knowledgeEnabled = !memoryReview && !knowledgeRerank && !!this.knowledge && this.knowledge.enabled();
         const knowledgeToken = knowledgeEnabled ? this.knowledge.issue(conversation.id) : undefined;
         const knowledgeExtension = resolve(import.meta.dirname, "../../agents/super-pi-knowledge/index.ts");
         const knowledgeArgs = knowledgeEnabled ? ["--extension", knowledgeExtension] : [];
+        const webExtension = resolve(import.meta.dirname, "../../agents/super-pi-web/index.ts");
+        const webEnabled = !memoryReview && !knowledgeRerank && existsSync(webExtension) && !!process.env.SUPER_PI_WEB_ENDPOINT;
+        const webArgs = webEnabled ? ["--extension", webExtension] : [];
+        // The Feishu tools are mounted for every ordinary turn, and NOT for a review or a rerank: a
+        // background reflection has no business reading a company's cloud documents, and a reranker
+        // must not be able to reach the tools it is ranking.
+        const feishuEnabled = !memoryReview && !knowledgeRerank && this.feishuExtensionArgs().length > 0;
+        const feishuArgs = feishuEnabled ? this.feishuExtensionArgs() : [];
+        // The document tools are mounted for every ordinary turn, and NOT for a review or a rerank: a
+        // background reflection has no business reading a PDF it was not asked about, and a reranker
+        // must not be able to reach the tools it is ranking.
+        const documentsEnabled = !memoryReview && !knowledgeRerank && this.documentExtensionArgs().length > 0;
+        const documentArgs = documentsEnabled ? this.documentExtensionArgs() : [];
+        // THE ONE-SHOT CHILD'S CREDENTIAL, MINTED ONCE. The server holds ONE capability per
+        // conversation, so minting a second one for the same conversation would replace the first and
+        // leave the task dispatch holding a token the server has already forgotten. Both the task
+        // extension and the document extension therefore share this one value.
+        const oneShotCapability = (extensionArgs.length || documentsEnabled || webEnabled || feishuEnabled) ? mintCapability(conversation.id) : undefined;
         // BOTH extension tools, or neither. Naming one while the other goes unmentioned would be a lie in a
         // different direction: Pi filters its registry through `--tools`, so an agent that declares
         // `tools: {"*": false, read: true}` gets whichever of the two is on this line and silently not the
@@ -1132,13 +1297,13 @@ export class PiRpcRuntime {
         // allowlist and naming a tool Pi has not registered would change the spawn line for every other
         // mode. The prompt asks for a bare JSON array and nothing else; if the model spends a turn on a
         // tool call anyway the reranker times out and falls back to the lexical order.
-        const agentArgs = memoryReview ? ["--no-extensions", "--no-skills", "--no-mcp", "--no-context-files", "--no-prompt-templates", "--tools", "memory,skill_manage,session_search"] : knowledgeRerank ? ["--no-extensions", "--no-skills", "--no-mcp", "--no-context-files", "--no-prompt-templates"] : await agentSpawnArgs(this.agents.promptDir, agent, { extraAllowedTools: [...(extensionArgs.length ? [TASK_TOOL_NAME, TODO_TOOL_NAME, WORKFLOW_TOOL_NAME, RUN_ASYNC_TOOL_NAME, "question", "tool_register"] : []), ...(memoryEnabled ? ["memory", "skill_manage", "session_search"] : []), ...(knowledgeEnabled ? [KNOWLEDGE_TOOL_NAME] : [])] });
+        const agentArgs = memoryReview ? ["--no-extensions", "--no-skills", "--no-mcp", "--no-context-files", "--no-prompt-templates", "--tools", "memory,skill_manage,session_search"] : knowledgeRerank ? ["--no-extensions", "--no-skills", "--no-mcp", "--no-context-files", "--no-prompt-templates"] : await agentSpawnArgs(this.agents.promptDir, agent, { extraAllowedTools: [...(extensionArgs.length ? [TASK_TOOL_NAME, TODO_TOOL_NAME, WORKFLOW_TOOL_NAME, RUN_ASYNC_TOOL_NAME, SCHEDULED_TASK_TOOL_NAME, "question", "tool_register"] : []), ...(memoryEnabled ? ["memory", "skill_manage", "session_search"] : []), ...(knowledgeEnabled ? [KNOWLEDGE_TOOL_NAME, KNOWLEDGE_IMPORT_TOOL_NAME] : []), ...(documentsEnabled ? [DOCUMENT_READ_TOOL_NAME, DOCUMENT_WRITE_TOOL_NAME] : []), ...(webEnabled ? [WEB_SEARCH_TOOL_NAME, WEB_FETCH_TOOL_NAME] : []), ...(feishuEnabled ? [FEISHU_READ_TOOL_NAME, FEISHU_WRITE_TOOL_NAME] : [])] });
         // Refused here, with the reason, rather than handed to the spawn: an ENOENT from `spawn` reads as
         // "the app is broken" and hides the one fact that matters, which is where it looked for Pi.
         if (!this.pi.found)
             throw new Error(this.pi.reason);
         // npm exposes global CLIs as .cmd shims on Windows; Node requires a shell to launch those shims.
-        const child = spawn(shellQuote(this.pi.command), ["--mode", "rpc", "--session-dir", this.sessionDir, "--session-id", conversation.id, ...extensionArgs, ...memoryArgs, ...knowledgeArgs, ...agentArgs], {
+        const child = spawn(shellQuote(this.pi.command), ["--mode", "rpc", "--session-dir", this.sessionDir, "--session-id", conversation.id, ...extensionArgs, ...memoryArgs, ...knowledgeArgs, ...documentArgs, ...webArgs, ...feishuArgs, ...agentArgs], {
             cwd: childCwd,
             stdio: ["pipe", "pipe", "pipe"],
             shell: process.platform === "win32",
@@ -1146,13 +1311,26 @@ export class PiRpcRuntime {
             // every turn would silently replace the child's environment with whatever THIS process has at
             // spawn time. Inheriting is what an omitted `env` already does, so the two paths differ in nothing
             // but the four documented additions.
-            ...((extensionArgs.length || memoryEnabled || knowledgeEnabled) ? { env: { ...process.env, ...(extensionArgs.length ? await this.oneShotExtensionEnv(conversation.id) : {}), ...(memoryEnabled ? {
+            ...((extensionArgs.length || memoryEnabled || knowledgeEnabled || documentsEnabled || webEnabled || feishuEnabled) ? { env: { ...process.env, ...(oneShotCapability ? await this.oneShotExtensionEnv(conversation.id, oneShotCapability) : {}), ...(memoryEnabled ? {
                         SUPER_PI_MEMORY_ENDPOINT: process.env.SUPER_PI_MEMORY_ENDPOINT,
                         SUPER_PI_MEMORY_TOKEN: memoryToken,
                         SUPER_PI_MEMORY_REVIEW: memoryReview ? "1" : "0",
                     } : {}), ...(knowledgeEnabled ? {
                         SUPER_PI_KNOWLEDGE_ENDPOINT: process.env.SUPER_PI_KNOWLEDGE_ENDPOINT,
                         SUPER_PI_KNOWLEDGE_TOKEN: knowledgeToken,
+                    } : {}), ...(documentsEnabled ? {
+                        SUPER_PI_DOCUMENTS_ENDPOINT: this.options.documentsEndpoint ?? "",
+                        // The document tools carry the SESSION's capability, the same credential the task dispatch
+                        // uses: it proves which conversation is asking, and the server checks that the turn is
+                        // running. The conversation id travels with it, because the workspace is derived from the
+                        // conversation and never from the request.
+                        //
+                        // IT IS THE SAME VALUE THE TASK EXTENSION GETS. A one-shot child has no session to borrow a
+                        // credential from, so the token is minted for the turn - and minted ONCE, because the server
+                        // holds one capability per conversation and a second mint would replace the first in the
+                        // map, leaving the task dispatch holding a token the server had already forgotten.
+                        SUPER_PI_DOCUMENTS_TOKEN: oneShotCapability ?? "",
+                        SUPER_PI_DOCUMENTS_CONVERSATION: conversation.id,
                     } : {}) } } : {}),
         });
         const channel = new RpcChannel(child);
@@ -2070,7 +2248,11 @@ export class PiRpcRuntime {
             // A model asked for "only the title" still wraps it now and then. Stripping the wrappers is not
             // cosmetic: without it a leading quote or a `Title:` prefix becomes the first characters of every
             // title in the sidebar.
-            const title = text
+            //
+            // AND THE MODEL'S OWN REASONING IS STRIPPED FIRST, because a model that thinks inside its
+            // answer puts the thinking in front of the title: the title would then start with `<think>`,
+            // and the sidebar would show the markup of a reasoning trace where a label belongs.
+            const title = stripInlineThinking(text)
                 .replace(/^\s*(?:title|标题)\s*[:：]\s*/iu, "")
                 .replace(/^[`"'“”‘’「『]+/u, "")
                 .replace(/[`"'“”‘’」』]+$/u, "")
@@ -2125,9 +2307,13 @@ export class PiRpcRuntime {
             }
             if (!settled)
                 throw new Error(`模型在 ${Math.round(input.timeoutMs / 1000)} 秒内没有返回`);
-            if (!text.trim())
+            // THE MODEL'S OWN REASONING IS NOT THE TOOL'S OUTPUT. A model that thinks inside its answer
+            // would otherwise hand the caller a `<think>`-prefixed string, and the caller - a tool, a
+            // title, a card - would store the reasoning trace as its result.
+            const answer = stripInlineThinking(text);
+            if (!answer.trim())
                 throw new Error("模型没有返回任何内容");
-            return text;
+            return answer;
         }
         finally {
             if (child.exitCode === null && child.pid !== undefined)

package/dist/server/scheduled-tasks.d.ts

@@ -0,0 +1,101 @@
+import type { ModelSelection } from "./types.js";
+/**
+ * WHEN A SCHEDULED TASK RUNS.
+ *
+ * FOUR SHAPES, AND NOT A CRON EXPRESSION. A cron string would bring a parser, a timezone story and a
+ * daylight-saving story to a panel that runs on the same machine as the server - and the two shapes
+ * people actually ask for are "every N minutes" and "every day at HH:MM". The set is closed on purpose:
+ * a schedule that cannot be expressed here is not a schedule the panel can edit, and the panel is the
+ * only place a user can see what they are agreeing to.
+ *
+ * - `interval`: every N minutes. The interval is anchored on the last run, not on the wall clock, so a
+ *   task that takes four minutes to run does not slowly drift later every cycle.
+ * - `daily`: every day at a local `HH:MM`.
+ * - `weekly`: on the listed weekdays (0 = Sunday) at a local `HH:MM`.
+ * - `once`: at one instant. The task is finished after it fires.
+ *
+ * THE TIME IS LOCAL, not UTC and not a named zone, because the server and the panel are the same
+ * machine for every installation that exists. A "09:00" that means something different in the panel
+ * than in the scheduler would be the worst possible bug in this feature: it would fire at the wrong
+ * hour and look like it had fired at the right one.
+ */
+export type ScheduleSpec = {
+    kind: "interval";
+    everyMinutes: number;
+} | {
+    kind: "daily";
+    time: string;
+} | {
+    kind: "weekly";
+    weekdays: number[];
+    time: string;
+} | {
+    kind: "once";
+    at: number;
+};
+/**
+ * ONE SCHEDULED TASK: a prompt, a model to run it with, and when to run it.
+ *
+ * `conversationId` is the task's OWN conversation, created lazily on the first run. The task never runs
+ * in somebody else's conversation: a scheduled run that landed in the user's working session would
+ * interleave with what they were doing, and would change that session's model out from under it.
+ */
+export type ScheduledTask = {
+    id: string;
+    name: string;
+    /** The instruction, sent VERBATIM as the user message of the task's conversation. */
+    prompt: string;
+    /** The workspace the task belongs to: it decides the working directory and the defaults. */
+    workspaceId: string;
+    /** The task's own conversation, created on the first run. Absent until then. */
+    conversationId?: string;
+    /** Overrides the workspace's default agent. */
+    agentId?: string;
+    /** Overrides the workspace's default model. A `provider`/`modelId` PAIR, never half of one. */
+    model?: ModelSelection;
+    schedule: ScheduleSpec;
+    enabled: boolean;
+    /** When the task fires next, in epoch milliseconds. Absent for a finished one-shot task. */
+    nextRunAt?: number;
+    lastRunAt?: number;
+    lastRunStatus?: "completed" | "failed" | "skipped";
+    lastRunMessage?: string;
+    /** Whether a person or the agent created it. Both are editable by both. */
+    createdBy: "user" | "agent";
+    createdAt: number;
+    updatedAt: number;
+};
+/** The shortest interval a task may ask for. A one-minute floor is what makes a task a task. */
+export declare const MIN_INTERVAL_MINUTES = 1;
+/** The longest interval: a week. Anything longer is a calendar arrangement, not an interval. */
+export declare const MAX_INTERVAL_MINUTES: number;
+/**
+ * Reads a schedule out of whatever a caller sent, or explains why it cannot.
+ *
+ * THE SERVER OWNS THIS, and the extension on the other side of the wire deliberately does NOT have a
+ * copy of it. The extension hands over what the model wrote; this function decides what it means. A
+ * second implementation on the extension side would be a second opinion about the same wire, and the two
+ * would disagree the first time a model wrote a schedule in a shape one of them accepted and the other
+ * did not - with the model's mistake showing up as a server error it cannot explain.
+ */
+export declare function normalizeSchedule(raw: unknown): ScheduleSpec;
+/**
+ * WHEN THE TASK FIRES NEXT, given a moment to look forward from.
+ *
+ * `undefined` means "never again": a one-shot task whose moment has passed.
+ *
+ * The daily and weekly cases walk forward day by day in LOCAL time rather than adding 24 hours, so a
+ * schedule at 09:00 stays at 09:00 across a daylight-saving change instead of drifting to 08:00 or
+ * 10:00 for half the year.
+ */
+export declare function nextRunAt(spec: ScheduleSpec, from: number): number | undefined;
+/**
+ * THE SCHEDULE IN WORDS, for the panel and for the text the agent reads back.
+ *
+ * One implementation for both readers, because two descriptions of one schedule would eventually say
+ * two different things - and the agent's description is what the user is told when the agent says
+ * "I set up a daily task". If the two disagreed, the user would find out from the clock.
+ */
+export declare function describeSchedule(spec: ScheduleSpec): string;
+/** A moment as `YYYY-MM-DD HH:MM`, in local time. */
+export declare function formatMoment(ms: number): string;

package/dist/server/scheduled-tasks.js

@@ -0,0 +1,138 @@
+/** The shortest interval a task may ask for. A one-minute floor is what makes a task a task. */
+export const MIN_INTERVAL_MINUTES = 1;
+/** The longest interval: a week. Anything longer is a calendar arrangement, not an interval. */
+export const MAX_INTERVAL_MINUTES = 60 * 24 * 7;
+/**
+ * Reads a schedule out of whatever a caller sent, or explains why it cannot.
+ *
+ * THE SERVER OWNS THIS, and the extension on the other side of the wire deliberately does NOT have a
+ * copy of it. The extension hands over what the model wrote; this function decides what it means. A
+ * second implementation on the extension side would be a second opinion about the same wire, and the two
+ * would disagree the first time a model wrote a schedule in a shape one of them accepted and the other
+ * did not - with the model's mistake showing up as a server error it cannot explain.
+ */
+export function normalizeSchedule(raw) {
+    if (!raw || typeof raw !== "object")
+        throw new Error("周期必须是一个对象：{\"kind\":\"interval\",\"everyMinutes\":30} 这样写。");
+    const value = raw;
+    const kind = typeof value.kind === "string" ? value.kind.trim() : "";
+    if (kind === "interval") {
+        const everyMinutes = Number(value.everyMinutes);
+        if (!Number.isFinite(everyMinutes) || !Number.isInteger(everyMinutes))
+            throw new Error("每隔 N 分钟需要一个整数分钟数。");
+        if (everyMinutes < MIN_INTERVAL_MINUTES || everyMinutes > MAX_INTERVAL_MINUTES) {
+            throw new Error(`间隔分钟数要在 ${MIN_INTERVAL_MINUTES} 到 ${MAX_INTERVAL_MINUTES} 之间。`);
+        }
+        return { kind: "interval", everyMinutes };
+    }
+    if (kind === "daily")
+        return { kind: "daily", time: normalizeTime(value.time) };
+    if (kind === "weekly") {
+        const weekdays = normalizeWeekdays(value.weekdays);
+        return { kind: "weekly", weekdays, time: normalizeTime(value.time) };
+    }
+    if (kind === "once") {
+        const at = Number(value.at);
+        if (!Number.isFinite(at) || at <= 0)
+            throw new Error("一次性任务需要一个触发时刻（毫秒时间戳）。");
+        return { kind: "once", at };
+    }
+    throw new Error("周期只能是 interval（每隔 N 分钟）、daily（每天）、weekly（每周）或 once（仅一次）。");
+}
+/** `HH:MM`, twenty-four hour, leading zero or not. The only time shape this feature accepts. */
+function normalizeTime(raw) {
+    if (typeof raw !== "string")
+        throw new Error("触发时刻要写成 \"HH:MM\"，比如 \"09:00\"。");
+    const match = /^(\d{1,2}):(\d{2})$/.exec(raw.trim());
+    if (!match)
+        throw new Error("触发时刻要写成 \"HH:MM\"，比如 \"09:00\"。");
+    const hours = Number(match[1]);
+    const minutes = Number(match[2]);
+    if (hours > 23 || minutes > 59)
+        throw new Error("触发时刻不是一个真实的时间。");
+    return `${String(hours).padStart(2, "0")}:${String(minutes).padStart(2, "0")}`;
+}
+/** The weekdays of a weekly schedule, sorted and deduplicated. An empty list means every day. */
+function normalizeWeekdays(raw) {
+    if (!Array.isArray(raw))
+        throw new Error("每周任务需要给出星期几，比如 [1,3] 表示周一和周三。");
+    const days = Array.from(new Set(raw.map((item) => Number(item)).filter((item) => Number.isInteger(item) && item >= 0 && item <= 6)));
+    if (!days.length)
+        throw new Error("每周任务至少要有一天。");
+    return days.sort((a, b) => a - b);
+}
+/**
+ * WHEN THE TASK FIRES NEXT, given a moment to look forward from.
+ *
+ * `undefined` means "never again": a one-shot task whose moment has passed.
+ *
+ * The daily and weekly cases walk forward day by day in LOCAL time rather than adding 24 hours, so a
+ * schedule at 09:00 stays at 09:00 across a daylight-saving change instead of drifting to 08:00 or
+ * 10:00 for half the year.
+ */
+export function nextRunAt(spec, from) {
+    if (spec.kind === "interval")
+        return from + spec.everyMinutes * 60_000;
+    if (spec.kind === "once")
+        return spec.at > from ? spec.at : undefined;
+    if (spec.kind === "daily")
+        return nextDailyAt(spec.time, from);
+    return nextWeeklyAt(spec.weekdays, spec.time, from);
+}
+/** The next moment at `HH:MM` strictly after `from`, in local time. */
+function nextDailyAt(time, from) {
+    const [hours, minutes] = time.split(":").map(Number);
+    const candidate = new Date(from);
+    candidate.setHours(hours, minutes, 0, 0);
+    if (candidate.getTime() <= from)
+        candidate.setDate(candidate.getDate() + 1);
+    return candidate.getTime();
+}
+/**
+ * The next moment at `HH:MM` on one of `weekdays`, strictly after `from`, in local time.
+ *
+ * At most eight days are examined, which covers every weekday list including an empty one: an empty
+ * list means "every day", and the daily case is a special case of it.
+ */
+function nextWeeklyAt(weekdays, time, from) {
+    const days = weekdays.length ? weekdays : [0, 1, 2, 3, 4, 5, 6];
+    const [hours, minutes] = time.split(":").map(Number);
+    for (let offset = 0; offset <= 7; offset += 1) {
+        const candidate = new Date(from);
+        candidate.setDate(candidate.getDate() + offset);
+        candidate.setHours(hours, minutes, 0, 0);
+        if (candidate.getTime() <= from)
+            continue;
+        if (days.includes(candidate.getDay()))
+            return candidate.getTime();
+    }
+    // Unreachable: within eight days every weekday in a full week comes round. The fallback keeps the
+    // function total rather than returning `undefined` for a shape that cannot happen.
+    return nextDailyAt(time, from);
+}
+/**
+ * THE SCHEDULE IN WORDS, for the panel and for the text the agent reads back.
+ *
+ * One implementation for both readers, because two descriptions of one schedule would eventually say
+ * two different things - and the agent's description is what the user is told when the agent says
+ * "I set up a daily task". If the two disagreed, the user would find out from the clock.
+ */
+export function describeSchedule(spec) {
+    if (spec.kind === "interval")
+        return `每隔 ${spec.everyMinutes} 分钟`;
+    if (spec.kind === "daily")
+        return `每天 ${spec.time}`;
+    if (spec.kind === "weekly")
+        return `每周${spec.weekdays.map(weekdayName).join("、")} ${spec.time}`;
+    return `仅一次：${formatMoment(spec.at)}`;
+}
+/** 0 = Sunday, which is what `Date.getDay()` says. */
+function weekdayName(day) {
+    return ["日", "一", "二", "三", "四", "五", "六"][day] ?? "?";
+}
+/** A moment as `YYYY-MM-DD HH:MM`, in local time. */
+export function formatMoment(ms) {
+    const date = new Date(ms);
+    const pad = (value) => String(value).padStart(2, "0");
+    return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} ${pad(date.getHours())}:${pad(date.getMinutes())}`;
+}

package/dist/server/server-context.d.ts

@@ -39,6 +39,17 @@ export interface EventBroadcaster {
 export interface ServerContext {
     memory?: import("./active-memory.js").ActiveMemory;
     knowledge?: import("./knowledge.js").KnowledgeBase;
+    web?: import("./web.js").WebService;
+    /** The agent-facing document tools. Optional so the server can start without them. */
+    documentService?: import("./application/document-service.js").DocumentService;
+    /**
+     * THE FEISHU TOOLS.
+     *
+     * Optional because the credential may be missing, not because the feature may be missing: the
+     * service is always constructed, and a call made before the credential is configured is refused
+     * with the message that says what to do - which a missing service could not say.
+     */
+    feishu?: import("./application/feishu-service.js").FeishuService;
     paths: ServerPaths;
     store: Store;
     runtime: AgentRuntime;
@@ -52,6 +63,14 @@ export interface ServerContext {
     catalogService: CatalogService;
     /** The providers a person added through the settings window. */
     providerService: ProviderService;
+    /**
+     * The scheduled tasks and the clock behind them.
+     *
+     * In the context because TWO layers need it: the command handler routes the panel's five commands
+     * into it, and the HTTP layer exposes the agent-facing endpoint that lets a running turn create a
+     * task of its own.
+     */
+    scheduledTaskService?: import("./application/scheduled-task-service.js").ScheduledTaskService;
     execService: ExecService;
     toolRegistry: ToolRegistry;
     toolRunner: ToolRunner;