@fudrouter/fsrouter 0.6.64 → 0.6.65

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

@@ -0,0 +1,223 @@
+import { logToolCall } from "../audit.ts";
+import { getMcpHttpAuthHeadersForInternalFetch } from "../httpAuthContext.ts";
+import { normalizeQuotaResponse } from "../../../shared/contracts/quota.ts";
+import { resolveOmniRouteBaseUrl } from "../../../shared/utils/resolveOmniRouteBaseUrl.ts";
+import {
+  getComboModelProvider,
+  getComboModelString,
+  getComboStepTarget
+} from '../../../dist/lib/combos/steps.ts.js';
+import { rankBySpeed, DEFAULT_SPEED_WEIGHTS } from "../../services/autoCombo/speedRanking.ts";
+const OMNIROUTE_BASE_URL = resolveOmniRouteBaseUrl();
+const OMNIROUTE_API_KEY = process.env.OMNIROUTE_API_KEY || "";
+async function apiFetch(path, options = {}) {
+  const url = `${OMNIROUTE_BASE_URL}${path}`;
+  const headers = {
+    "Content-Type": "application/json",
+    ...OMNIROUTE_API_KEY ? { Authorization: `Bearer ${OMNIROUTE_API_KEY}` } : {},
+    ...getMcpHttpAuthHeadersForInternalFetch(),
+    ...options.headers || {}
+  };
+  const response = await fetch(url, { ...options, headers, signal: AbortSignal.timeout(3e4) });
+  if (!response.ok) {
+    const text = await response.text().catch(() => "Unknown error");
+    throw new Error(`API [${response.status}]: ${text}`);
+  }
+  return response.json();
+}
+function isRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function toRecord(value) {
+  return isRecord(value) ? value : {};
+}
+function toArrayOfRecords(value) {
+  return Array.isArray(value) ? value.filter(isRecord) : [];
+}
+function toString(value, fallback = "") {
+  return typeof value === "string" ? value : fallback;
+}
+function toNumber(value, fallback = 0) {
+  const parsed = typeof value === "number" ? value : typeof value === "string" && value.trim().length > 0 ? Number(value) : Number.NaN;
+  return Number.isFinite(parsed) ? parsed : fallback;
+}
+function getComboModels(combo) {
+  const directModels = toArrayOfRecords(combo.models);
+  const nestedModels = toArrayOfRecords(toRecord(combo.data).models);
+  const sourceModels = directModels.length > 0 ? directModels : nestedModels;
+  return sourceModels.map((model) => ({
+    provider: getComboModelProvider(model) || (getComboModelString(model) ? "unknown" : "combo"),
+    model: getComboModelString(model) || getComboStepTarget(model) || "",
+    inputCostPer1M: toNumber(model.inputCostPer1M, 3)
+  }));
+}
+function normalizeCombosResponse(raw) {
+  if (Array.isArray(raw)) return raw.filter(isRecord);
+  const source = toRecord(raw);
+  return Array.isArray(source.combos) ? source.combos.filter(isRecord) : [];
+}
+function settledValue(result) {
+  return result.status === "fulfilled" ? result.value : void 0;
+}
+async function fetchTelemetrySources() {
+  const [combosRaw, healthRaw, quotaRaw, analyticsRaw] = await Promise.allSettled([
+    apiFetch("/api/combos"),
+    apiFetch("/api/monitoring/health"),
+    apiFetch("/api/usage/quota"),
+    apiFetch("/api/usage/analytics?period=session")
+  ]);
+  const analytics = toRecord(settledValue(analyticsRaw));
+  return {
+    combos: normalizeCombosResponse(settledValue(combosRaw)),
+    breakers: toArrayOfRecords(toRecord(settledValue(healthRaw)).circuitBreakers),
+    providers: normalizeQuotaResponse(settledValue(quotaRaw) ?? {}).providers,
+    analyticsByProvider: toRecord(toRecord(analytics.byProvider)),
+    analyticsTop: analytics
+  };
+}
+function selectComboScope(combos, comboId) {
+  const targetCombo = comboId ? combos.find((combo) => toString(combo.id) === comboId || toString(combo.name) === comboId) : void 0;
+  return {
+    targetCombo,
+    scopedCombos: targetCombo ? [targetCombo] : combos.filter((combo) => combo.enabled !== false)
+  };
+}
+function noCandidatesResult(error) {
+  return { content: [{ type: "text", text: JSON.stringify({ error }) }], isError: true };
+}
+function providerAnalytics(sources, provider) {
+  const perProvider = toRecord(sources.analyticsByProvider[provider]);
+  return perProvider.requests ? perProvider : toRecord(sources.analyticsTop.byProvider && toRecord(sources.analyticsTop.byProvider)[provider]);
+}
+function buildCandidate(model, sources) {
+  const cb = sources.breakers.find((breaker) => toString(breaker.provider) === model.provider);
+  const q = sources.providers.find((providerEntry) => providerEntry.provider === model.provider);
+  const analytics = providerAnalytics(sources, model.provider);
+  const cbState = toString(cb?.state, "CLOSED");
+  const p95 = toNumber(analytics.p95LatencyMs, NaN);
+  const errorRate = toNumber(analytics.errorRate, 0);
+  return {
+    provider: model.provider,
+    model: model.model,
+    circuitBreakerState: cbState,
+    avgE2ELatencyMs: toNumber(analytics.avgLatencyMs, NaN),
+    p95LatencyMs: Number.isFinite(p95) ? p95 : 0,
+    avgTokensPerSecond: toNumber(analytics.avgTokensPerSecond ?? analytics.tps, NaN),
+    avgTtftMs: toNumber(analytics.avgTtftMs ?? analytics.ttftMs, NaN),
+    latencyStdDev: toNumber(analytics.latencyStdDev, NaN),
+    errorRate: Number.isFinite(errorRate) ? errorRate : 0,
+    failureRate: Number.isFinite(errorRate) ? errorRate : 0,
+    quotaRemaining: q?.quotaUsed != null && q?.quotaTotal ? Math.max(0, 100 - q.quotaUsed / q.quotaTotal * 100) : 100,
+    quotaTotal: q?.quotaTotal ?? 100,
+    costPer1MTokens: model.inputCostPer1M ?? 0
+  };
+}
+function buildSpeedCandidates(scopedCombos, sources) {
+  const speedCandidates = [];
+  for (const combo of scopedCombos) {
+    for (const model of getComboModels(combo)) {
+      if (model.provider && model.model) speedCandidates.push(buildCandidate(model, sources));
+    }
+  }
+  return speedCandidates;
+}
+function candidateCompletenessScore(candidate) {
+  return (candidate.circuitBreakerState ? 1 : 0) + (candidate.quotaRemaining != null ? 1 : 0);
+}
+function dedupeCandidates(candidates) {
+  const deduped = /* @__PURE__ */ new Map();
+  for (const candidate of candidates) {
+    const key = `${candidate.provider}::${candidate.model}`;
+    const existing = deduped.get(key);
+    if (!existing || candidateCompletenessScore(candidate) > candidateCompletenessScore(existing)) {
+      deduped.set(key, candidate);
+    }
+  }
+  return [...deduped.values()];
+}
+async function applyWinnerToCombo(targetCombo, winner) {
+  const comboId = toString(targetCombo.id);
+  const comboData = toRecord(targetCombo.data);
+  const baseConfig = toRecord(targetCombo.config);
+  const currentConfig = Object.keys(baseConfig).length > 0 ? baseConfig : toRecord(comboData.config);
+  const nextConfig = {
+    ...currentConfig,
+    auto: {
+      ...toRecord(currentConfig.auto),
+      routerStrategy: "latency"
+    }
+  };
+  const updatedCombo = toRecord(
+    await apiFetch(`/api/combos/${encodeURIComponent(comboId)}`, {
+      method: "PUT",
+      body: JSON.stringify({ strategy: "auto", config: nextConfig })
+    })
+  );
+  const updatedConfig = toRecord(updatedCombo.config);
+  return {
+    id: toString(updatedCombo.id, comboId),
+    name: toString(updatedCombo.name, toString(targetCombo.name, comboId)),
+    strategy: toString(updatedCombo.strategy, "auto"),
+    autoRoutingStrategy: toString(toRecord(updatedConfig.auto).routerStrategy, "latency")
+  };
+}
+async function handlePickFastestModel(args) {
+  const start = Date.now();
+  try {
+    const sources = await fetchTelemetrySources();
+    const { targetCombo, scopedCombos } = selectComboScope(sources.combos, args.comboId);
+    if (scopedCombos.length === 0) {
+      return noCandidatesResult("No matching combos available");
+    }
+    const finalCandidates = dedupeCandidates(buildSpeedCandidates(scopedCombos, sources));
+    if (finalCandidates.length === 0) {
+      return noCandidatesResult("No provider\xD7model candidates available to rank");
+    }
+    const weights = args.weights ? { ...DEFAULT_SPEED_WEIGHTS, ...args.weights } : DEFAULT_SPEED_WEIGHTS;
+    const ranked = rankBySpeed(finalCandidates, weights, {
+      includeUnhealthy: args.includeUnhealthy === true
+    });
+    const limit = Math.min(Math.max(toNumber(args.limit, 10), 1), 50);
+    const trimmed = ranked.slice(0, limit);
+    const winner = trimmed[0];
+    let appliedToCombo = null;
+    if (args.applyToCombo && targetCombo && winner) {
+      appliedToCombo = await applyWinnerToCombo(targetCombo, winner);
+    }
+    const result = {
+      fastest: winner ? {
+        provider: winner.provider,
+        model: winner.model,
+        score: winner.score,
+        reason: winner.reason
+      } : null,
+      ranked: trimmed.map((entry) => ({
+        provider: entry.provider,
+        model: entry.model,
+        score: entry.score,
+        factors: entry.factors,
+        metrics: entry.metrics,
+        reason: entry.reason
+      })),
+      weights,
+      comboScope: targetCombo ? { id: toString(targetCombo.id), name: toString(targetCombo.name) } : null,
+      appliedToCombo
+    };
+    await logToolCall("omniroute_pick_fastest_model", args, result, Date.now() - start, true);
+    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    await logToolCall(
+      "omniroute_pick_fastest_model",
+      args,
+      null,
+      Date.now() - start,
+      false,
+      msg
+    );
+    return { content: [{ type: "text", text: `Error: ${msg}` }], isError: true };
+  }
+}
+export {
+  handlePickFastestModel
+};

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

@@ -0,0 +1,181 @@
+import { z } from "zod";
+import { resolve, normalize, isAbsolute } from "path";
+import { listPlugins, getPluginByName, updatePluginConfig } from '../../../dist/lib/db/plugins.js';
+import { pluginManager } from '../../../dist/lib/plugins/manager.js';
+import { validatePluginConfig } from '../../../dist/lib/plugins/manifest.js';
+function validatePluginPath(path) {
+  if (path.includes("\0")) {
+    throw new Error("Invalid path: contains null bytes");
+  }
+  if (!isAbsolute(path)) {
+    throw new Error("Path must be absolute");
+  }
+  const normalized = normalize(resolve(path));
+  if (normalized.includes("..") || normalized.includes("~")) {
+    throw new Error("Invalid path: directory traversal detected");
+  }
+  return normalized;
+}
+const pluginTools = [
+  {
+    name: "plugin_list",
+    description: "List all installed plugins with their status, hooks, and metadata.",
+    scopes: ["read:plugins"],
+    inputSchema: z.object({
+      status: z.enum(["installed", "active", "inactive", "error"]).optional().describe("Filter by plugin status")
+    }),
+    handler: async (args) => {
+      const plugins = listPlugins(args.status);
+      return {
+        plugins: plugins.map((p) => ({
+          name: p.name,
+          version: p.version,
+          description: p.description,
+          status: p.status,
+          enabled: p.enabled === 1,
+          hooks: JSON.parse(p.hooks || "[]"),
+          permissions: JSON.parse(p.permissions || "[]"),
+          installedAt: p.installedAt,
+          activatedAt: p.activatedAt
+        }))
+      };
+    }
+  },
+  {
+    name: "plugin_install",
+    description: "Install a plugin from a local directory path.",
+    scopes: ["write:plugins"],
+    inputSchema: z.object({
+      path: z.string().describe("Absolute path to the plugin directory containing plugin.json")
+    }),
+    handler: async (args) => {
+      const safePath = validatePluginPath(args.path);
+      const plugin = await pluginManager.install(safePath);
+      return {
+        success: true,
+        plugin: {
+          name: plugin.name,
+          version: plugin.version,
+          status: plugin.status
+        }
+      };
+    }
+  },
+  {
+    name: "plugin_activate",
+    description: "Activate an installed plugin (loads hooks into the request pipeline).",
+    scopes: ["write:plugins"],
+    inputSchema: z.object({
+      name: z.string().describe("Plugin name (kebab-case)")
+    }),
+    handler: async (args) => {
+      try {
+        await pluginManager.activate(args.name);
+        return { success: true, message: `Plugin '${args.name}' activated` };
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { success: false, error: msg };
+      }
+    }
+  },
+  {
+    name: "plugin_deactivate",
+    description: "Deactivate an active plugin (unloads hooks from the request pipeline).",
+    scopes: ["write:plugins"],
+    inputSchema: z.object({
+      name: z.string().describe("Plugin name (kebab-case)")
+    }),
+    handler: async (args) => {
+      try {
+        await pluginManager.deactivate(args.name);
+        return { success: true, message: `Plugin '${args.name}' deactivated` };
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { success: false, error: msg };
+      }
+    }
+  },
+  {
+    name: "plugin_uninstall",
+    description: "Uninstall a plugin (deactivates, removes files, removes from DB).",
+    scopes: ["write:plugins"],
+    inputSchema: z.object({
+      name: z.string().describe("Plugin name (kebab-case)")
+    }),
+    handler: async (args) => {
+      try {
+        await pluginManager.uninstall(args.name);
+        return { success: true, message: `Plugin '${args.name}' uninstalled` };
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { success: false, error: msg };
+      }
+    }
+  },
+  {
+    name: "plugin_configure",
+    description: "Get or update a plugin's configuration.",
+    scopes: ["write:plugins"],
+    inputSchema: z.object({
+      name: z.string().describe("Plugin name"),
+      config: z.record(z.string(), z.unknown()).optional().describe("New config values to merge (omit to just read current config)")
+    }),
+    handler: async (args) => {
+      const plugin = getPluginByName(args.name);
+      if (!plugin) return { success: false, error: `Plugin '${args.name}' not found` };
+      if (args.config) {
+        const current = JSON.parse(plugin.config || "{}");
+        const merged = { ...current, ...args.config };
+        const rawSchema = JSON.parse(plugin.configSchema || "{}");
+        if (Object.keys(rawSchema).length > 0) {
+          const validation = validatePluginConfig(merged, rawSchema);
+          if (!validation.valid) {
+            return { success: false, error: "Config validation failed: one or more values are invalid" };
+          }
+        }
+        updatePluginConfig(args.name, merged);
+        return { success: true, config: merged };
+      }
+      return {
+        config: JSON.parse(plugin.config || "{}"),
+        configSchema: JSON.parse(plugin.configSchema || "{}")
+      };
+    }
+  },
+  {
+    name: "plugin_executions",
+    description: "View plugin execution metrics (from plugin_analytics table).",
+    scopes: ["read:plugins"],
+    inputSchema: z.object({
+      name: z.string().optional().describe("Filter by plugin name"),
+      limit: z.number().min(1).max(100).default(20).describe("Max results to return")
+    }),
+    handler: async (args) => {
+      const { getPluginAnalytics, getPluginAnalyticsSummary } = await import('../../../dist/lib/db/plugins.js');
+      const limit = args.limit || 20;
+      if (args.name) {
+        const rows = getPluginAnalytics(args.name).slice(0, limit);
+        return { metrics: rows };
+      }
+      const allPlugins = listPlugins();
+      const metrics = allPlugins.slice(0, limit).map((p) => getPluginAnalyticsSummary(p.name));
+      return { metrics };
+    }
+  },
+  {
+    name: "plugin_scan",
+    description: "Scan the plugin directory for new plugins and sync with DB.",
+    scopes: ["write:plugins"],
+    inputSchema: z.object({}),
+    handler: async () => {
+      const result = await pluginManager.scan();
+      return {
+        discovered: result.discovered,
+        errors: result.errors
+      };
+    }
+  }
+];
+export {
+  pluginTools
+};

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

@@ -0,0 +1,139 @@
+import { z } from "zod";
+import { PoolRegistry } from "../../services/sessionPool/poolRegistry.ts";
+import { getWebSessionPoolHealth } from "../../services/webSessionPoolHealth.ts";
+import { getBrowserPoolMetrics } from "../../services/browserPool.ts";
+const poolStatusInput = z.object({
+  provider: z.string().optional().describe("Provider name (e.g. 'pollinations'). Omit to list all pools")
+});
+const poolSessionsInput = z.object({
+  provider: z.string().describe("Provider name (e.g. 'pollinations')")
+});
+const poolResetInput = z.object({
+  provider: z.string().describe("Provider name (e.g. 'pollinations')")
+});
+const poolWarmInput = z.object({
+  provider: z.string().describe("Provider name (e.g. 'pollinations')"),
+  count: z.number().int().min(1).max(50).default(6).describe("Target session count (1\u201350)")
+});
+const poolHealthInput = z.object({
+  provider: z.string().optional().describe("Provider name (e.g. 'pollinations'). Omit to list all pools")
+});
+async function handlePoolStatus(args) {
+  if (args.provider) {
+    const stats = PoolRegistry.getStats(args.provider);
+    if (!stats) {
+      return { error: `No pool found for provider '${args.provider}'` };
+    }
+    return { provider: args.provider, stats };
+  }
+  const all = PoolRegistry.getAllStats();
+  return {
+    totalPools: all.length,
+    providers: PoolRegistry.listProviders(),
+    pools: all
+  };
+}
+async function handlePoolSessions(args) {
+  const details = PoolRegistry.getSessionDetails(args.provider);
+  if (!details) {
+    return { error: `No pool found for provider '${args.provider}'` };
+  }
+  const stats = PoolRegistry.getStats(args.provider);
+  return {
+    provider: args.provider,
+    sessionCount: details.length,
+    stats,
+    sessions: details
+  };
+}
+async function handlePoolReset(args) {
+  const existed = PoolRegistry.resetPool(args.provider);
+  return {
+    provider: args.provider,
+    reset: existed,
+    message: existed ? `Pool '${args.provider}' shut down and removed. It will be recreated on next request.` : `No pool found for provider '${args.provider}'`
+  };
+}
+async function handlePoolWarm(args) {
+  const pool = PoolRegistry.getPool(args.provider);
+  if (!pool) {
+    return { error: `No pool found for provider '${args.provider}'` };
+  }
+  const before = pool.totalCount;
+  await pool.warmUp(args.count);
+  const after = pool.totalCount;
+  return {
+    provider: args.provider,
+    targetCount: args.count,
+    sessionsBefore: before,
+    sessionsAfter: after,
+    created: after - before
+  };
+}
+async function handlePoolHealth(args) {
+  const report = getWebSessionPoolHealth(args.provider);
+  return report;
+}
+const browserPoolStatusInput = z.object({});
+async function handleBrowserPoolStatus() {
+  return getBrowserPoolMetrics();
+}
+const poolTools = {
+  omniroute_pool_status: {
+    name: "omniroute_pool_status",
+    description: "Returns session pool status for a specific provider or all providers. Includes session counts by state (active/cooldown/dead), request totals, success rate, and throughput.",
+    scopes: ["read:health"],
+    inputSchema: poolStatusInput,
+    handler: (args) => handlePoolStatus(args)
+  },
+  omniroute_pool_sessions: {
+    name: "omniroute_pool_sessions",
+    description: "Lists all sessions in a provider's pool with per-session details: fingerprint, status, request counts, inflight, cooldown remaining, and age.",
+    scopes: ["read:health"],
+    inputSchema: poolSessionsInput,
+    handler: (args) => handlePoolSessions(args)
+  },
+  omniroute_pool_reset: {
+    name: "omniroute_pool_reset",
+    description: "Shuts down and removes all sessions for a provider's pool. A new pool will be created automatically on the next request.",
+    scopes: ["write:resilience"],
+    inputSchema: poolResetInput,
+    handler: (args) => handlePoolReset(args)
+  },
+  omniroute_pool_warm: {
+    name: "omniroute_pool_warm",
+    description: "Warms a session pool to the specified session count (1\u201350). Sessions beyond the current count are created with fresh browser fingerprints.",
+    scopes: ["write:resilience"],
+    inputSchema: poolWarmInput,
+    handler: (args) => handlePoolWarm(args)
+  },
+  omniroute_pool_health: {
+    name: "omniroute_pool_health",
+    description: "Returns aggregated web-session pool health: pool stats + circuit breaker state + per-session details + health status (healthy/degraded/down) + issues list.",
+    scopes: ["read:health"],
+    inputSchema: poolHealthInput,
+    handler: (args) => handlePoolHealth(args)
+  },
+  omniroute_browser_pool_status: {
+    name: "omniroute_browser_pool_status",
+    description: "Returns the stealth browser pool's live status (enabled, active contexts, browser running, stealth available, idle age) plus cumulative lifecycle telemetry: browser launches/failures, context create/reuse/evict/release counts, context-create failures, and shutdowns with the last reason.",
+    scopes: ["read:health"],
+    inputSchema: browserPoolStatusInput,
+    handler: () => handleBrowserPoolStatus()
+  }
+};
+export {
+  browserPoolStatusInput,
+  handleBrowserPoolStatus,
+  handlePoolHealth,
+  handlePoolReset,
+  handlePoolSessions,
+  handlePoolStatus,
+  handlePoolWarm,
+  poolHealthInput,
+  poolResetInput,
+  poolSessionsInput,
+  poolStatusInput,
+  poolTools,
+  poolWarmInput
+};

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

@@ -0,0 +1,113 @@
+import { z } from "zod";
+import { skillRegistry } from '../../../dist/lib/skills/registry.js';
+import { skillExecutor } from '../../../dist/lib/skills/executor.js';
+const SkillListSchema = z.object({
+  apiKeyId: z.string().optional(),
+  name: z.string().optional(),
+  enabled: z.boolean().optional()
+});
+const SkillEnableSchema = z.object({
+  apiKeyId: z.string(),
+  skillId: z.string(),
+  enabled: z.boolean()
+});
+const SkillExecuteSchema = z.object({
+  apiKeyId: z.string(),
+  skillName: z.string(),
+  input: z.record(z.string(), z.unknown()),
+  sessionId: z.string().optional()
+});
+const skillTools = {
+  omniroute_skills_list: {
+    name: "omniroute_skills_list",
+    description: "List all registered skills with optional filtering by API key or name",
+    scopes: ["read:skills"],
+    inputSchema: SkillListSchema,
+    handler: async (args) => {
+      await skillRegistry.loadFromDatabase(args.apiKeyId);
+      const skills = skillRegistry.list(args.apiKeyId);
+      let filtered = skills;
+      if (args.name) {
+        filtered = filtered.filter((s) => s.name.includes(args.name));
+      }
+      if (args.enabled !== void 0) {
+        filtered = filtered.filter((s) => s.enabled === args.enabled);
+      }
+      return {
+        skills: filtered.map((s) => ({
+          id: s.id,
+          name: s.name,
+          version: s.version,
+          description: s.description,
+          enabled: s.enabled,
+          createdAt: s.createdAt.toISOString()
+        })),
+        count: filtered.length
+      };
+    }
+  },
+  omniroute_skills_enable: {
+    name: "omniroute_skills_enable",
+    description: "Enable or disable a specific skill by ID",
+    scopes: ["write:skills"],
+    inputSchema: SkillEnableSchema,
+    handler: async (args) => {
+      await skillRegistry.loadFromDatabase(args.apiKeyId);
+      const skill = await skillRegistry.setEnabledById(args.skillId, args.apiKeyId, args.enabled);
+      if (!skill) {
+        throw new Error(`Skill not found: ${args.skillId}`);
+      }
+      return { success: true, skillId: args.skillId, enabled: args.enabled };
+    }
+  },
+  omniroute_skills_execute: {
+    name: "omniroute_skills_execute",
+    description: "Execute a skill with provided input and return the result",
+    scopes: ["execute:skills"],
+    inputSchema: SkillExecuteSchema,
+    handler: async (args) => {
+      const execution = await skillExecutor.execute(args.skillName, args.input, {
+        apiKeyId: args.apiKeyId,
+        sessionId: args.sessionId
+      });
+      return {
+        id: execution.id,
+        skillId: execution.skillId,
+        status: execution.status,
+        output: execution.output,
+        error: execution.errorMessage,
+        duration: execution.durationMs,
+        createdAt: execution.createdAt.toISOString()
+      };
+    }
+  },
+  omniroute_skills_executions: {
+    name: "omniroute_skills_executions",
+    description: "List recent skill execution history",
+    scopes: ["read:skills"],
+    inputSchema: z.object({
+      apiKeyId: z.string().optional(),
+      limit: z.number().int().positive().max(100).optional()
+    }),
+    handler: async (args) => {
+      const executions = skillExecutor.listExecutions(args.apiKeyId, args.limit || 50);
+      return {
+        executions: executions.map((e) => ({
+          id: e.id,
+          skillId: e.skillId,
+          status: e.status,
+          duration: e.durationMs,
+          error: e.errorMessage,
+          createdAt: e.createdAt.toISOString()
+        })),
+        count: executions.length
+      };
+    }
+  }
+};
+export {
+  SkillEnableSchema,
+  SkillExecuteSchema,
+  SkillListSchema,
+  skillTools
+};

package/open-sse/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "open-sse",
+  "version": "1.0.4",
+  "private": true,
+  "type": "module",
+  "main": "index.js",
+  "scripts": {
+    "build": "echo 'No build step for open-sse'"
+  }
+}