@fudrouter/fsrouter 0.6.58 → 0.6.60

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

@@ -1,223 +0,0 @@
-import { logToolCall } from "../audit.ts";
-import { getMcpHttpAuthHeadersForInternalFetch } from "../httpAuthContext.ts";
-import { normalizeQuotaResponse } from "../../../src/shared/contracts/quota.ts";
-import { resolveOmniRouteBaseUrl } from "../../../src/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

@@ -1,181 +0,0 @@
-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

@@ -1,139 +0,0 @@
-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

@@ -1,113 +0,0 @@
-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

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