@ynhcj/xiaoyi-channel 1.1.19 → 1.1.21

package/dist/src/provider.js

@@ -9,6 +9,226 @@
 //   models.providers.xiaoyiprovider.models = [...]
 import { createHash } from "crypto";
 import { getCurrentSessionContext } from "./tools/session-manager.js";
+import { selfEvolutionManager } from "./utils/self-evolution-manager.js";
+// ── Retry config ──────────────────────────────────────────────
+const RETRY_DELAYS_MS = [10_000, 20_000, 40_000, 60_000, 60_000];
+const MAX_RETRY_ATTEMPTS = 5;
+/** Check if an errorMessage indicates a retryable provider error by type. */
+function isRetryableProviderError(message) {
+    if (!message)
+        return false;
+    const lower = message.toLowerCase();
+    if (lower.includes("the server had an error while processing your request"))
+        return true;
+    if (lower.includes("rate limit reached for requests"))
+        return true;
+    if (lower.includes("现在访问有点拥挤，稍等一下再试会更顺畅哦～"))
+        return true;
+    return false;
+}
+/** Check if the request is triggered by a cron job by inspecting the first user message. */
+function isCronTriggered(messages) {
+    if (!messages)
+        return false;
+    const firstUser = messages.find(m => m.role === "user");
+    if (!firstUser)
+        return false;
+    let text = "";
+    if (typeof firstUser.content === "string") {
+        text = firstUser.content;
+    }
+    else if (Array.isArray(firstUser.content)) {
+        const block = firstUser.content.find(b => b.type === "text" && typeof b.text === "string");
+        if (block)
+            text = block.text;
+    }
+    return /^\[cron:/i.test(text.trim());
+}
+/** Extract cron title from first user message matching `[cron:<uuid> <title>]`. */
+function extractCronTitle(messages) {
+    if (!messages)
+        return undefined;
+    const firstUser = messages.find(m => m.role === "user");
+    if (!firstUser)
+        return undefined;
+    let text = "";
+    if (typeof firstUser.content === "string") {
+        text = firstUser.content;
+    }
+    else if (Array.isArray(firstUser.content)) {
+        const block = firstUser.content.find(b => b.type === "text" && typeof b.text === "string");
+        if (block)
+            text = block.text;
+    }
+    const match = text.trim().match(/^\[cron:[^\s]+\s+(.+)\]$/);
+    return match ? match[1] : undefined;
+}
+/** Compute retry delay in ms for the given 1-based attempt, with up to 10s jitter. */
+function getRetryDelayMs(attempt, isCron = false) {
+    if (isCron) {
+        return 60_000 + Math.floor(Math.random() * 10_000);
+    }
+    const base = attempt <= RETRY_DELAYS_MS.length
+        ? RETRY_DELAYS_MS[attempt - 1]
+        : RETRY_DELAYS_MS[RETRY_DELAYS_MS.length - 1];
+    const jitter = Math.floor(Math.random() * 10_000);
+    return base + jitter;
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Build a minimal EventStream-compatible object that replays a single
+ * done/error event. This avoids importing @mariozechner/pi-ai at runtime
+ * (the package is not available in the extension sandbox).
+ */
+function buildReplayStream(result) {
+    let settled = false;
+    const queued = [
+        result.stopReason === "error"
+            ? { type: "error", reason: "error", error: result }
+            : { type: "done", reason: result.stopReason, message: result },
+    ];
+    return {
+        result: () => Promise.resolve(result),
+        push: () => { },
+        end: () => { },
+        [Symbol.asyncIterator]: () => {
+            return {
+                next: async () => {
+                    if (settled || queued.length === 0) {
+                        settled = true;
+                        return { value: undefined, done: true };
+                    }
+                    settled = true;
+                    return { value: queued.shift(), done: false };
+                },
+            };
+        },
+    };
+}
+/**
+ * Wrap the underlying stream with retry logic while preserving real-time streaming.
+ *
+ * Strategy:
+ *  1. Buffer events until the first content-bearing event is seen.
+ *  2. If the stream errors before any content, the buffer is tiny (start + error)
+ *     and we can safely retry with a fresh API call.
+ *  3. Once content events appear, flush the buffer and switch to pass-through mode
+ *     — the consumer sees every text_delta in real time.
+ */
+function createRetryingStream(createStream, cronJob) {
+    let resultResolve;
+    const resultPromise = new Promise(resolve => { resultResolve = resolve; });
+    const CONTENT_EVENT_TYPES = new Set([
+        "text_start", "text_delta", "text_end",
+        "thinking_start", "thinking_delta", "thinking_end",
+        "toolcall_start", "toolcall_delta", "toolcall_end",
+    ]);
+    async function* retryGenerator() {
+        for (let attempt = 0; attempt < MAX_RETRY_ATTEMPTS; attempt++) {
+            const stream = await createStream();
+            let hasContent = false;
+            const buffer = [];
+            let errorResult = null;
+            for await (const event of stream) {
+                const isContent = CONTENT_EVENT_TYPES.has(event.type);
+                if (!hasContent && !isContent) {
+                    // ── Buffer phase (no content yet) ──
+                    if (event.type === "done") {
+                        console.log(`[xiaoyiprovider] stream completed (no content), usage: input=${event.message?.usage?.input} output=${event.message?.usage?.output}`);
+                        for (const b of buffer)
+                            yield b;
+                        resultResolve(event.message);
+                        yield event;
+                        return;
+                    }
+                    if (event.type === "error") {
+                        errorResult = event.error;
+                    }
+                    buffer.push(event);
+                }
+                else {
+                    // ── Streaming phase ──
+                    if (!hasContent) {
+                        console.log("[xiaoyiprovider] first content event received, switching to streaming mode");
+                        hasContent = true;
+                        for (const b of buffer)
+                            yield b;
+                    }
+                    // IMPORTANT: resolve result() BEFORE yielding terminal events to avoid deadlock.
+                    // The SDK calls result() when it sees done/error — if we yield first, the generator
+                    // suspends and can never reach resolve, causing a permanent deadlock.
+                    if (event.type === "done") {
+                        console.log(`[xiaoyiprovider] stream completed, usage: input=${event.message?.usage?.input} output=${event.message?.usage?.output}`);
+                        resultResolve(event.message);
+                        yield event;
+                        return;
+                    }
+                    if (event.type === "error") {
+                        console.log(`[xiaoyiprovider] stream error after content: ${event.error?.errorMessage}`);
+                        resultResolve(event.error);
+                        yield event;
+                        return;
+                    }
+                    yield event;
+                }
+            }
+            // Stream ended during buffer phase — decide whether to retry
+            if (errorResult?.stopReason === "error" && isRetryableProviderError(errorResult.errorMessage)) {
+                if (attempt < MAX_RETRY_ATTEMPTS - 1) {
+                    const delayMs = getRetryDelayMs(attempt + 1, cronJob);
+                    console.log(`[xiaoyiprovider] retryable error (attempt ${attempt + 1}/${MAX_RETRY_ATTEMPTS}): ` +
+                        `${errorResult.errorMessage} — retrying in ${delayMs}ms`);
+                    await sleep(delayMs);
+                    continue; // discard buffer, retry with a new stream
+                }
+                console.log(`[xiaoyiprovider] all ${MAX_RETRY_ATTEMPTS} retries exhausted, surfacing last error`);
+            }
+            else if (errorResult) {
+                console.log(`[xiaoyiprovider] non-retryable error: ${errorResult.errorMessage}`);
+            }
+            // Non-retryable or retries exhausted — yield buffered events.
+            // Resolve before yielding the terminal event to avoid the same deadlock.
+            for (const b of buffer) {
+                if (b.type === "done") {
+                    resultResolve(b.message);
+                }
+                else if (b.type === "error") {
+                    resultResolve(b.error);
+                }
+                yield b;
+            }
+            if (errorResult && buffer.every(b => b.type !== "done" && b.type !== "error")) {
+                resultResolve(errorResult);
+            }
+            return;
+        }
+        // Safety: final fallback attempt
+        console.log("[xiaoyiprovider] entering final fallback attempt");
+        const lastStream = await createStream();
+        for await (const event of lastStream) {
+            if (event.type === "done") {
+                resultResolve(event.message);
+                yield event;
+                return;
+            }
+            if (event.type === "error") {
+                resultResolve(event.error);
+                yield event;
+                return;
+            }
+            yield event;
+        }
+    }
+    const gen = retryGenerator();
+    return {
+        result: () => resultPromise,
+        push: () => { },
+        end: () => { },
+        [Symbol.asyncIterator]: () => gen,
+    };
+}
 /**
  * Dynamic header keys injected via extraParams and forwarded to the HTTP request.
  * Correspond to the three fields written to .xiaoyiruntime:
@@ -17,6 +237,41 @@ import { getCurrentSessionContext } from "./tools/session-manager.js";
 const HEADER_TRACE_ID = "x-hag-trace-id";
 const HEADER_SESSION_ID = "x-session-id";
 const HEADER_INTERACTION_ID = "x-interaction-id";
+/** Internal key for passing fallback uid prefix from prepareExtraParams to wrapStreamFn. */
+const FALLBACK_PREFIX_KEY = "_xiaoyi_fallback_prefix";
+const SELF_EVOLUTION_PROMPT_BEGIN = "<self_evolution_prompt>";
+const SELF_EVOLUTION_PROMPT_END = "</self_evolution_prompt>";
+const SELF_EVOLUTION_ENABLED_PROMPT_SECTION = `
+${SELF_EVOLUTION_PROMPT_BEGIN}
+## Self Evolution(CRITICAL)
+用户已启用自进化(不管之前是什么状态，不管之前的对话记录，当前视作已开启即可)。
+自进化含义：当你识别出某个稳定、可复用的经验、调试模式或工作流程，并且它很可能对未来完成此用户的同类任务有帮助时，你可以考虑将其保存为可复用的经验。
+
+[触发条件]
+当满足以下任意一项时，必须触发自进化流程：
+- 显式指令与关键词匹配（最高优先级）：当用户消息中包含“进化”、“下次应该”、“以后必须”、“永远”等表达长期意图的词汇，或伴随明显的行为纠正、流程规范化或交付标准设定的指导动作等。
+- 主动固化要求：用户主动要求将过去的交互经验（如交付件规格、skill选择、任务工作流等）进行沉淀/自进化。
+- 隐式经验与避坑沉淀：当前任务执行过程中，你识别出了可以持久化为长期经验的标准工作流，或者在执行中遇到了工具调用错误、命令参数错误等明确的“踩坑点”，以后需要规避。
+
+[触发后处理]
+- 遵循 "xiaoyi-self-evolution" 技能指导逐步进行技能评估。
+- 只能在任务完成后，正式回复用户前读取该技能。
+- 禁止直接修改文件。需要先创建提案，向用户发送进化请求，用户同意后才能进行更改。
+${SELF_EVOLUTION_PROMPT_END}
+`.trim();
+const SELF_EVOLUTION_DISABLED_PROMPT_SECTION = `
+${SELF_EVOLUTION_PROMPT_BEGIN}
+## Self Evolution
+用户当前已禁用自我进化。
+你不得执行自进化相关行为，并且应将此功能视为不可用(不管之前是什么状态，不管之前的对话记录，当前视作已关闭即可)。
+${SELF_EVOLUTION_PROMPT_END}
+`.trim();
+function stripSelfEvolutionPrompt(prompt) {
+    return prompt
+        .replace(/\n*<self_evolution_prompt>[\s\S]*?<\/self_evolution_prompt>\n*/gu, "\n\n")
+        .replace(/\n{3,}/gu, "\n\n")
+        .trim();
+}
 /**
  * Encode uid via SHA-256 and take first 32 hex chars.
  */
@@ -57,26 +312,25 @@ export const xiaoyiProvider = {
                 [HEADER_INTERACTION_ID]: interactionId,
             };
         }
-        // Fallback: uid-based values
+        // Fallback: store uid prefix for lazy timestamp generation in wrapStreamFn.
+        // This ensures each model call gets a fresh timestamp instead of reusing
+        // the same one across tool-use loops and retries.
         const uid = getUidFromConfig(ctx.config);
         if (!uid)
             return undefined;
-        const prefix = encodeUid(uid);
-        const ts = Date.now();
-        const fallbackValue = `${prefix}_${ts}`;
         return {
             ...ctx.extraParams,
-            [HEADER_TRACE_ID]: fallbackValue,
-            [HEADER_SESSION_ID]: fallbackValue,
-            [HEADER_INTERACTION_ID]: fallbackValue,
+            [FALLBACK_PREFIX_KEY]: encodeUid(uid),
         };
     },
     /**
      * Wrap the stream function to inject dynamic headers into every
-     * HTTP request to the model provider.
+     * HTTP request to the model provider, and retry on retryable errors
+     * (server_error / rate_limit_error) with backoff: 10s, 20s, 40s, 60s (cap).
      *
-     * Reads the values injected by prepareExtraParams and adds them
-     * as HTTP headers on the outgoing request.
+     * The retry loop awaits stream.result() to detect errors before deciding
+     * whether to retry. This keeps the agent loop waiting (no timeout risk
+     * since the default agent timeout is 48 hours).
      */
     wrapStreamFn: (ctx) => {
         const underlying = ctx.streamFn;
@@ -86,21 +340,50 @@ export const xiaoyiProvider = {
             // 每次请求时从 ctx.extraParams 动态读取 header
             const dynamicHeaders = {};
             if (ctx.extraParams) {
-                const traceId = ctx.extraParams[HEADER_TRACE_ID];
-                const sessionId = ctx.extraParams[HEADER_SESSION_ID];
-                const interactionId = ctx.extraParams[HEADER_INTERACTION_ID];
-                if (typeof traceId === "string")
-                    dynamicHeaders[HEADER_TRACE_ID] = traceId;
-                if (typeof sessionId === "string")
-                    dynamicHeaders[HEADER_SESSION_ID] = sessionId;
-                if (typeof interactionId === "string")
-                    dynamicHeaders[HEADER_INTERACTION_ID] = interactionId;
+                const fallbackPrefix = ctx.extraParams[FALLBACK_PREFIX_KEY];
+                if (typeof fallbackPrefix === "string") {
+                    // Fallback mode: generate fresh timestamp per request
+                    const isCron = isCronTriggered(context.messages);
+                    const fallbackValue = `${fallbackPrefix}_${Date.now()}`;
+                    dynamicHeaders[HEADER_TRACE_ID] = isCron ? `cron_${fallbackValue}` : fallbackValue;
+                    dynamicHeaders[HEADER_SESSION_ID] = fallbackValue;
+                    dynamicHeaders[HEADER_INTERACTION_ID] = fallbackValue;
+                    if (isCron) {
+                        const cronTitle = extractCronTitle(context.messages);
+                        if (cronTitle)
+                            dynamicHeaders["x-cron-title"] = cronTitle;
+                        if (context.messages?.length === 1)
+                            dynamicHeaders["x-cron-flag"] = "begin";
+                    }
+                }
+                else {
+                    // Session mode: use pre-resolved session headers + fresh timestamp
+                    const traceId = ctx.extraParams[HEADER_TRACE_ID];
+                    const sessionId = ctx.extraParams[HEADER_SESSION_ID];
+                    const interactionId = ctx.extraParams[HEADER_INTERACTION_ID];
+                    if (typeof traceId === "string") {
+                        const isCron = isCronTriggered(context.messages);
+                        dynamicHeaders[HEADER_TRACE_ID] = isCron ? `cron_${traceId}_${Date.now()}` : traceId;
+                        if (isCron) {
+                            const cronTitle = extractCronTitle(context.messages);
+                            if (cronTitle)
+                                dynamicHeaders["x-cron-title"] = cronTitle;
+                            if (context.messages?.length === 1)
+                                dynamicHeaders["x-cron-flag"] = "begin";
+                        }
+                    }
+                    if (typeof sessionId === "string")
+                        dynamicHeaders[HEADER_SESSION_ID] = sessionId;
+                    if (typeof interactionId === "string")
+                        dynamicHeaders[HEADER_INTERACTION_ID] = interactionId;
+                }
             }
             // 记录输入
             console.log(`[xiaoyiprovider] input messages count: ${context.messages?.length ?? 0}`);
             if (context.systemPrompt) {
                 console.log(`[xiaoyiprovider] system prompt length: ${context.systemPrompt.length}`);
             }
+            const sessionCtx = getCurrentSessionContext();
             // 在发送给模型前，优化 systemPrompt 结构
             if (context.systemPrompt) {
                 let sp = context.systemPrompt;
@@ -130,26 +413,35 @@ export const xiaoyiProvider = {
                 console.log(`[xiaoyiprovider] system prompt optimized: ${beforeLen} -> ${sp.length}`);
                 context.systemPrompt = sp;
             }
+            const selfEvolutionEnabled = await selfEvolutionManager.isEnabled();
+            const prompt = stripSelfEvolutionPrompt(context.systemPrompt ?? "");
+            context.systemPrompt = [
+                prompt,
+                selfEvolutionEnabled
+                    ? SELF_EVOLUTION_ENABLED_PROMPT_SECTION
+                    : SELF_EVOLUTION_DISABLED_PROMPT_SECTION,
+            ]
+                .filter(Boolean)
+                .join("\n\n");
             // Append device context to systemPrompt
-            const sessionCtx = getCurrentSessionContext();
             if (sessionCtx?.deviceType) {
                 const rawDevice = sessionCtx.deviceType;
                 const displayDevice = (rawDevice === "2in1") ? "鸿蒙PC" : rawDevice;
-                const deviceSection = `\n\n## Current User Device Context\nThe current user is using the following device: ${displayDevice}\nYou need to be aware of the user’s current device and provide guidance accordingly. If the response involves device-related tools or actions, you must tailor the reply based on the user’s current device, using device-specific references such as “saved to the Notes/Calendar on your {deviceType}.\n”`;
+                const deviceSection = `\n\n## Current User Device Context\nThe current user is using the following device: ${displayDevice}\nYou need to be aware of the user's current device and provide guidance accordingly. If the response involves device-related tools or actions, you must tailor the reply based on the user's current device, using device-specific references such as "saved to the Notes/Calendar on your {deviceType}.\n"`;
                 context.systemPrompt = (context.systemPrompt ?? "") + deviceSection;
             }
-            const stream = await underlying(model, context, {
+            // ── Retry-capable streaming ──────────────────────────────
+            const cronJob = isCronTriggered(context.messages);
+            if (cronJob)
+                console.log("[xiaoyiprovider] detected cron-triggered request, using extended retry delays");
+            const makeStream = () => underlying(model, context, {
                 ...options,
                 headers: {
                     ...options?.headers,
                     ...dynamicHeaders,
                 },
             });
-            // 异步监听输出（不阻塞 stream 返回）
-            stream.result().then((result) => {
-                console.log(`[xiaoyiprovider] stream completed, usage: input=${result.usage?.input} output=${result.usage?.output}`);
-            }, (err) => console.log(`[xiaoyiprovider] stream error: ${JSON.stringify(err)}`));
-            return stream;
+            return createRetryingStream(makeStream, cronJob);
         };
     },
 };

package/dist/src/self-evolution-handler.d.ts

@@ -0,0 +1 @@
+export declare function handleSelfEvolutionEvent(context: any, runtime: any): void;

package/dist/src/self-evolution-handler.js

@@ -0,0 +1,47 @@
+import { readFileSync, writeFileSync } from "fs";
+const XIAOYIRUNTIME_PATH = "/home/sandbox/.openclaw/.xiaoyiruntime";
+export function handleSelfEvolutionEvent(context, runtime) {
+    const log = runtime?.log ?? console.log;
+    const error = runtime?.error ?? console.error;
+    try {
+        const state = context.event?.payload?.selfEvolutionState;
+        if (typeof state !== "string") {
+            error("[SELF_EVOLUTION] invalid payload: missing selfEvolutionState");
+            return;
+        }
+        log(`[SELF_EVOLUTION] received state: ${state}`);
+        let content;
+        try {
+            content = readFileSync(XIAOYIRUNTIME_PATH, "utf-8");
+        }
+        catch {
+            // File doesn't exist yet — create it
+            log(`[SELF_EVOLUTION] ${XIAOYIRUNTIME_PATH} not found, creating new file`);
+            writeFileSync(XIAOYIRUNTIME_PATH, `selfEvolutionState=${state}\n`, "utf-8");
+            log(`[SELF_EVOLUTION] wrote selfEvolutionState=${state}`);
+            return;
+        }
+        const lines = content.split("\n");
+        const key = "selfEvolutionState";
+        let found = false;
+        const updated = lines.map((line) => {
+            if (line.startsWith(`${key}=`)) {
+                found = true;
+                return `${key}=${state}`;
+            }
+            return line;
+        });
+        if (!found) {
+            // Ensure trailing newline before appending
+            const trimmed = content.trimEnd();
+            writeFileSync(XIAOYIRUNTIME_PATH, `${trimmed}\n${key}=${state}\n`, "utf-8");
+        }
+        else {
+            writeFileSync(XIAOYIRUNTIME_PATH, updated.join("\n"), "utf-8");
+        }
+        log(`[SELF_EVOLUTION] updated selfEvolutionState=${state} in ${XIAOYIRUNTIME_PATH}`);
+    }
+    catch (err) {
+        error("[SELF_EVOLUTION] failed to handle event:", err);
+    }
+}

package/dist/src/skill-retriever/config.d.ts

@@ -0,0 +1,4 @@
+import type { ToolRetrieverConfig } from "./types.js";
+export interface NormalizedConfig extends ToolRetrieverConfig {
+}
+export declare function normalizeToolRetrieverConfig(raw?: unknown): NormalizedConfig;

package/dist/src/skill-retriever/config.js

@@ -0,0 +1,23 @@
+const DEFAULT_CONFIG = {
+    enabled: true,
+    maxTools: 2,
+    includeUninstalledOnly: true,
+    envFilePath: "~/.openclaw/.xiaoyienv",
+    timeoutMs: 1000,
+};
+export function normalizeToolRetrieverConfig(raw) {
+    if (!raw || typeof raw !== "object") {
+        return { ...DEFAULT_CONFIG };
+    }
+    const cfg = raw;
+    return {
+        enabled: cfg.enabled ?? DEFAULT_CONFIG.enabled,
+        maxTools: Math.min(20, Math.max(1, cfg.maxTools ?? DEFAULT_CONFIG.maxTools)),
+        includeUninstalledOnly: cfg.includeUninstalledOnly ?? DEFAULT_CONFIG.includeUninstalledOnly,
+        envFilePath: cfg.envFilePath ?? DEFAULT_CONFIG.envFilePath,
+        serviceUrl: cfg.serviceUrl,
+        apiKey: cfg.apiKey,
+        uid: cfg.uid,
+        timeoutMs: cfg.timeoutMs ?? DEFAULT_CONFIG.timeoutMs,
+    };
+}

package/dist/src/skill-retriever/hooks.d.ts

@@ -0,0 +1,22 @@
+interface PluginHookBeforePromptBuildEvent {
+    prompt: string;
+    messages: unknown[];
+}
+interface PluginHookBeforePromptBuildResult {
+    systemPrompt?: string;
+    prependContext?: string;
+    prependSystemContext?: string;
+    appendSystemContext?: string;
+}
+interface PluginHookAgentContext {
+    agentId?: string;
+    sessionKey?: string;
+    sessionId?: string;
+    workspaceDir?: string;
+    messageProvider?: string;
+    trigger?: string;
+    channelId?: string;
+}
+import type { ToolRetrieverConfig } from "./types.js";
+export declare function createBeforePromptBuildHandler(config: ToolRetrieverConfig): (event: PluginHookBeforePromptBuildEvent, ctx?: PluginHookAgentContext) => Promise<PluginHookBeforePromptBuildResult | undefined>;
+export {};

package/dist/src/skill-retriever/hooks.js

@@ -0,0 +1,91 @@
+import { searchTools, formatToolsForContext, extractUserQuery } from "./tool-search.js";
+const TOOL_RETRIEVER_HEADER = `## 用户查询相关skill列表如下：
+
+`;
+const TOOL_RETRIEVER_FOOTER = `
+以上是检索到的、与当前查询相关但用户尚未安装的skill，请按照以下规则判断是否需要推荐：
+1.判断用户当前请求的意图类型：
+-若用户请求为查询已有信息、查看状态、执行已有功能或进行常规操作（例如查看定时任务列表），且这些操作无需额外skill即可完成，则不推荐任何skill。
+2.仅在以下条件全部满足时，才考虑推荐skill：
+-用户请求明确表示需要完成某个具体任务；
+-现有能力（包括已安装的skill或系统自带功能）不足以满足该任务。此时，优先推荐与任务强相关的skill。
+3.对于强相关且用户尚未安装的skill：
+-可主动提醒用户考虑安装，但禁止直接安装；
+-用户明确同意后，使用find-skills执行安装。
+4.若用户已安装的skill已能很好地完成当前任务，即使存在功能相似的未安装skill，也无需提醒。
+---以下是用户原始请求---
+`;
+const PLUGIN_LOG_PREFIX = "[skill-retriever]";
+const SKIP_KEYWORDS = ["安装", "装一下", "下载", "查询", "查找", "install", "卸载", "删除", "重载", "定时任务", "重装"];
+const SKIP_PATTERNS = [
+    "/new", "/reset", "/compact", "/stop", "/think", "/model", "/fast", "/verbose", "/config", "/debug", "/status", "/tasks", "/whoami", "/context", "/skill", "/commands", "/tools"
+];
+function shouldSkipSearch(prompt) {
+    const trimmedPrompt = prompt.trim();
+    if (trimmedPrompt.startsWith("/")) {
+        return "query starts with / (built-in command)";
+    }
+    const lowerPrompt = trimmedPrompt.toLowerCase();
+    for (const keyword of SKIP_KEYWORDS) {
+        if (lowerPrompt.includes(keyword.toLowerCase())) {
+            return `query contains keyword: ${keyword}`;
+        }
+    }
+    for (const pattern of SKIP_PATTERNS) {
+        if (lowerPrompt.includes(pattern.toLowerCase())) {
+            return `query matches pattern: ${pattern}`;
+        }
+    }
+    return null;
+}
+export function createBeforePromptBuildHandler(config) {
+    return async (event, ctx) => {
+        const userPrompt = event.prompt;
+        if (ctx?.sessionKey?.includes(":subagent:")) {
+            return undefined;
+        }
+        if (!config.enabled) {
+            return undefined;
+        }
+        if (!userPrompt || userPrompt.trim().length === 0) {
+            return undefined;
+        }
+        const extractedQuery = extractUserQuery(userPrompt);
+        if (!extractedQuery || extractedQuery.length === 0) {
+            return undefined;
+        }
+        const skipReason = shouldSkipSearch(extractedQuery);
+        if (skipReason) {
+            return undefined;
+        }
+        try {
+            const searchResult = await searchTools({
+                query: extractedQuery,
+                maxTools: config.maxTools,
+                includeUninstalledOnly: config.includeUninstalledOnly,
+                envFilePath: config.envFilePath,
+                serviceUrl: config.serviceUrl,
+                apiKey: config.apiKey,
+                uid: config.uid,
+                timeoutMs: config.timeoutMs,
+            });
+            if (!searchResult || searchResult.tools.length === 0) {
+                return undefined;
+            }
+            console.log(`${PLUGIN_LOG_PREFIX} [RESULT] Found ${searchResult.tools.length} skills, building context...`);
+            const toolsContext = formatToolsForContext(searchResult, config.includeUninstalledOnly);
+            if (!toolsContext) {
+                console.log(`${PLUGIN_LOG_PREFIX} [ERROR] Failed to format skills context`);
+                return undefined;
+            }
+            return {
+                prependContext: TOOL_RETRIEVER_HEADER + toolsContext + TOOL_RETRIEVER_FOOTER,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.error(`${PLUGIN_LOG_PREFIX} [ERROR] ${errorMessage}, original query: "${extractedQuery}"`);
+            return undefined;
+        }
+    };
+}

package/dist/src/skill-retriever/tool-search.d.ts

@@ -0,0 +1,16 @@
+import type { EnvConfig, ToolSearchResult } from "./types.js";
+export declare function extractUserQuery(fullPrompt: string): string;
+export declare function readEnvFile(filePath: string): EnvConfig;
+export declare function getInstalledSkills(): string[];
+export interface SearchToolsOptions {
+    query: string;
+    maxTools?: number;
+    includeUninstalledOnly?: boolean;
+    envFilePath?: string;
+    serviceUrl?: string;
+    apiKey?: string;
+    uid?: string;
+    timeoutMs?: number;
+}
+export declare function searchTools(options: SearchToolsOptions): Promise<ToolSearchResult | null>;
+export declare function formatToolsForContext(result: ToolSearchResult, includeInstallUrl?: boolean): string;