@fudrouter/fsrouter 0.6.62 → 0.6.63

package/open-sse/mcp-server/tools/agentSkillTools.js

@@ -0,0 +1,69 @@
+import { z } from "zod";
+import { getCatalog, getSkillById, filterCatalog, computeCoverage, fetchSkillMarkdown } from '../../../dist/lib/agentSkills/catalog.js';
+const AgentSkillsListSchema = z.object({
+  category: z.enum(["api", "cli"]).optional().describe("Filter by category: 'api' or 'cli'"),
+  area: z.string().optional().describe("Filter by area (e.g. 'providers', 'models', 'cli-serve')")
+});
+const AgentSkillsGetSchema = z.object({
+  id: z.string().describe("Canonical skill ID (e.g. 'omni-providers', 'cli-serve')")
+});
+const AgentSkillsCoverageSchema = z.object({});
+const agentSkillTools = {
+  omniroute_agent_skills_list: {
+    name: "omniroute_agent_skills_list",
+    description: "List OmniRoute agent skills with optional filtering by category (api/cli) or area. Returns skill metadata including id, name, description, endpoints/commands, and URLs.",
+    inputSchema: AgentSkillsListSchema,
+    handler: async (args) => {
+      const skills = args.category || args.area ? filterCatalog({ category: args.category, area: args.area }) : getCatalog();
+      return {
+        skills: skills.map((s) => ({
+          id: s.id,
+          name: s.name,
+          description: s.description,
+          category: s.category,
+          area: s.area,
+          endpoints: s.endpoints,
+          cliCommands: s.cliCommands,
+          icon: s.icon,
+          isEntry: s.isEntry,
+          isNew: s.isNew,
+          rawUrl: s.rawUrl,
+          githubUrl: s.githubUrl
+        })),
+        count: skills.length,
+        coverage: computeCoverage()
+      };
+    }
+  },
+  omniroute_agent_skills_get: {
+    name: "omniroute_agent_skills_get",
+    description: "Get detailed metadata and SKILL.md markdown for a single agent skill by its canonical ID. Returns all skill fields plus the raw markdown content.",
+    inputSchema: AgentSkillsGetSchema,
+    handler: async (args) => {
+      const skill = getSkillById(args.id);
+      if (!skill) {
+        throw new Error(`Skill not found: ${args.id}`);
+      }
+      const markdown = await fetchSkillMarkdown(args.id);
+      return {
+        ...skill,
+        markdown
+      };
+    }
+  },
+  omniroute_agent_skills_coverage: {
+    name: "omniroute_agent_skills_coverage",
+    description: "Returns the current SKILL.md coverage stats: how many of the 22 API skills and 20 CLI skills have generated SKILL.md files on the filesystem vs the catalog total.",
+    inputSchema: AgentSkillsCoverageSchema,
+    handler: async (_args) => {
+      const coverage = computeCoverage();
+      return coverage;
+    }
+  }
+};
+export {
+  AgentSkillsCoverageSchema,
+  AgentSkillsGetSchema,
+  AgentSkillsListSchema,
+  agentSkillTools
+};

package/open-sse/mcp-server/tools/compressionTools.js

@@ -0,0 +1,309 @@
+import { logToolCall } from "../audit.ts";
+import {
+  getCompressionSettings,
+  updateCompressionSettings
+} from '../../../dist/lib/db/compression.ts.js';
+import { getCompressionAnalyticsSummary } from '../../../dist/lib/db/compressionAnalytics.ts.js';
+import { getCacheStatsSummary } from '../../../dist/lib/db/compressionCacheStats.ts.js';
+import { listCompressionCombos } from '../../../dist/lib/db/compressionCombos.ts.js';
+import {
+  getMcpDescriptionCompressionStats,
+  snapshotMcpDescriptionCompressionStats
+} from "../descriptionCompressor.ts";
+async function handleCompressionStatus(args, extra) {
+  const start = Date.now();
+  try {
+    const settings = await getCompressionSettings();
+    await snapshotMcpDescriptionCompressionStats();
+    const analyticsSummary = getCompressionAnalyticsSummary();
+    const mcpDescriptionStats = getMcpDescriptionCompressionStats();
+    const cacheStats = getCacheStatsSummary();
+    const result = {
+      enabled: settings.enabled,
+      strategy: settings.defaultMode || "standard",
+      settings: {
+        maxTokens: settings.autoTriggerTokens,
+        autoTriggerMode: settings.autoTriggerMode ?? "lite",
+        targetRatio: 0.7,
+        // Default target ratio
+        preserveSystemPrompt: settings.preserveSystemPrompt,
+        mcpDescriptionCompressionEnabled: settings.mcpDescriptionCompressionEnabled !== false
+      },
+      analytics: {
+        totalRequests: analyticsSummary.totalRequests,
+        compressedRequests: Object.values(analyticsSummary.byMode ?? {}).reduce(
+          (sum, mode) => sum + mode.count,
+          0
+        ),
+        tokensSaved: analyticsSummary.totalTokensSaved,
+        avgCompressionRatio: analyticsSummary.avgSavingsPct,
+        byMode: analyticsSummary.byMode ?? {},
+        byEngine: analyticsSummary.byEngine ?? {},
+        byCompressionCombo: analyticsSummary.byCompressionCombo ?? {},
+        validationFallbacks: analyticsSummary.validationFallbacks,
+        requestsWithReceipts: analyticsSummary.realUsage.requestsWithReceipts,
+        realUsage: analyticsSummary.realUsage,
+        mcpDescriptionCompression: {
+          descriptionsCompressed: mcpDescriptionStats.descriptionsCompressed,
+          charsBefore: mcpDescriptionStats.charsBefore,
+          charsAfter: mcpDescriptionStats.charsAfter,
+          charsSaved: mcpDescriptionStats.charsSaved,
+          estimatedTokensSaved: mcpDescriptionStats.estimatedTokensSaved,
+          persistedEstimatedTokensSaved: analyticsSummary.mcpDescriptionCompression.estimatedTokensSaved,
+          persistedSnapshots: analyticsSummary.mcpDescriptionCompression.snapshots,
+          source: "mcp_metadata_estimate",
+          notProviderUsage: true
+        }
+      },
+      cacheStats: cacheStats ? {
+        hits: Math.round(cacheStats.cacheHitRate * (cacheStats.totalRequests || 1)),
+        misses: Math.round((1 - cacheStats.cacheHitRate) * (cacheStats.totalRequests || 1)),
+        hitRate: `${(cacheStats.cacheHitRate * 100).toFixed(2)}%`,
+        tokensSaved: Math.round(cacheStats.avgNetSavings)
+      } : null
+    };
+    const duration = Date.now() - start;
+    await logToolCall("omniroute_compression_status", args, result, duration, true);
+    return result;
+  } catch (error) {
+    const duration = Date.now() - start;
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    await logToolCall(
+      "omniroute_compression_status",
+      args,
+      { error: errorMessage },
+      duration,
+      false,
+      "ERROR"
+    );
+    throw error;
+  }
+}
+async function handleCompressionConfigure(args, extra) {
+  const start = Date.now();
+  try {
+    const updates = {};
+    if (args.enabled !== void 0) {
+      updates.enabled = args.enabled;
+    }
+    if (args.strategy !== void 0) {
+      updates.defaultMode = args.strategy;
+    }
+    if (args.autoTriggerMode !== void 0) {
+      updates.autoTriggerMode = args.autoTriggerMode;
+    }
+    if (args.maxTokens !== void 0) {
+      updates.autoTriggerTokens = args.maxTokens;
+    }
+    if (args.preserveSystemPrompt !== void 0) {
+      updates.preserveSystemPrompt = args.preserveSystemPrompt;
+    }
+    if (args.mcpDescriptionCompressionEnabled !== void 0) {
+      updates.mcpDescriptionCompressionEnabled = args.mcpDescriptionCompressionEnabled;
+    }
+    const settings = await updateCompressionSettings(updates);
+    const result = {
+      success: true,
+      updated: updates,
+      settings: {
+        enabled: settings.enabled,
+        strategy: settings.defaultMode || "standard",
+        autoTriggerMode: settings.autoTriggerMode ?? "lite",
+        maxTokens: settings.autoTriggerTokens,
+        targetRatio: 0.7,
+        // Default target ratio
+        preserveSystemPrompt: settings.preserveSystemPrompt,
+        mcpDescriptionCompressionEnabled: settings.mcpDescriptionCompressionEnabled !== false
+      }
+    };
+    const duration = Date.now() - start;
+    await logToolCall("omniroute_compression_configure", args, result, duration, true);
+    return result;
+  } catch (error) {
+    const duration = Date.now() - start;
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    await logToolCall(
+      "omniroute_compression_configure",
+      args,
+      { error: errorMessage },
+      duration,
+      false,
+      "ERROR"
+    );
+    throw error;
+  }
+}
+import { z } from "zod";
+import {
+  compressionStatusInput,
+  compressionConfigureInput,
+  setCompressionEngineInput,
+  listCompressionCombosInput,
+  compressionComboStatsInput
+} from "../schemas/tools.ts";
+import { handleCcrRetrieve } from "../../services/compression/engines/ccr/index.ts";
+import {
+  listRtkCommandSamples,
+  discoverRepeatedNoise,
+  suggestFilter,
+  commandToId
+} from "../../services/compression/engines/rtk/index.ts";
+import { resolveCallerScopeContext } from "../scopeEnforcement.ts";
+import { resolveMcpCallerApiKeyId } from "../mcpCallerIdentity.ts";
+const ccrRetrieveInput = z.object({
+  hash: z.string().min(6).max(64).describe("24-hex content hash from a [CCR retrieve hash=<hash>] marker"),
+  mode: z.enum(["full", "head", "tail", "lines", "grep", "stats"]).optional().describe("Retrieval mode: full (default) | head | tail | lines | grep | stats"),
+  n: z.number().int().positive().max(1e4).optional().describe("head/tail: number of lines"),
+  start: z.number().int().positive().optional().describe("lines: 1-indexed inclusive start"),
+  end: z.number().int().positive().optional().describe("lines: 1-indexed inclusive end"),
+  pattern: z.string().max(512).optional().describe("grep: regex (validated safe; ReDoS-rejected)"),
+  unique: z.boolean().optional().describe("grep: dedupe matching lines")
+});
+async function handleSetCompressionEngine(args) {
+  const updates = { enabled: true };
+  if (args.engine) {
+    updates.defaultMode = args.engine === "caveman" ? "standard" : args.engine;
+    if (args.engine === "off") updates.enabled = false;
+  }
+  if (args.cavemanIntensity) {
+    const current = await getCompressionSettings();
+    updates.cavemanConfig = {
+      ...current.cavemanConfig ?? {},
+      intensity: args.cavemanIntensity
+    };
+  }
+  if (args.rtkIntensity) {
+    const current = await getCompressionSettings();
+    updates.rtkConfig = {
+      ...current.rtkConfig ?? {},
+      intensity: args.rtkIntensity
+    };
+  }
+  if (args.outputMode !== void 0) {
+    const current = await getCompressionSettings();
+    updates.cavemanOutputMode = {
+      ...current.cavemanOutputMode ?? {},
+      enabled: args.outputMode
+    };
+  }
+  const settings = await updateCompressionSettings(updates);
+  return { success: true, settings };
+}
+async function handleListCompressionCombos() {
+  return { combos: listCompressionCombos() };
+}
+async function handleCompressionComboStats(args) {
+  const summary = getCompressionAnalyticsSummary(args.since === "all" ? void 0 : args.since);
+  if (!args.comboId) return summary;
+  return {
+    comboId: args.comboId,
+    summary,
+    combo: summary.byCompressionCombo[args.comboId] ?? { count: 0, tokensSaved: 0 }
+  };
+}
+const rtkDiscoverInput = z.object({
+  limit: z.number().int().positive().max(2e3).optional().describe("Max samples to scan (default 500)")
+});
+const rtkLearnInput = z.object({
+  command: z.string().min(1).max(500).describe("The command to learn an RTK filter draft for"),
+  limit: z.number().int().positive().max(2e3).optional().describe("Max samples to scan (default 500)")
+});
+function resolveSampleLimit(limit) {
+  if (!Number.isFinite(limit) || !limit || limit <= 0) return 500;
+  return Math.min(2e3, Math.floor(limit));
+}
+async function handleRtkDiscover(args) {
+  const start = Date.now();
+  const samples = listRtkCommandSamples({ limit: resolveSampleLimit(args.limit) });
+  const candidates = discoverRepeatedNoise(samples);
+  const result = { sampleCount: samples.length, candidates };
+  await logToolCall("omniroute_rtk_discover", args, result, Date.now() - start, true);
+  return result;
+}
+async function handleRtkLearn(args) {
+  const start = Date.now();
+  const command = args.command.trim();
+  const targetId = commandToId(command);
+  const matching = listRtkCommandSamples({ limit: resolveSampleLimit(args.limit) }).filter(
+    (sample) => commandToId(sample.command) === targetId
+  );
+  const filter = suggestFilter(command, matching);
+  const result = { command, sampleCount: matching.length, filter };
+  await logToolCall("omniroute_rtk_learn", args, result, Date.now() - start, true);
+  return result;
+}
+const compressionTools = {
+  omniroute_compression_status: {
+    name: "omniroute_compression_status",
+    description: "Returns current compression configuration, strategy, analytics summary (requests compressed, tokens saved, avg ratio), and provider-aware cache statistics.",
+    scopes: ["read:compression"],
+    inputSchema: compressionStatusInput,
+    handler: (args) => handleCompressionStatus(args)
+  },
+  omniroute_compression_configure: {
+    name: "omniroute_compression_configure",
+    description: "Configure compression settings at runtime. Supports enabling/disabling compression, changing strategy (off/lite/standard/aggressive/ultra/rtk/stacked), adjusting maxTokens threshold, targetRatio, auto-trigger mode, system prompt preservation, and MCP description compression.",
+    scopes: ["write:compression"],
+    inputSchema: compressionConfigureInput,
+    handler: (args) => handleCompressionConfigure(args)
+  },
+  omniroute_set_compression_engine: {
+    name: "omniroute_set_compression_engine",
+    description: "Set the active compression engine and Caveman/RTK runtime options.",
+    scopes: ["write:compression"],
+    inputSchema: setCompressionEngineInput,
+    handler: (args) => handleSetCompressionEngine(args)
+  },
+  omniroute_list_compression_combos: {
+    name: "omniroute_list_compression_combos",
+    description: "List compression combos and their engine pipelines.",
+    scopes: ["read:compression"],
+    inputSchema: listCompressionCombosInput,
+    handler: (_args) => handleListCompressionCombos()
+  },
+  omniroute_compression_combo_stats: {
+    name: "omniroute_compression_combo_stats",
+    description: "Get compression analytics grouped by engine and compression combo.",
+    scopes: ["read:compression"],
+    inputSchema: compressionComboStatsInput,
+    handler: (args) => handleCompressionComboStats(args)
+  },
+  omniroute_ccr_retrieve: {
+    name: "omniroute_ccr_retrieve",
+    description: "Retrieve the verbatim content block stored by the CCR compression engine. When a large block is compressed, a marker `[CCR retrieve hash=<24hex> chars=N]` is inserted. Pass the hash from the marker to this tool to get the original text back. Optional `mode` (head/tail/lines/grep/stats) retrieves a slice or summary instead of the whole block; omit for the full block. Scope: read:compression. Always available (sticky-on).",
+    scopes: ["read:compression"],
+    inputSchema: ccrRetrieveInput,
+    handler: async (args, extra) => {
+      const apiKeyPrincipal = await resolveMcpCallerApiKeyId();
+      if (apiKeyPrincipal) {
+        return handleCcrRetrieve(args, apiKeyPrincipal);
+      }
+      const { callerId } = resolveCallerScopeContext(extra, ["read:compression"]);
+      return handleCcrRetrieve(args, callerId === "anonymous" ? void 0 : callerId);
+    }
+  },
+  omniroute_rtk_discover: {
+    name: "omniroute_rtk_discover",
+    description: "Mine the opt-in RTK raw-output sample store for recurring noise lines and return them as ranked candidates the operator can turn into strip/collapse filters. Read-only; suggestions only. Scope: read:compression.",
+    scopes: ["read:compression"],
+    inputSchema: rtkDiscoverInput,
+    handler: (args) => handleRtkDiscover(args)
+  },
+  omniroute_rtk_learn: {
+    name: "omniroute_rtk_learn",
+    description: "Suggest an RTK filter draft for a specific command, learned from that command's captured outputs in the opt-in raw-output sample store. Read-only; returns a draft for the operator to review and save. Scope: read:compression.",
+    scopes: ["read:compression"],
+    inputSchema: rtkLearnInput,
+    handler: (args) => handleRtkLearn(args)
+  }
+};
+export {
+  compressionTools,
+  handleCompressionComboStats,
+  handleCompressionConfigure,
+  handleCompressionStatus,
+  handleListCompressionCombos,
+  handleRtkDiscover,
+  handleRtkLearn,
+  handleSetCompressionEngine
+};

package/open-sse/mcp-server/tools/gamificationTools.js

@@ -0,0 +1,134 @@
+import { z } from "zod";
+const gamificationTools = [
+  {
+    name: "gamification_leaderboard",
+    description: "Get leaderboard rankings for a scope (global, weekly, monthly, tokens_shared).",
+    scopes: ["read:gamification"],
+    inputSchema: z.object({
+      scope: z.enum(["global", "weekly", "monthly", "tokens_shared"]).default("global"),
+      limit: z.number().min(1).max(100).default(50)
+    }),
+    handler: async (args) => {
+      const { getTopN } = await import('../../../dist/lib/gamification/leaderboard.js');
+      const entries = await getTopN(args.scope, args.limit);
+      return { entries };
+    }
+  },
+  {
+    name: "gamification_rank",
+    description: "Get rank for an API key in a leaderboard scope.",
+    scopes: ["read:gamification"],
+    inputSchema: z.object({
+      apiKeyId: z.string(),
+      scope: z.enum(["global", "weekly", "monthly", "tokens_shared"]).default("global")
+    }),
+    handler: async (args) => {
+      const { getRank } = await import('../../../dist/lib/gamification/leaderboard.js');
+      const rank = await getRank(args.apiKeyId, args.scope);
+      return { rank };
+    }
+  },
+  {
+    name: "gamification_profile",
+    description: "Get XP, level, and badges for an API key.",
+    scopes: ["read:gamification"],
+    inputSchema: z.object({
+      apiKeyId: z.string()
+    }),
+    handler: async (args) => {
+      const { getXp, getBadges } = await import('../../../dist/lib/db/gamification.js');
+      const { calculateLevel, getLevelTitle, getLevelTier } = await import('../../../dist/lib/gamification/xp.js');
+      const { getStreak } = await import('../../../dist/lib/gamification/streaks.js');
+      const xp = getXp(args.apiKeyId);
+      const badges = getBadges(args.apiKeyId);
+      const streak = await getStreak(args.apiKeyId);
+      const level = xp ? calculateLevel(xp.totalXp) : 1;
+      return {
+        totalXp: xp?.totalXp || 0,
+        level,
+        title: getLevelTitle(level),
+        tier: getLevelTier(level),
+        streak: streak.currentStreak,
+        longestStreak: streak.longestStreak,
+        badges: badges.map((b) => ({ id: b.badgeId, unlockedAt: b.unlockedAt }))
+      };
+    }
+  },
+  {
+    name: "gamification_badges",
+    description: "List all badge definitions or earned badges for an API key.",
+    scopes: ["read:gamification"],
+    inputSchema: z.object({
+      apiKeyId: z.string().optional(),
+      category: z.string().optional()
+    }),
+    handler: async (args) => {
+      const { getBadgeDefinitions, getBadges } = await import('../../../dist/lib/db/gamification.js');
+      if (args.apiKeyId) {
+        const badges = getBadges(args.apiKeyId);
+        return { earned: badges };
+      }
+      const definitions = getBadgeDefinitions(args.category);
+      return { definitions };
+    }
+  },
+  {
+    name: "gamification_transfer",
+    description: "Transfer tokens between API keys.",
+    scopes: ["write:gamification"],
+    inputSchema: z.object({
+      fromApiKeyId: z.string(),
+      toApiKeyId: z.string(),
+      amount: z.number().positive(),
+      reason: z.string().optional()
+    }),
+    handler: async (args) => {
+      const { transferTokens } = await import('../../../dist/lib/gamification/sharing.js');
+      const result = await transferTokens(
+        args.fromApiKeyId,
+        args.toApiKeyId,
+        args.amount,
+        args.reason
+      );
+      return result;
+    }
+  },
+  {
+    name: "gamification_invite",
+    description: "Create an invite token for server connection.",
+    scopes: ["write:gamification"],
+    inputSchema: z.object({
+      apiKeyId: z.string(),
+      serverUrl: z.string().optional(),
+      maxUses: z.number().positive().default(1)
+    }),
+    handler: async (args) => {
+      const { createInvite } = await import('../../../dist/lib/gamification/invites.js');
+      const result = await createInvite(args.apiKeyId, args.serverUrl, args.maxUses);
+      return result;
+    }
+  },
+  {
+    name: "gamification_servers",
+    description: "List connected community servers.",
+    scopes: ["read:gamification"],
+    inputSchema: z.object({}),
+    handler: async () => {
+      const { listServers } = await import('../../../dist/lib/gamification/servers.js');
+      return { servers: await listServers() };
+    }
+  },
+  {
+    name: "gamification_anomalies",
+    description: "Get flagged anomalous XP activity (admin only).",
+    scopes: ["read:gamification"],
+    inputSchema: z.object({}),
+    handler: async () => {
+      const { getAnomalies } = await import('../../../dist/lib/gamification/antiCheat.js');
+      return { anomalies: await getAnomalies() };
+    }
+  }
+];
+export {
+  gamificationTools
+};

package/open-sse/mcp-server/tools/githubSkillTools.js

@@ -0,0 +1,102 @@
+import { sanitizeErrorMessage } from "../../utils/error.ts";
+import {
+  searchGitHubSkills,
+  scanText,
+  resolveInstallPath,
+  GitHubSkillsSearchSchema,
+  GitHubSkillsScanSchema,
+  GitHubSkillsInstallSchema
+} from '../../../dist/lib/skills/githubCollector.js';
+async function handleSearch(args) {
+  const { repos, errors } = await searchGitHubSkills({
+    minStars: args.minStars,
+    maxResults: args.maxResults
+  });
+  let filtered = repos;
+  if (args.minScore > 0) filtered = filtered.filter((r) => r.score >= args.minScore);
+  if (args.query) {
+    const q = args.query.toLowerCase();
+    filtered = filtered.filter(
+      (r) => r.fullName.toLowerCase().includes(q) || r.description.toLowerCase().includes(q)
+    );
+  }
+  return {
+    skills: filtered.map((r) => ({
+      fullName: r.fullName,
+      stars: r.stars,
+      score: r.score,
+      description: r.description.slice(0, 200),
+      topics: r.topics,
+      htmlUrl: r.htmlUrl,
+      hasSkillFile: r.hasSkillFile,
+      license: r.license
+    })),
+    total: filtered.length,
+    errors: errors.length > 0 ? errors : void 0
+  };
+}
+async function handleScan(args) {
+  const findings = scanText(args.content, args.repoName);
+  return {
+    repoName: args.repoName,
+    clean: findings.length === 0,
+    findings: findings.map((f) => ({
+      pattern: f.pattern,
+      context: f.context
+    }))
+  };
+}
+async function handleInstall(args) {
+  const results = [];
+  const skillName = args.repoName.split("/").pop() || args.repoName;
+  for (const target of args.targets) {
+    try {
+      const dest = resolveInstallPath(target, skillName, args.description);
+      results.push({
+        target,
+        ok: true,
+        action: "installed",
+        destDir: dest
+      });
+    } catch (err) {
+      results.push({
+        target,
+        ok: false,
+        action: "error",
+        error: sanitizeErrorMessage(err.message)
+      });
+    }
+  }
+  return {
+    repoName: args.repoName,
+    skillName,
+    results,
+    allOk: results.every((r) => r.ok)
+  };
+}
+const githubSkillTools = {
+  omniroute_github_skills_search: {
+    name: "omniroute_github_skills_search",
+    description: "Search GitHub for agent skill repositories that contain SKILL.md, CLAUDE.md, .cursorrules, or similar agent configuration files. Returns scored results sorted by relevance. Scores are 0.0\u20131.0 based on stars, name signals, description keywords, and topic tags. Ideal for discovering community agent skills from GitHub.",
+    inputSchema: GitHubSkillsSearchSchema,
+    scopes: ["read:skills"],
+    handler: handleSearch
+  },
+  omniroute_github_skills_scan: {
+    name: "omniroute_github_skills_scan",
+    description: "Scan SKILL.md or README content from a GitHub repo for blocked patterns including eval(base64), hardcoded secrets (API keys, passwords, private keys), dangerous function calls (os.system, subprocess.Popen), and other malware indicators. Returns findings with context or 'clean' status.",
+    inputSchema: GitHubSkillsScanSchema,
+    scopes: ["read:skills"],
+    handler: handleScan
+  },
+  omniroute_github_skills_install: {
+    name: "omniroute_github_skills_install",
+    description: "Preview or plan the installation of a discovered GitHub skill into one or more agent directories (Hermes: ~/AppData/Local/hermes/skills/, Claude: ~/.claude/skills/, Gemini: ~/.gemini/skills/, OpenCode: ~/.opencode/skills/). Categorizes the skill based on its name and description. Returns the target paths where the skill would be installed.",
+    inputSchema: GitHubSkillsInstallSchema,
+    scopes: ["read:skills", "write:skills"],
+    handler: handleInstall
+  }
+};
+export {
+  githubSkillTools
+};