@argosvix/mcp-server 0.22.0-alpha.1 → 0.22.0-alpha.3

package/dist/tools.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../src/tools.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,oCAAoC,CAAC;AAyI/D,eAAO,MAAM,KAAK,EAAE,IAAI,EA8gDvB,CAAC;AAEF,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC9B,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,wBAAsB,YAAY,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC;IAChE,OAAO,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC/C,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,CAAC,CAqyBD"}
+{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../src/tools.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,oCAAoC,CAAC;AAkJ/D,eAAO,MAAM,KAAK,EAAE,IAAI,EA2jDvB,CAAC;AAEF,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC9B,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,wBAAsB,YAAY,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC;IAChE,OAAO,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC/C,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,CAAC,CA6tCD"}

package/dist/tools.js

@@ -148,6 +148,15 @@ const TOOL_ARG_ALLOWLIST = {
     // percentiles / llm-budget / audit) を 並列 fetch + 1 narrative response に
     // 圧縮。 window 軸のみ 受け、 backend 新 endpoint 不要 (= 純 read aggregator)。
     get_account_health: ["window"],
+    // 2026-06-05 axis 4 Tier 1 = propose_alert_rules (= AI が baseline 統計から
+    // 推奨 alert rule を 提案、 適用は customer 確認後 create_alert 別 step)。
+    // 既存 4 endpoint (= aggregate ×2 + percentiles + list_alerts) を fetch +
+    // 推奨 JSON を 返す。 backend 新 endpoint 不要。
+    propose_alert_rules: ["lookbackDays"],
+    // 2026-06-05 axis 4 Tier 1 = detect_anomaly (= 現 window vs baseline window
+    // 比較で cost / latency / error_rate / call_volume の 4 軸 異常検出)。
+    // pure MCP-side aggregator、 backend 変更ゼロ。
+    detect_anomaly: ["window", "threshold"],
     // 2026-06-02 Codex round 2 🔴 fix = idempotencyKey 必須 path (= AI agent が
     // retry した時に backend で dedup)、 client が opaque string 64 char で carry。
     run_eval: ["name", "recentCount", "label", "promptRegistryId", "idempotencyKey"],
@@ -1334,6 +1343,49 @@ export const tools = [
             },
         },
     },
+    {
+        name: "detect_anomaly",
+        description: "現 window と baseline window (= 同 length の 1 期前) を 比較して cost / latency / error_rate / call_volume の 4 軸で 異常を検出 (= axis 4 Tier 1 = AI が 1 prompt で 「何か変なことが起きてないか」 把握)。 " +
+            "threshold で 感度 調整可能: sensitive (= 1.5×) / normal (= 2×、 default) / conservative (= 3×)。 detection 数 0-4 件、 各 anomaly は narrative 付き。 " +
+            "返却 = { window, threshold, current: {...}, baseline: {...}, anomalies: [{ axis, severity: 'minor'|'major'|'critical', current, baseline, ratio, narrative }] } 形式。 baseline data 不足 (= 期間 record < 10) は anomalies: [] + warning narrative で carry。",
+        inputSchema: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                window: {
+                    type: "string",
+                    description: "観測 window (= '1h' / '24h' / '7d'、 default '24h')",
+                    enum: ["1h", "24h", "7d"],
+                    default: "24h",
+                },
+                threshold: {
+                    type: "string",
+                    description: "感度 (= 'sensitive' 1.5× / 'normal' 2× / 'conservative' 3×、 default 'normal')",
+                    enum: ["sensitive", "normal", "conservative"],
+                    default: "normal",
+                },
+            },
+        },
+    },
+    {
+        name: "propose_alert_rules",
+        description: "過去 lookbackDays (= 7-30、 default 14) の calls pattern を 分析して、 cost / latency / error_rate / anomaly の 推奨 alert rule を JSON 提案 (= axis 4 Tier 1 = AI が baseline 設計)。 " +
+            "適用は customer 確認後 create_alert で別 step (= propose のみ、 副作用ゼロ)。 既存 alerts と被らない rule のみ 提案 (= list_alerts で 既存 type を fetch)。 " +
+            "返却 = { lookbackDays, baseline: {meanDailyCost, p95Latency, errorRate, dailyCalls}, proposals: [{ name, alertType, thresholdValue, windowMinutes, reasoning }], skipped: [{ alertType, reason }] } 形式。 大手 dashboard が UI で 表示する 軸を MCP-first で 1 prompt 完結。",
+        inputSchema: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                lookbackDays: {
+                    type: "integer",
+                    description: "baseline 算出の lookback 日数 (= 7-30、 default 14)",
+                    minimum: 7,
+                    maximum: 30,
+                    default: 14,
+                },
+            },
+        },
+    },
     {
         name: "get_account_health",
         description: "自社 LLM infra の健康状態 サマリを 1 call で取得 (= axis 4 Tier 1 = 自律 AI ops)。 既存 4 endpoint (= aggregate_calls / get_percentiles / get_llm_budget / list_audit_log) を 並列 fetch して 1 narrative response に圧縮。 " +
@@ -2058,6 +2110,387 @@ export async function dispatchTool(input) {
                 }
                 return await callApi(apiBase, `/v1/projects/${encodeURIComponent(projectId)}`, {}, apiKey, { method: "DELETE" });
             }
+            case "detect_anomaly": {
+                // 2026-06-05 axis 4 Tier 1 = 現 window vs baseline window (= 同 length
+                // の 1 期前) 比較で 4 軸 異常検出。 pure MCP-side aggregator、 backend
+                // 変更ゼロ。 threshold 感度 = 1.5× (sensitive) / 2× (normal) / 3×
+                // (conservative)。 baseline data 不足は anomalies: [] + warning。
+                const winRaw = typeof safeArgs["window"] === "string" ? safeArgs["window"] : "24h";
+                const window = winRaw === "1h" || winRaw === "24h" || winRaw === "7d" ? winRaw : "24h";
+                const thresholdRaw = typeof safeArgs["threshold"] === "string" ? safeArgs["threshold"] : "normal";
+                const threshold = thresholdRaw === "sensitive" ||
+                    thresholdRaw === "normal" ||
+                    thresholdRaw === "conservative"
+                    ? thresholdRaw
+                    : "normal";
+                const multiplier = threshold === "sensitive" ? 1.5 : threshold === "conservative" ? 3 : 2;
+                const windowMs = window === "1h"
+                    ? 60 * 60 * 1000
+                    : window === "24h"
+                        ? 24 * 60 * 60 * 1000
+                        : 7 * 24 * 60 * 60 * 1000;
+                const now = Date.now();
+                const currentEnd = new Date(now).toISOString();
+                const currentStart = new Date(now - windowMs).toISOString();
+                const baselineEnd = currentStart;
+                const baselineStart = new Date(now - 2 * windowMs).toISOString();
+                const fetchWindow = async (startTime, endTime) => {
+                    const [costRes, errorRes, countRes, percentileRes] = await Promise.allSettled([
+                        callApi(apiBase, "/v1/query/aggregate", {}, apiKey, {
+                            method: "POST",
+                            jsonBody: { startTime, endTime, groupBy: "provider", metric: "cost" },
+                        }),
+                        callApi(apiBase, "/v1/query/aggregate", {}, apiKey, {
+                            method: "POST",
+                            jsonBody: { startTime, endTime, groupBy: "provider", metric: "error_rate" },
+                        }),
+                        callApi(apiBase, "/v1/query/aggregate", {}, apiKey, {
+                            method: "POST",
+                            jsonBody: { startTime, endTime, groupBy: "provider", metric: "count" },
+                        }),
+                        callApi(apiBase, "/v1/query/percentiles", {}, apiKey, {
+                            method: "POST",
+                            jsonBody: { startTime, endTime, metric: "latency" },
+                        }),
+                    ]);
+                    const extractJson = (r) => {
+                        if (r.status !== "fulfilled" || r.value.isError)
+                            return null;
+                        try {
+                            return JSON.parse(r.value.content[0]?.text ?? "");
+                        }
+                        catch {
+                            return null;
+                        }
+                    };
+                    const cost = extractJson(costRes);
+                    const errors = extractJson(errorRes);
+                    const counts = extractJson(countRes);
+                    const percentiles = extractJson(percentileRes);
+                    return {
+                        costUsd: cost?.total?.value ?? 0,
+                        errorRate: errors?.total?.value ?? null,
+                        calls: counts?.total?.value ?? 0,
+                        p95Latency: percentiles?.p95 ?? null,
+                        records: percentiles?.total ?? counts?.total?.count ?? 0,
+                    };
+                };
+                const [current, baseline] = await Promise.all([
+                    fetchWindow(currentStart, currentEnd),
+                    fetchWindow(baselineStart, baselineEnd),
+                ]);
+                if (baseline.records < 10) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: JSON.stringify({
+                                    window,
+                                    threshold,
+                                    current,
+                                    baseline,
+                                    anomalies: [],
+                                    warning: `baseline window に records ${baseline.records} 件 (< 10 件)、 anomaly 検出 統計強度 不足`,
+                                }),
+                            },
+                        ],
+                    };
+                }
+                const anomalies = [];
+                const severityFromRatio = (ratio) => {
+                    if (ratio >= multiplier * 2)
+                        return "critical";
+                    if (ratio >= multiplier * 1.3)
+                        return "major";
+                    return "minor";
+                };
+                // 1. cost spike (= current cost > baseline cost × multiplier)
+                if (baseline.costUsd > 0 && current.costUsd > baseline.costUsd * multiplier) {
+                    const ratio = current.costUsd / baseline.costUsd;
+                    anomalies.push({
+                        axis: "cost",
+                        severity: severityFromRatio(ratio),
+                        current: Math.round(current.costUsd * 100) / 100,
+                        baseline: Math.round(baseline.costUsd * 100) / 100,
+                        ratio: Math.round(ratio * 100) / 100,
+                        narrative: `cost が baseline の ${ratio.toFixed(1)}× ($${current.costUsd.toFixed(2)} vs $${baseline.costUsd.toFixed(2)})。 threshold=${threshold} (= ${multiplier}×) を 超過。`,
+                    });
+                }
+                // 2. latency p95 spike
+                if (baseline.p95Latency !== null &&
+                    baseline.p95Latency > 0 &&
+                    current.p95Latency !== null &&
+                    current.p95Latency > baseline.p95Latency * multiplier) {
+                    const ratio = current.p95Latency / baseline.p95Latency;
+                    anomalies.push({
+                        axis: "latency",
+                        severity: severityFromRatio(ratio),
+                        current: Math.round(current.p95Latency),
+                        baseline: Math.round(baseline.p95Latency),
+                        ratio: Math.round(ratio * 100) / 100,
+                        narrative: `p95 latency が baseline の ${ratio.toFixed(1)}× (${Math.round(current.p95Latency)} ms vs ${Math.round(baseline.p95Latency)} ms)。 LLM provider 側 劣化 / 自社 prompt 改変 / network 等 軸。`,
+                    });
+                }
+                // 3. error_rate spike (= current > max(baseline × multiplier, +5pp))
+                if (baseline.errorRate !== null &&
+                    current.errorRate !== null &&
+                    current.errorRate > Math.max(baseline.errorRate * multiplier, baseline.errorRate + 0.05)) {
+                    const ratio = baseline.errorRate > 0 ? current.errorRate / baseline.errorRate : 999;
+                    anomalies.push({
+                        axis: "error_rate",
+                        severity: severityFromRatio(ratio === 999 ? multiplier * 2 : ratio),
+                        current: Math.round(current.errorRate * 10000) / 10000,
+                        baseline: Math.round(baseline.errorRate * 10000) / 10000,
+                        ratio: ratio === 999 ? 999 : Math.round(ratio * 100) / 100,
+                        narrative: `error rate が ${(current.errorRate * 100).toFixed(2)}% (baseline ${(baseline.errorRate * 100).toFixed(2)}%)。 ratio ${ratio === 999 ? "∞" : ratio.toFixed(1)}× で threshold=${threshold} 超過。`,
+                    });
+                }
+                // 4. call volume spike or drop (= current calls > baseline × multiplier OR < baseline / multiplier)
+                if (baseline.calls > 0) {
+                    const ratio = current.calls / baseline.calls;
+                    if (ratio >= multiplier) {
+                        anomalies.push({
+                            axis: "call_volume",
+                            severity: severityFromRatio(ratio),
+                            current: current.calls,
+                            baseline: baseline.calls,
+                            ratio: Math.round(ratio * 100) / 100,
+                            narrative: `call volume が baseline の ${ratio.toFixed(1)}× (${current.calls} vs ${baseline.calls})。 traffic spike / retry storm / new user onboarding 等 軸。`,
+                        });
+                    }
+                    else if (ratio > 0 && 1 / ratio >= multiplier) {
+                        const dropRatio = 1 / ratio;
+                        anomalies.push({
+                            axis: "call_volume",
+                            severity: severityFromRatio(dropRatio),
+                            current: current.calls,
+                            baseline: baseline.calls,
+                            ratio: Math.round(ratio * 100) / 100,
+                            narrative: `call volume が baseline の 1/${dropRatio.toFixed(1)} に 急減 (${current.calls} vs ${baseline.calls})。 SDK side outage / user drop-off / 自社 feature flag 等 軸。`,
+                        });
+                    }
+                }
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                window,
+                                threshold,
+                                multiplier,
+                                current,
+                                baseline,
+                                anomalies,
+                            }),
+                        },
+                    ],
+                };
+            }
+            case "propose_alert_rules": {
+                // 2026-06-05 axis 4 Tier 1 = baseline 統計 + 推奨 alert rule 提案。
+                // propose のみ、 適用は別 step (= create_alert)。 既存 alert と被る
+                // type は skipped 配列に reason 付きで carry (= duplicate 防御)。
+                const lookbackRaw = safeArgs["lookbackDays"];
+                const lookbackDays = typeof lookbackRaw === "number" &&
+                    Number.isFinite(lookbackRaw) &&
+                    lookbackRaw >= 7 &&
+                    lookbackRaw <= 30
+                    ? Math.floor(lookbackRaw)
+                    : 14;
+                const now = Date.now();
+                const windowMs = lookbackDays * 24 * 60 * 60 * 1000;
+                const startTime = new Date(now - windowMs).toISOString();
+                const endTime = new Date(now).toISOString();
+                const dailyCostBody = {
+                    startTime,
+                    endTime,
+                    groupBy: "day",
+                    metric: "cost",
+                };
+                const errorRateBody = {
+                    startTime,
+                    endTime,
+                    groupBy: "provider",
+                    metric: "error_rate",
+                };
+                const dailyCountBody = {
+                    startTime,
+                    endTime,
+                    groupBy: "day",
+                    metric: "count",
+                };
+                const percentileBody = { startTime, endTime, metric: "latency" };
+                const [dailyCostRes, errorRateRes, dailyCountRes, percentileRes, alertsRes] = await Promise.allSettled([
+                    callApi(apiBase, "/v1/query/aggregate", {}, apiKey, {
+                        method: "POST",
+                        jsonBody: dailyCostBody,
+                    }),
+                    callApi(apiBase, "/v1/query/aggregate", {}, apiKey, {
+                        method: "POST",
+                        jsonBody: errorRateBody,
+                    }),
+                    callApi(apiBase, "/v1/query/aggregate", {}, apiKey, {
+                        method: "POST",
+                        jsonBody: dailyCountBody,
+                    }),
+                    callApi(apiBase, "/v1/query/percentiles", {}, apiKey, {
+                        method: "POST",
+                        jsonBody: percentileBody,
+                    }),
+                    callApi(apiBase, "/v1/alerts", {}, apiKey),
+                ]);
+                const extractJson = (r) => {
+                    if (r.status !== "fulfilled" || r.value.isError)
+                        return null;
+                    const txt = r.value.content[0]?.text ?? "";
+                    try {
+                        return JSON.parse(txt);
+                    }
+                    catch {
+                        return null;
+                    }
+                };
+                const dailyCost = extractJson(dailyCostRes);
+                const errorRate = extractJson(errorRateRes);
+                const dailyCount = extractJson(dailyCountRes);
+                const percentiles = extractJson(percentileRes);
+                const alerts = extractJson(alertsRes);
+                const dailyCostValues = (dailyCost?.groups ?? [])
+                    .map((g) => Number(g.value))
+                    .filter((v) => Number.isFinite(v));
+                const meanDailyCost = dailyCostValues.length > 0
+                    ? dailyCostValues.reduce((a, b) => a + b, 0) / dailyCostValues.length
+                    : 0;
+                const maxDailyCost = dailyCostValues.length > 0 ? Math.max(...dailyCostValues) : 0;
+                const dailyCountValues = (dailyCount?.groups ?? [])
+                    .map((g) => Number(g.value))
+                    .filter((v) => Number.isFinite(v));
+                const meanDailyCalls = dailyCountValues.length > 0
+                    ? dailyCountValues.reduce((a, b) => a + b, 0) / dailyCountValues.length
+                    : 0;
+                const p95Latency = percentiles?.p95 ?? null;
+                const totalCalls = dailyCount?.total?.value ?? 0;
+                const observedErrorRate = errorRate?.total?.value !== undefined && errorRate.total.value !== null
+                    ? Number(errorRate.total.value)
+                    : null;
+                const existingTypes = new Set((alerts?.alerts ?? [])
+                    .map((a) => a.alertType)
+                    .filter((t) => typeof t === "string"));
+                const proposals = [];
+                const skipped = [];
+                // 1. cost_daily = 過去 lookback 平均の 2× で trigger (= 異常な 1 日 支出 を 検出)
+                if (existingTypes.has("cost_daily")) {
+                    skipped.push({
+                        alertType: "cost_daily",
+                        reason: "既に同 type の alert が 設定済",
+                    });
+                }
+                else if (meanDailyCost <= 0) {
+                    skipped.push({
+                        alertType: "cost_daily",
+                        reason: `lookback ${lookbackDays} 日の cost data が 不足 (mean=${meanDailyCost})`,
+                    });
+                }
+                else {
+                    const threshold = Math.round(meanDailyCost * 2 * 100) / 100;
+                    proposals.push({
+                        name: `Daily cost > ${threshold} USD (baseline 2×)`,
+                        alertType: "cost_daily",
+                        thresholdValue: threshold,
+                        windowMinutes: 1440,
+                        reasoning: `過去 ${lookbackDays} 日の 平均 daily cost = $${meanDailyCost.toFixed(2)} / 観測 max = $${maxDailyCost.toFixed(2)}。 baseline 2× を 異常閾値 として 提案。`,
+                    });
+                }
+                // 2. latency_p95 = 過去 p95 の 1.5× で trigger
+                if (existingTypes.has("latency_p95")) {
+                    skipped.push({
+                        alertType: "latency_p95",
+                        reason: "既に同 type の alert が 設定済",
+                    });
+                }
+                else if (p95Latency === null || p95Latency <= 0) {
+                    skipped.push({
+                        alertType: "latency_p95",
+                        reason: "lookback 期間に p95 latency data が 不足",
+                    });
+                }
+                else {
+                    const threshold = Math.round(p95Latency * 1.5);
+                    proposals.push({
+                        name: `p95 latency > ${threshold} ms (baseline 1.5×)`,
+                        alertType: "latency_p95",
+                        thresholdValue: threshold,
+                        windowMinutes: 60,
+                        reasoning: `過去 ${lookbackDays} 日の p95 latency = ${Math.round(p95Latency)} ms。 baseline 1.5× を 劣化閾値 として 提案。`,
+                    });
+                }
+                // 3. error_rate = 観測 error_rate の 3× もしくは最低 5% で trigger
+                if (existingTypes.has("error_rate")) {
+                    skipped.push({
+                        alertType: "error_rate",
+                        reason: "既に同 type の alert が 設定済",
+                    });
+                }
+                else if (totalCalls < 100) {
+                    skipped.push({
+                        alertType: "error_rate",
+                        reason: `lookback の total calls = ${totalCalls} で 統計的に baseline 不確定 (要 100+ calls)`,
+                    });
+                }
+                else {
+                    const baseRate = observedErrorRate ?? 0;
+                    const threshold = Math.max(0.05, Math.round(baseRate * 3 * 1000) / 1000);
+                    proposals.push({
+                        name: `Error rate > ${(threshold * 100).toFixed(1)}% (baseline 3× or 5% min)`,
+                        alertType: "error_rate",
+                        thresholdValue: threshold,
+                        windowMinutes: 60,
+                        reasoning: `過去 ${lookbackDays} 日の error rate = ${((baseRate ?? 0) * 100).toFixed(2)}%。 baseline 3× と 最低 5% の 大きい方 を 異常閾値 として 提案。`,
+                    });
+                }
+                // 4. anomaly_cost = 統計的異常検知 (= forecast モデル baseline、 type 別 1 件のみ)
+                if (existingTypes.has("anomaly_cost")) {
+                    skipped.push({
+                        alertType: "anomaly_cost",
+                        reason: "既に同 type の alert が 設定済",
+                    });
+                }
+                else if (meanDailyCalls < 50) {
+                    skipped.push({
+                        alertType: "anomaly_cost",
+                        reason: `1 日平均 calls = ${Math.round(meanDailyCalls)} で anomaly 検知の 統計強度 不足 (要 50+ daily calls)`,
+                    });
+                }
+                else {
+                    proposals.push({
+                        name: `Cost anomaly (statistical z-score > 3σ)`,
+                        alertType: "anomaly_cost",
+                        thresholdValue: 3,
+                        windowMinutes: 60,
+                        reasoning: `過去 ${lookbackDays} 日で 1 日平均 ${Math.round(meanDailyCalls)} calls 観測、 anomaly forecast モデルが 有効。 z-score 3σ 超を 異常 として 提案。`,
+                    });
+                }
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                lookbackDays,
+                                baseline: {
+                                    meanDailyCost: Math.round(meanDailyCost * 100) / 100,
+                                    maxDailyCost: Math.round(maxDailyCost * 100) / 100,
+                                    p95Latency: p95Latency !== null ? Math.round(p95Latency) : null,
+                                    errorRate: observedErrorRate,
+                                    dailyCalls: Math.round(meanDailyCalls),
+                                    totalCalls,
+                                },
+                                proposals,
+                                skipped,
+                            }),
+                        },
+                    ],
+                };
+            }
             case "get_account_health": {
                 // 2026-06-05 axis 4 Tier 1 = 自社 LLM infra 健康状態 サマリ。 既存
                 // 4 endpoint を 並列 fetch + 1 narrative 圧縮。 個別 fail は partial