assistme 0.3.1 → 0.3.2

package/src/agent/memory.ts

@@ -26,10 +26,6 @@ export interface Memory {
 // ── Memory Manager ──────────────────────────────────────────────────
 
 export class MemoryManager {
-  constructor(_userId: string) {
-    // userId is no longer needed — auth is handled by the MCP token in callMcpHandler
-  }
-
   /**
    * Store a new memory. Called by the agent after completing tasks
    * to remember important facts about the user.
@@ -45,9 +41,7 @@ export class MemoryManager {
     }
   ): Promise<Memory> {
     const expiresAt = options?.expiresInDays
-      ? new Date(
-          Date.now() + options.expiresInDays * 86400_000
-        ).toISOString()
+      ? new Date(Date.now() + options.expiresInDays * 86400_000).toISOString()
       : null;
 
     const data = await callMcpHandler<Memory>("memory.store", {
@@ -132,10 +126,7 @@ export class MemoryManager {
 
   // ── CRUD for CLI ────────────────────────────────────────────
 
-  async list(
-    category?: MemoryCategory,
-    limit = 20
-  ): Promise<Memory[]> {
+  async list(category?: MemoryCategory, limit = 20): Promise<Memory[]> {
     const data = await callMcpHandler<Memory[]>("memory.list", {
       category: category || null,
       limit,

package/src/agent/processor.ts

@@ -29,101 +29,7 @@ import {
   BROWSER_TOOL_NAMES,
 } from "./mcp-servers.js";
 import { createEventHooks } from "./event-hooks.js";
-
-const BASE_SYSTEM_PROMPT = `You are AssistMe, an AI assistant that operates like a real human on the user's computer. You control the user's actual Chrome browser and work with their real files.
-
-KEY PRINCIPLE: You operate the user's real browser, not a headless sandbox. This means:
-- The browser has the user's real cookies, logins, and sessions
-- When you navigate to amazon.com, you see the user's logged-in Amazon
-- If a site needs login, the browser will auto-detect the login page and prompt the user
-- After the user logs in, their session is saved in the persistent browser profile (~/.assistme/browser-profile)
-- Saved sessions persist across assistme restarts — the user only needs to log in once per site
-- You are like a human assistant sitting at the user's computer
-- Chrome is automatically managed — just call browser_connect and it will auto-launch if needed
-- NEVER ask the user to manually start Chrome or run any terminal commands for browser setup
-
-Available capabilities:
-1. BROWSER CONTROL (user's real Chrome via CDP):
-   - Use browser tools (browser_connect, browser_navigate, browser_read_page, browser_screenshot, browser_click, browser_type, browser_press_key, browser_scroll, browser_get_elements, browser_evaluate, browser_list_tabs, browser_switch_tab, browser_new_tab) to control the user's real Chrome
-   - If auth is needed: use browser_request_user_action to ask the user to log in
-
-2. FILE OPERATIONS & SHELL:
-   - Read, Write, Edit tools for file operations
-   - Bash tool for shell commands
-   - Glob and Grep for file search
-
-3. MEMORY:
-   - You can remember things about the user using memory_store
-   - Use this when you learn preferences, important facts, or standing instructions
-   - Your stored memories persist across conversations
-   - PROACTIVELY use memory_store during tasks when you discover user preferences, habits, or important context
-   - Before completing a task, consider if anything learned should be remembered for future conversations
-
-4. SKILL-AWARE EXECUTION (CRITICAL — follow this for EVERY task):
-   Step A — Search: Before executing ANY task, check if an existing skill matches (use skill_invoke or skill_search).
-   Step B — If skill found: load it with skill_invoke and follow its instructions precisely. If the instructions are incomplete or wrong, adapt and improve as you go — note what changed.
-   Step C — If NO skill found: BEFORE executing, draft a skill plan following the Agent Skills format:
-     Skill Draft: [kebab-case-name]
-     Description: [what this skill does and when to use it]
-     Steps:
-     1. [first step]
-     2. [second step]
-     ...
-     The draft should be a reusable workflow, not specific to this one request. Use generic placeholders where the user provided specific values.
-   Step D — Execute: Follow the skill draft (or loaded skill) step by step. Refine the draft as you discover better approaches, edge cases, or missing steps.
-   Step E — After execution: The system will automatically evaluate whether to save the skill. You do NOT need to call skill_create manually.
-
-   Agent Skills format reference (agentskills.io):
-   - name: 1-64 chars, lowercase kebab-case (a-z, 0-9, hyphens), no leading/trailing/consecutive hyphens
-   - description: 1-1024 chars, describe what the skill does AND when to use it, include keywords for discoverability
-   - body: markdown step-by-step instructions, examples, edge cases. Keep under 500 lines.
-   - Progressive disclosure: metadata (~100 tokens) → instructions (<5000 tokens) → references (on demand)
-
-5. JOB AUTOMATION:
-   - When the user describes their job/role/daily work, use skill_generate to decompose it into automatable skills
-   - ALWAYS use ask_user to get user approval before creating skills — never create skills without approval
-   - Use job_run to start a job — it gives you the job's goal and available skills as capabilities
-   - When running a job, be AGENTIC: decide dynamically what to do based on what you discover
-   - Do NOT follow a fixed sequence — if checking Slack reveals a task that needs GitHub, go do GitHub immediately
-   - Chain actions intelligently: one skill's findings should inform your next move
-   - Skip irrelevant skills, use tools directly when skills aren't needed
-   - Use job_schedule for recurring automation (e.g., "run my SE job every weekday morning")
-   - Use job_status to check run history
-
-6. SKILL MARKETPLACE:
-   - Use skill_browse to discover community-published skills
-   - Use skill_add to add marketplace skills to the user's collection
-   - Use skill_publish to share the user's skills with the community
-
-Workflow for web tasks (e.g. "查一下 kindle 最新款价格"):
-1. browser_connect → connect to user's Chrome
-2. browser_new_tab → open a new tab
-3. browser_navigate → go to the website (login pages are auto-detected — the user will be prompted and their session saved)
-4. browser_read_page or browser_screenshot → read the content
-5. If login is needed but not auto-detected → use browser_request_user_action to ask the user
-6. Repeat across multiple sites as needed
-7. Summarize findings
-
-Guidelines:
-- Always use the real browser for web tasks, never try to fetch URLs programmatically
-- Use browser_screenshot when you need to see the visual layout
-- Use browser_get_elements to find clickable elements before clicking
-- Login pages are auto-detected after navigation — the user is prompted and sessions are saved automatically
-- If auto-detection misses a login page, use browser_request_user_action manually
-- Be thorough: check multiple sources when comparing prices/products
-- Summarize results clearly at the end
-- When you learn something about the user (preferences, habits), use memory_store to remember it
-
-CRITICAL — Ask before you guess:
-- Before executing a task, verify you have all required information. If anything is ambiguous or missing, use ask_user to ask.
-- First try to resolve unknowns yourself: check memories, read workspace files (e.g. git remote, config files), or infer from conversation history.
-- If you still lack a critical piece of information after self-resolution, ASK the user via ask_user. Do NOT guess, assume defaults, or proceed with incomplete information.
-- When asking, provide suggested options as buttons whenever possible — the user can always type a custom answer instead.
-- Examples of when to ask: which account/repo/project to target, what format the user wants, which of multiple options to choose, credentials or URLs that cannot be inferred.
-- Keep questions specific and actionable. Explain what you already know and what exactly you need.
-- After receiving the answer, store it with memory_store if it is likely to be useful in future conversations.
-
-Workspace path: {workspace_path}`;
+import { BASE_SYSTEM_PROMPT } from "./system-prompt.js";
 
 const MAX_HISTORY_ENTRIES = 10;
 const MAX_RESPONSE_LENGTH = 1500;
@@ -131,7 +37,6 @@ const MAX_RESPONSE_LENGTH = 1500;
 export class TaskProcessor {
   private memoryManager: MemoryManager | null = null;
   private skillManager: SkillManager;
-  private userId: string | null = null;
   private sessionId: string | null = null;
   /** In-memory conversation history, keyed by conversation_id */
   private historyCache: Map<string, HistoryEntry[]> = new Map();
@@ -140,9 +45,8 @@ export class TaskProcessor {
     this.skillManager = new SkillManager();
   }
 
-  setUserId(userId: string): void {
-    this.userId = userId;
-    this.memoryManager = new MemoryManager(userId);
+  init(userId: string): void {
+    this.memoryManager = new MemoryManager();
     this.skillManager.setUserId(userId);
     // Load DB skills asynchronously (non-blocking)
     this.skillManager.loadFromDb().catch((err) => {
@@ -159,10 +63,7 @@ export class TaskProcessor {
    * to create/update a skill. The agent already has full context from
    * the task it just completed — no need to re-describe anything.
    */
-  private async evaluateSkillPostTask(
-    agentSessionId: string,
-    model: string
-  ): Promise<void> {
+  private async evaluateSkillPostTask(agentSessionId: string, model: string): Promise<void> {
     await evaluateAndMaybeCreateSkill({
       sessionId: agentSessionId,
       skillManager: this.skillManager,
@@ -249,7 +150,6 @@ export class TaskProcessor {
         skillManager: this.skillManager,
         taskId: task.id,
         sessionId: this.sessionId || undefined,
-        userId: this.userId || undefined,
       });
 
       // Create event hooks for Supabase event emission
@@ -283,6 +183,11 @@ export class TaskProcessor {
         "mcp__assistme-agent__job_run",
         "mcp__assistme-agent__job_schedule",
         "mcp__assistme-agent__job_status",
+        // Credential tools (local storage)
+        "mcp__assistme-agent__credential_get",
+        "mcp__assistme-agent__credential_set",
+        "mcp__assistme-agent__credential_list",
+        "mcp__assistme-agent__credential_remove",
       ];
 
       // Build async generator for prompt (required for MCP tools)
@@ -385,7 +290,11 @@ export class TaskProcessor {
 
             default:
               // Capture session ID from init message for post-task session resume
-              if (message.type === "system" && "subtype" in message && (message as Record<string, unknown>).subtype === "init") {
+              if (
+                message.type === "system" &&
+                "subtype" in message &&
+                (message as Record<string, unknown>).subtype === "init"
+              ) {
                 agentSessionId = (message as Record<string, unknown>).session_id as string;
               }
               log.debug(`SDK message type: ${message.type}`);
@@ -416,8 +325,9 @@ export class TaskProcessor {
 
       // Post-task: resume the same session to evaluate skill creation (fire-and-forget)
       if (agentSessionId) {
-        this.evaluateSkillPostTask(agentSessionId, config.model)
-          .catch((err) => log.debug(`Post-task skill evaluation skipped: ${err}`));
+        this.evaluateSkillPostTask(agentSessionId, config.model).catch((err) =>
+          log.debug(`Post-task skill evaluation skipped: ${err}`)
+        );
       }
     } catch (err) {
       const errorMsg = err instanceof Error ? err.message : String(err);

package/src/agent/scheduler.ts

@@ -174,7 +174,6 @@ export class Scheduler {
 // ── CRUD helpers for CLI commands ──────────────────────────────────
 
 export async function createScheduledTask(
-  _userId: string,
   name: string,
   prompt: string,
   cronExpression: string,
@@ -191,7 +190,7 @@ export async function createScheduledTask(
   });
 }
 
-export async function listScheduledTasks(_userId: string): Promise<ScheduledTask[]> {
+export async function listScheduledTasks(): Promise<ScheduledTask[]> {
   return callMcpHandler<ScheduledTask[]>("schedule.list");
 }
 
@@ -202,7 +201,7 @@ export async function toggleScheduledTask(taskId: string, enabled: boolean): Pro
     // Need to recalculate next run when re-enabling
     const taskData = await callMcpHandler<{ cron_expression: string; timezone: string }>(
       "schedule.get_task",
-      { task_id: taskId },
+      { task_id: taskId }
     );
     if (taskData) {
       const nextRun = getNextRunTime(taskData.cron_expression, taskData.timezone);

package/src/agent/session.ts

@@ -52,23 +52,13 @@ export class SessionManager {
     this.onTask = onTask;
     this.userId = userId;
 
-    this.session = await createSession(
-      userId,
-      config.sessionName,
-      config.workspacePath,
-      "0.1.0"
-    );
+    this.session = await createSession(config.sessionName, config.workspacePath, "0.1.0");
 
     // Get or create CLI conversation for this session
-    this.conversationId = await getOrCreateCliConversation(
-      userId,
-      this.session.id
-    );
+    this.conversationId = await getOrCreateCliConversation();
 
     this.running = true;
-    log.success(
-      `Session started: ${this.session.id} (${config.sessionName})`
-    );
+    log.success(`Session started: ${this.session.id} (${config.sessionName})`);
     log.info(`Workspace: ${config.workspacePath}`);
 
     // Start heartbeat
@@ -107,44 +97,43 @@ export class SessionManager {
     this.pollTimer = setTimeout(() => this.pollForTasks(), delay);
   }
 
-  private async executeScheduledTask(
-    scheduledTask: ScheduledTask
-  ): Promise<void> {
+  private async executeScheduledTask(scheduledTask: ScheduledTask): Promise<void> {
     if (!this.session || !this.userId || !this.conversationId) return;
 
     log.info(`Running scheduled task: "${scheduledTask.name}"`);
 
     try {
-      await this.submitTask(
-        `[Scheduled: ${scheduledTask.name}] ${scheduledTask.prompt}`
-      );
+      await this.submitTask(`[Scheduled: ${scheduledTask.name}] ${scheduledTask.prompt}`);
     } catch (err) {
       log.error(`Scheduled task error: ${err}`);
     }
   }
 
   private async executeJobRun(jobRun: PendingJobRun): Promise<void> {
-    if (!this.session || !this.userId || !this.conversationId || !this.onTask)
-      return;
+    if (!this.session || !this.userId || !this.conversationId || !this.onTask) return;
 
-    log.info(
-      `Executing job run: ${jobRun.job_name} (${jobRun.id.slice(0, 8)}...)`
-    );
+    log.info(`Executing job run: ${jobRun.job_name} (${jobRun.id.slice(0, 8)}...)`);
 
-    const runner = new JobRunner(this.userId);
+    const runner = new JobRunner();
     const job = await runner.loadJob(jobRun.job_name);
 
     if (!job) {
       log.error(`Job "${jobRun.job_name}" not found, marking run as failed`);
-      try { await runner.completeRun(jobRun.id, "failed", `Job "${jobRun.job_name}" not found`); }
-      catch { /* already logged inside completeRun */ }
+      try {
+        await runner.completeRun(jobRun.id, "failed", `Job "${jobRun.job_name}" not found`);
+      } catch {
+        /* already logged inside completeRun */
+      }
       return;
     }
 
     if (job.skills.length === 0) {
       log.error(`Job "${jobRun.job_name}" has no skills, marking run as failed`);
-      try { await runner.completeRun(jobRun.id, "failed", "Job has no linked skills"); }
-      catch { /* already logged inside completeRun */ }
+      try {
+        await runner.completeRun(jobRun.id, "failed", "Job has no linked skills");
+      } catch {
+        /* already logged inside completeRun */
+      }
       return;
     }
 
@@ -214,7 +203,7 @@ export class SessionManager {
         }
       } else if (this.userId) {
         // Priority 2: Pending job runs (triggered from web UI)
-        const jobRun = await pollAndClaimJobRun(this.userId);
+        const jobRun = await pollAndClaimJobRun();
 
         if (jobRun) {
           this.processingDepth++;
@@ -267,12 +256,7 @@ export class SessionManager {
     await setSessionBusy(this.session.id, true);
 
     try {
-      const task = await createTask(
-        this.conversationId,
-        this.userId,
-        this.session.id,
-        prompt
-      );
+      const task = await createTask(this.conversationId, this.session.id, prompt);
 
       // Claim immediately so poll can't grab it even after depth decrements
       await claimTask(task.id);

package/src/agent/skills.ts

@@ -6,18 +6,113 @@ import { callMcpHandler } from "../db/api-client.js";
 
 // Common English stop words to filter out of matching
 const STOP_WORDS = new Set([
-  "the", "a", "an", "is", "are", "was", "were", "be", "been", "being",
-  "have", "has", "had", "do", "does", "did", "will", "would", "could",
-  "should", "may", "might", "shall", "can", "need", "dare", "ought",
-  "used", "to", "of", "in", "for", "on", "with", "at", "by", "from",
-  "as", "into", "through", "during", "before", "after", "above", "below",
-  "between", "out", "off", "over", "under", "again", "further", "then",
-  "once", "here", "there", "when", "where", "why", "how", "all", "each",
-  "every", "both", "few", "more", "most", "other", "some", "such", "no",
-  "nor", "not", "only", "own", "same", "so", "than", "too", "very",
-  "and", "but", "or", "if", "this", "that", "these", "those", "it",
-  "its", "i", "me", "my", "we", "our", "you", "your", "he", "him",
-  "she", "her", "they", "them", "what", "which", "who", "whom",
+  "the",
+  "a",
+  "an",
+  "is",
+  "are",
+  "was",
+  "were",
+  "be",
+  "been",
+  "being",
+  "have",
+  "has",
+  "had",
+  "do",
+  "does",
+  "did",
+  "will",
+  "would",
+  "could",
+  "should",
+  "may",
+  "might",
+  "shall",
+  "can",
+  "need",
+  "dare",
+  "ought",
+  "used",
+  "to",
+  "of",
+  "in",
+  "for",
+  "on",
+  "with",
+  "at",
+  "by",
+  "from",
+  "as",
+  "into",
+  "through",
+  "during",
+  "before",
+  "after",
+  "above",
+  "below",
+  "between",
+  "out",
+  "off",
+  "over",
+  "under",
+  "again",
+  "further",
+  "then",
+  "once",
+  "here",
+  "there",
+  "when",
+  "where",
+  "why",
+  "how",
+  "all",
+  "each",
+  "every",
+  "both",
+  "few",
+  "more",
+  "most",
+  "other",
+  "some",
+  "such",
+  "no",
+  "nor",
+  "not",
+  "only",
+  "own",
+  "same",
+  "so",
+  "than",
+  "too",
+  "very",
+  "and",
+  "but",
+  "or",
+  "if",
+  "this",
+  "that",
+  "these",
+  "those",
+  "it",
+  "its",
+  "i",
+  "me",
+  "my",
+  "we",
+  "our",
+  "you",
+  "your",
+  "he",
+  "him",
+  "she",
+  "her",
+  "they",
+  "them",
+  "what",
+  "which",
+  "who",
+  "whom",
 ]);
 
 /**
@@ -48,6 +143,13 @@ function bigrams(tokens: string[]): Set<string> {
 
 // ── Skill Interfaces ────────────────────────────────────────────────
 
+export interface SkillCredentialRequirement {
+  name: string;
+  type: "api_key" | "oauth_token" | "login" | "secret" | "custom";
+  description: string;
+  required: boolean;
+}
+
 export interface SkillMetadata {
   requires?: {
     bins?: string[];
@@ -60,6 +162,7 @@ export interface SkillMetadata {
   os?: string[];
   always?: boolean;
   skillKey?: string;
+  credentials?: SkillCredentialRequirement[];
 }
 
 export interface Skill {
@@ -92,6 +195,7 @@ function parseDbMetadata(raw: unknown): SkillMetadata {
     os: openclaw.os as string[] | undefined,
     always: openclaw.always as boolean | undefined,
     skillKey: openclaw.skillKey as string | undefined,
+    credentials: openclaw.credentials as SkillCredentialRequirement[] | undefined,
   };
 }
 
@@ -165,7 +269,8 @@ export class SkillManager {
     const docFreq = new Map<string, number>();
     const totalSkills = this.skills.size || 1;
     for (const skill of this.skills.values()) {
-      const allText = `${skill.name} ${skill.description} ${skill.content} ${skill.keywords.join(" ")}`.toLowerCase();
+      const allText =
+        `${skill.name} ${skill.description} ${skill.content} ${skill.keywords.join(" ")}`.toLowerCase();
       const words = new Set(tokenize(allText));
       for (const w of words) {
         docFreq.set(w, (docFreq.get(w) || 0) + 1);
@@ -266,8 +371,10 @@ export class SkillManager {
 
     let budget = this.DESCRIPTION_BUDGET_CHARS;
     let prompt = "\n\n## Your Skills\n";
-    prompt += "These are your approved skills. Use skill_invoke to load full instructions when a task matches.\n";
-    prompt += "If no skill matches but the task is a reusable pattern, consider creating one with skill_create.\n\n";
+    prompt +=
+      "These are your approved skills. Use skill_invoke to load full instructions when a task matches.\n";
+    prompt +=
+      "If no skill matches but the task is a reusable pattern, consider creating one with skill_create.\n\n";
     let included = 0;
 
     for (const skill of skills) {
@@ -287,24 +394,6 @@ export class SkillManager {
     return prompt;
   }
 
-  /** @deprecated Use buildSkillDescriptions() + skill_invoke tool instead. */
-  buildSkillPrompt(taskPrompt: string): string {
-    const relevant = this.findRelevant(taskPrompt);
-    if (relevant.length === 0) return "";
-
-    let prompt = "\n\n## Available Skills\n";
-    prompt += "The following skills provide detailed instructions for this type of task:\n\n";
-
-    for (const skill of relevant) {
-      const emoji = skill.metadata.emoji || "";
-      prompt += `### ${emoji ? emoji + " " : ""}${skill.name}\n`;
-      prompt += `*${skill.description}*\n\n`;
-      prompt += skill.content + "\n\n";
-    }
-
-    return prompt;
-  }
-
   async create(
     name: string,
     description: string,
@@ -327,7 +416,7 @@ export class SkillManager {
           emoji: options?.emoji || null,
           keywords: options?.keywords || [],
           metadata,
-        },
+        }
       );
 
       const row = (Array.isArray(data) ? data[0] : data) as Record<string, unknown> | null;
@@ -373,13 +462,13 @@ export class SkillManager {
     try {
       const result = await callMcpHandler<{ skill: Record<string, unknown>; agent_skill: unknown }>(
         "skill.fetch_and_add",
-        { skill_id: skillId },
+        { skill_id: skillId }
       );
 
       const row = result.skill;
-      const agentSkillRow = (result.agent_skill && typeof result.agent_skill === "object"
-        ? result.agent_skill
-        : row) as Record<string, unknown>;
+      const agentSkillRow = (
+        result.agent_skill && typeof result.agent_skill === "object" ? result.agent_skill : row
+      ) as Record<string, unknown>;
       const skill = this.rowToSkill({
         ...agentSkillRow,
         name: row.name,
@@ -425,7 +514,10 @@ export class SkillManager {
     const normalizedName = name.toLowerCase().replace(/[^a-z0-9]/g, "");
     for (const [existingName, skill] of this.skills) {
       const normalizedExisting = existingName.toLowerCase().replace(/[^a-z0-9]/g, "");
-      if (normalizedName.includes(normalizedExisting) || normalizedExisting.includes(normalizedName)) {
+      if (
+        normalizedName.includes(normalizedExisting) ||
+        normalizedExisting.includes(normalizedName)
+      ) {
         return skill;
       }
       const nameWords = new Set(name.split("-"));
@@ -546,16 +638,24 @@ export class SkillManager {
     }
   }
 
-  async searchDb(query: string, limit = 10): Promise<Array<{
-    name: string;
-    description: string;
-    emoji: string;
-    source: string;
-    invocationCount: number;
-  }>> {
+  async searchDb(
+    query: string,
+    limit = 10
+  ): Promise<
+    Array<{
+      name: string;
+      description: string;
+      emoji: string;
+      source: string;
+      invocationCount: number;
+    }>
+  > {
     if (this.userId) {
       try {
-        const data = await callMcpHandler<Record<string, unknown>[]>("skill.search", { query, limit });
+        const data = await callMcpHandler<Record<string, unknown>[]>("skill.search", {
+          query,
+          limit,
+        });
         if (data) {
           return data.map((row) => ({
             name: row.name as string,
@@ -565,7 +665,9 @@ export class SkillManager {
             invocationCount: (row.invocation_count as number) || 0,
           }));
         }
-      } catch { /* Fall through to in-memory search */ }
+      } catch {
+        /* Fall through to in-memory search */
+      }
     }
 
     const results = this.findRelevant(query, limit);
@@ -582,7 +684,9 @@ export class SkillManager {
     if (!this.userId) return;
     try {
       await callMcpHandler("skill.remove", { name });
-    } catch { /* Non-critical */ }
+    } catch {
+      /* Non-critical */
+    }
   }
 
   // ── Marketplace ────────────────────────────────────────────────────
@@ -630,18 +734,20 @@ export class SkillManager {
     sort?: "popular" | "recent" | "rating";
     limit?: number;
     offset?: number;
-  }): Promise<Array<{
-    id: string;
-    name: string;
-    description: string;
-    emoji: string;
-    version: string;
-    authorName: string;
-    category: string;
-    installCount: number;
-    avgRating: number | null;
-    ratingCount: number;
-  }>> {
+  }): Promise<
+    Array<{
+      id: string;
+      name: string;
+      description: string;
+      emoji: string;
+      version: string;
+      authorName: string;
+      category: string;
+      installCount: number;
+      avgRating: number | null;
+      ratingCount: number;
+    }>
+  > {
     try {
       const data = await callMcpHandler<Record<string, unknown>[]>("skill.browse", {
         query: options?.query || null,