@ynhcj/xiaoyi-channel 0.0.65-beta → 0.0.65-next

package/dist/src/provider.js

@@ -0,0 +1,368 @@
+// Xiaoyi Provider
+// Wraps any OpenAI-compatible endpoint and injects dynamic headers
+// (taskId, sessionId, conversationId) from the current XY channel session.
+// Falls back to uid-based values when no session context is available.
+//
+// Users configure the underlying model in config:
+//   models.providers.xiaoyiprovider.baseUrl = "https://..."
+//   models.providers.xiaoyiprovider.api = "openai-completions"
+//   models.providers.xiaoyiprovider.models = [...]
+import { createHash } from "crypto";
+import { getCurrentSessionContext } from "./tools/session-manager.js";
+// ── Retry config ──────────────────────────────────────────────
+const RETRY_DELAYS_MS = [10_000, 20_000, 40_000, 60_000];
+const MAX_RETRY_ATTEMPTS = 8;
+/** 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;
+    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());
+}
+/** 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:
+ *   TASK_ID, SESSION_ID, CONVERSATION_ID
+ */
+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";
+/**
+ * Encode uid via SHA-256 and take first 32 hex chars.
+ */
+function encodeUid(uid) {
+    return createHash("sha256").update(uid).digest("hex").slice(0, 32);
+}
+/**
+ * Get uid from channel config (OpenClawConfig -> channels -> xiaoyi-channel -> uid).
+ */
+function getUidFromConfig(config) {
+    return config?.channels?.["xiaoyi-channel"]?.uid;
+}
+export const xiaoyiProvider = {
+    id: "xiaoyiprovider",
+    label: "Xiaoyi Provider",
+    docsPath: "/providers/models",
+    auth: [],
+    isCacheTtlEligible: () => true,
+    /**
+     * Inject dynamic session params into extraParams so they flow
+     * through to wrapStreamFn's ctx.extraParams.
+     *
+     * Priority:
+     *   1. Session context (from AsyncLocalStorage, set by bot.ts)
+     *   2. uid-based fallback: sha256(uid).hex[:32]_timestamp
+     *   3. No uid available → return undefined (no headers injected)
+     */
+    prepareExtraParams: (ctx) => {
+        const sessionCtx = getCurrentSessionContext();
+        if (sessionCtx) {
+            const taskId = sessionCtx.taskId;
+            const sessionId = taskId.split("&")[0];
+            const interactionId = taskId.split("&")[1] || "";
+            return {
+                ...ctx.extraParams,
+                [HEADER_TRACE_ID]: taskId,
+                [HEADER_SESSION_ID]: sessionId,
+                [HEADER_INTERACTION_ID]: interactionId,
+            };
+        }
+        // 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;
+        return {
+            ...ctx.extraParams,
+            [FALLBACK_PREFIX_KEY]: encodeUid(uid),
+        };
+    },
+    /**
+     * Wrap the stream function to inject dynamic headers into every
+     * HTTP request to the model provider, and retry on retryable errors
+     * (server_error / rate_limit_error) with backoff: 10s, 20s, 40s, 60s (cap).
+     *
+     * 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;
+        if (!underlying)
+            return underlying;
+        return async (model, context, options) => {
+            // 每次请求时从 ctx.extraParams 动态读取 header
+            const dynamicHeaders = {};
+            if (ctx.extraParams) {
+                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;
+                }
+                else {
+                    // Session mode: use pre-resolved session headers
+                    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}` : traceId;
+                    }
+                    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}`);
+            }
+            // 在发送给模型前，优化 systemPrompt 结构
+            if (context.systemPrompt) {
+                let sp = context.systemPrompt;
+                const beforeLen = sp.length;
+                // 删除 ## Tooling 与 TOOLS.md 声明之间的内容
+                sp = sp.replace(/(## Tooling)[\s\S]*?(TOOLS\.md does not control tool availability; it is user guidance for how to use external tools\.)/, "$1\n\n$2");
+                // (1) 提取 ## Skills (mandatory) 到 </available_skills> 作为第一部分
+                const skillsMatch = sp.match(/(## Skills \(mandatory\)[\s\S]*?<\/available_skills>)/);
+                const part1 = skillsMatch ? skillsMatch[0] : '';
+                // (2) 提取 ## /home/sandbox/.openclaw/workspace/SOUL.md 到 ## /home/sandbox/.openclaw/workspace/TOOLS.md 之前的内容作为第二部分
+                const soulMatch = sp.match(/(## \/home\/sandbox\/\.openclaw\/workspace\/SOUL\.md[\s\S]*?)(?=## \/home\/sandbox\/\.openclaw\/workspace\/TOOLS\.md)/);
+                const part2 = soulMatch ? soulMatch[1].trim() : '';
+                if (part1 || part2) {
+                    // 从原始位置删除已提取的部分
+                    if (skillsMatch)
+                        sp = sp.replace(skillsMatch[0], '');
+                    if (soulMatch)
+                        sp = sp.replace(soulMatch[1], '');
+                    // 清理多余空行
+                    sp = sp.replace(/\n{3,}/g, '\n\n');
+                    // (3) 将 第二部分 + 第一部分 插入到 ## Runtime 上面
+                    const combined = (part2 + '\n\n' + part1).trim();
+                    if (combined && sp.includes('## Runtime')) {
+                        sp = sp.replace('## Runtime', combined + '\n\n## Runtime');
+                    }
+                }
+                console.log(`[xiaoyiprovider] system prompt optimized: ${beforeLen} -> ${sp.length}`);
+                context.systemPrompt = sp;
+            }
+            // 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"`;
+                context.systemPrompt = (context.systemPrompt ?? "") + deviceSection;
+            }
+            // ── 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,
+                },
+            });
+            return createRetryingStream(makeStream, cronJob);
+        };
+    },
+};

package/dist/src/reply-dispatcher.js

@@ -267,6 +267,12 @@ export function createXYReplyDispatcher(params) {
                 log(`[TOOL START] Tool: ${name}, phase: ${phase}, taskId: ${currentTaskId}`);
                 if (phase === "start") {
                     const toolName = name || "unknown";
+                    // call_device_tool 由自身 execute() 内部发送具体子工具名的状态更新
+                    // get_xxx_tool_schema 是给 LLM 查 schema 用的，无需向用户展示
+                    if (toolName === "call_device_tool" || toolName.endsWith("_tool_schema")) {
+                        log(`[TOOL START] Skipping generic status for ${toolName}`);
+                        return;
+                    }
                     try {
                         await sendStatusUpdate({
                             config,

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 XIAOYIENV_PATH = "/home/sandbox/.openclaw/.xiaoyienv";
+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(XIAOYIENV_PATH, "utf-8");
+        }
+        catch {
+            // File doesn't exist yet — create it
+            log(`[SELF_EVOLUTION] ${XIAOYIENV_PATH} not found, creating new file`);
+            writeFileSync(XIAOYIENV_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(XIAOYIENV_PATH, `${trimmed}\n${key}=${state}\n`, "utf-8");
+        }
+        else {
+            writeFileSync(XIAOYIENV_PATH, updated.join("\n"), "utf-8");
+        }
+        log(`[SELF_EVOLUTION] updated selfEvolutionState=${state} in ${XIAOYIENV_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,3 @@
+import type { PluginHookBeforePromptBuildEvent, PluginHookBeforePromptBuildResult, PluginHookAgentContext } from "openclaw/plugins/hooks.js";
+import type { ToolRetrieverConfig } from "./types.js";
+export declare function createBeforePromptBuildHandler(config: ToolRetrieverConfig): (event: PluginHookBeforePromptBuildEvent, ctx?: PluginHookAgentContext) => Promise<PluginHookBeforePromptBuildResult | undefined>;

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

@@ -0,0 +1,97 @@
+import { searchTools, formatToolsForContext, extractUserQuery } from "./tool-search.js";
+const TOOL_RETRIEVER_HEADER = `## 用户查询相关skill列表如下：
+
+`;
+const TOOL_RETRIEVER_FOOTER = `
+以上是检索到的、与当前查询相关但用户尚未安装的 skill，优先推荐强相关的 skill（通用兜底工具如 web-search、xiaoyi-gui-agent 仅在无强相关skill时调用）。
+对于强相关skill，你需要主动提醒用户可以考虑安装，但禁止直接给用户安装。用户明确希望安装后，使用find-skill执行安装。
+若用户已有的skill已能很好地完成当前任务，则无需提醒安装功能相似的skill。
+---以下是用户原始请求---
+`;
+const PLUGIN_LOG_PREFIX = "[skill-retriever]";
+const SKIP_KEYWORDS = ["安装", "装一下", "下载", "查询", "查找", "install", "卸载", "删除", "重载"];
+const SKIP_PATTERNS = [
+    "/new",
+    "/reset",
+    "session was started",
+    "a new session was started",
+];
+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:")) {
+            console.log(`${PLUGIN_LOG_PREFIX} [SKIP] Sub-agent detected, skipping search`);
+            return undefined;
+        }
+        if (!config.enabled) {
+            console.log(`${PLUGIN_LOG_PREFIX} [SKIP] Plugin disabled, original query: "${userPrompt}"`);
+            return undefined;
+        }
+        if (!userPrompt || userPrompt.trim().length === 0) {
+            console.log(`${PLUGIN_LOG_PREFIX} [SKIP] Empty query`);
+            return undefined;
+        }
+        console.log(`${PLUGIN_LOG_PREFIX} [RECEIVED] Original user query (len=${userPrompt.length}): "${userPrompt}"`);
+        const extractedQuery = extractUserQuery(userPrompt);
+        console.log(`${PLUGIN_LOG_PREFIX} [EXTRACTED] Extracted user query: "${extractedQuery}"`);
+        if (!extractedQuery || extractedQuery.length === 0) {
+            console.log(`${PLUGIN_LOG_PREFIX} [SKIP] No valid user query after extraction, skipping search`);
+            return undefined;
+        }
+        const skipReason = shouldSkipSearch(extractedQuery);
+        if (skipReason) {
+            console.log(`${PLUGIN_LOG_PREFIX} [SKIP] ${skipReason}, extracted query: "${extractedQuery}"`);
+            return undefined;
+        }
+        console.log(`${PLUGIN_LOG_PREFIX} [PROCEED] Calling skill search API (timeout=${config.timeoutMs}ms) for query: "${extractedQuery}"`);
+        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) {
+                console.log(`${PLUGIN_LOG_PREFIX} [RESULT] No skills found for query: "${extractedQuery}"`);
+                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 for query: "${extractedQuery}"`);
+                return undefined;
+            }
+            console.log(`${PLUGIN_LOG_PREFIX} [SUCCESS] Built context with ${searchResult.tools.length} skills for query: "${extractedQuery}"`);
+            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;