agentcert 0.1.0

package/dist/local-server.js

@@ -0,0 +1,491 @@
+import { createServer } from "node:http";
+import { readFile, stat } from "node:fs/promises";
+import { extname, join, relative, resolve, sep } from "node:path";
+import { pathToFileURL } from "node:url";
+import { reviewedFailureDataset, summarizeCorpus, } from "./corpus.js";
+import { openCorpusStore } from "./corpus-store.js";
+import { applyFailureReviews, appendFailureReview, createFailureReview, findFailurePattern, parseFailureReviewStatus, parseFailureType, parseReviewConfidence, readFailureReviews, } from "./failure-review.js";
+import { buildMonitorSnapshot } from "./monitor.js";
+export async function serveAgentCertMonitor(options) {
+    const staticRoot = resolve(options.staticDir);
+    const artifactRoot = resolve(options.artifactRoot);
+    const server = createServer(async (request, response) => {
+        try {
+            await handleRequest(request, response, options, staticRoot, artifactRoot);
+        }
+        catch (error) {
+            sendJson(response, 500, { error: error instanceof Error ? error.message : String(error) });
+        }
+    });
+    await new Promise((resolveListen) => server.listen(options.port, options.host, resolveListen));
+    const address = `http://${options.host}:${options.port}`;
+    process.stdout.write(`AgentCert Monitor server listening at ${address}\n`);
+    process.stdout.write(`Serving dashboard from ${staticRoot}\n`);
+    process.stdout.write(`Serving artifacts from ${artifactRoot}\n`);
+}
+async function handleRequest(request, response, options, staticRoot, artifactRoot) {
+    if (!request.url) {
+        sendJson(response, 400, { error: "Missing URL." });
+        return;
+    }
+    const url = new URL(request.url, `http://${request.headers.host ?? `${options.host}:${options.port}`}`);
+    if (url.pathname === "/api/health") {
+        await withStore(options.store, async (store) => {
+            sendJson(response, 200, {
+                ok: true,
+                subject: options.subject,
+                store: { kind: store.kind, description: store.description },
+                artifactRoot,
+            });
+        });
+        return;
+    }
+    if (url.pathname === "/api/monitor") {
+        await withStore(options.store, async (store) => {
+            const records = applyFailureReviews(await store.readAll(), await readFailureReviews(options.reviewsPath));
+            sendJson(response, 200, buildMonitorSnapshot(records, { subject: options.subject, detailUrl: options.detailUrl }));
+        });
+        return;
+    }
+    if (url.pathname === "/api/runs") {
+        await withStore(options.store, async (store) => {
+            const records = applyFailureReviews(await store.readAll(), await readFailureReviews(options.reviewsPath));
+            sendJson(response, 200, { runs: records.sort((left, right) => right.timestamp.localeCompare(left.timestamp)) });
+        });
+        return;
+    }
+    if (url.pathname === "/api/corpus/metrics") {
+        await withStore(options.store, async (store) => {
+            const records = applyFailureReviews(await store.readAll(), await readFailureReviews(options.reviewsPath));
+            sendJson(response, 200, summarizeCorpus(records).taxonomy);
+        });
+        return;
+    }
+    if (url.pathname === "/api/corpus/reviewed-dataset") {
+        await withStore(options.store, async (store) => {
+            const records = applyFailureReviews(await store.readAll(), await readFailureReviews(options.reviewsPath));
+            const rows = reviewedFailureDataset(records);
+            response.writeHead(200, {
+                "content-type": "application/x-ndjson; charset=utf-8",
+                "cache-control": "no-cache",
+                "content-disposition": 'attachment; filename="agentcert-reviewed-failure-dataset.jsonl"',
+            });
+            const payload = rows.map((row) => JSON.stringify(row)).join("\n");
+            response.end(`${payload}${payload.length > 0 ? "\n" : ""}`);
+        });
+        return;
+    }
+    const reviewRoute = matchRunReviewRoute(url.pathname);
+    if (reviewRoute && request.method === "POST") {
+        await handleFailureReviewPost(request, response, options, artifactRoot, reviewRoute.runId);
+        return;
+    }
+    if (url.pathname.startsWith("/api/runs/") && request.method !== "POST") {
+        const runId = decodeURIComponent(url.pathname.slice("/api/runs/".length));
+        await withStore(options.store, async (store) => {
+            const records = applyFailureReviews(await store.readAll(), await readFailureReviews(options.reviewsPath));
+            const record = records.find((item) => item.id === runId || item.runId === runId);
+            if (!record) {
+                sendJson(response, 404, { error: `Run ${runId} was not found.` });
+                return;
+            }
+            sendJson(response, 200, await buildRunDetail(record, artifactRoot));
+        });
+        return;
+    }
+    if (url.pathname === "/api/artifacts") {
+        await serveArtifact(response, artifactRoot, url.searchParams.get("path"));
+        return;
+    }
+    await serveStatic(response, staticRoot, url.pathname);
+}
+async function handleFailureReviewPost(request, response, options, artifactRoot, runId) {
+    const reviewsPath = options.reviewsPath;
+    if (!reviewsPath) {
+        sendJson(response, 400, { error: "This server was not configured with a failure review ledger path." });
+        return;
+    }
+    const body = await readJsonBody(request);
+    const patternKey = stringField(body, "patternKey");
+    const type = parseFailureType(stringField(body, "type"));
+    const reviewer = stringField(body, "reviewer") ?? "local-reviewer";
+    const note = stringField(body, "note");
+    const explicitStatus = stringField(body, "status");
+    const confidence = parseReviewConfidence(numberField(body, "confidence"));
+    const evidenceContext = reviewEvidenceContextField(body);
+    const taxonomyRationale = reviewTaxonomyRationaleField(body);
+    if (!patternKey) {
+        sendJson(response, 400, { error: "Missing patternKey." });
+        return;
+    }
+    await withStore(options.store, async (store) => {
+        const records = await store.readAll();
+        const record = records.find((item) => item.id === runId || item.runId === runId);
+        if (!record) {
+            sendJson(response, 404, { error: `Run ${runId} was not found.` });
+            return;
+        }
+        const target = {
+            patternKey,
+            recordId: record.id,
+            runId: record.runId,
+            product: record.product,
+            scenarioName: record.scenarioName,
+            faultName: record.faultName,
+        };
+        const matched = findFailurePattern(records, target);
+        if (!matched) {
+            sendJson(response, 404, { error: `Failure pattern ${patternKey} was not found on run ${runId}.` });
+            return;
+        }
+        const suggestedType = matched.pattern.suggestedType ?? matched.pattern.type;
+        const review = createFailureReview({
+            target,
+            type,
+            status: parseFailureReviewStatus(explicitStatus, type, suggestedType),
+            suggestedType,
+            reviewer,
+            note,
+            confidence,
+            evidenceContext,
+            taxonomyRationale,
+        });
+        await appendFailureReview(reviewsPath, review);
+        const updated = applyFailureReviews(records, await readFailureReviews(reviewsPath));
+        await store.append(updated, { replace: true });
+        const updatedRecord = updated.find((item) => item.id === record.id) ?? record;
+        sendJson(response, 200, await buildRunDetail(updatedRecord, artifactRoot));
+    });
+}
+export async function buildRunDetail(record, artifactRoot) {
+    const root = resolve(artifactRoot);
+    const tracePath = normalizeArtifactPath(record.artifacts.trace);
+    const resultPath = normalizeArtifactPath(record.artifacts.result);
+    const trace = tracePath ? await readJsonIfExists(join(root, tracePath)) : undefined;
+    const result = await readTripwireResult(root, resultPath);
+    const tripwireRun = result?.runs?.find((run) => run.runId === record.runId);
+    const assertions = tripwireRun?.assertions ?? assertionsFromFailurePatterns(record.failurePatterns);
+    const artifacts = await collectArtifacts(record, root, trace);
+    return {
+        record,
+        failurePatterns: record.failurePatterns,
+        assertions,
+        timeline: buildTimeline(record, assertions, trace),
+        artifacts,
+        traceSummary: traceSummary(trace),
+        finalUrl: tripwireRun?.finalUrl ?? stringMetadata(record.metadata, "finalUrl"),
+        diagnostics: stringArray(tripwireRun?.diagnostics ?? record.metadata?.diagnostics),
+        warnings: stringArray(tripwireRun?.warnings ?? record.metadata?.warnings ?? trace?.warnings),
+    };
+}
+function buildTimeline(record, assertions, trace) {
+    const failedAssertions = assertions.filter((assertion) => assertion.pass === false);
+    const timeline = failedAssertions.map((assertion) => ({
+        kind: "failure",
+        title: "Assertion failure",
+        timestamp: record.timestamp,
+        message: `${assertion.message}${assertion.observed === undefined ? "" : ` Observed: ${stringifyShort(assertion.observed)}`}`,
+    }));
+    const steps = trace?.steps ?? [];
+    const firstChangedStep = firstDivergenceStep(steps);
+    if (firstChangedStep) {
+        timeline.push({
+            kind: "page-state",
+            title: "First observed page divergence",
+            timestamp: firstChangedStep.timestamp,
+            stepIndex: firstChangedStep.stepIndex,
+            message: firstChangedStep.visibleTextSample ?? "The page state changed before the task reached the expected outcome.",
+            artifactPath: firstChangedStep.screenshotPath,
+        });
+    }
+    for (const event of steps.flatMap((step) => (step.agentEvents ?? []).map((agentEvent) => ({
+        ...agentEvent,
+        stepIndex: step.stepIndex,
+    })))) {
+        timeline.push({
+            kind: "agent-action",
+            title: `Agent ${event.type ?? "event"}`,
+            timestamp: event.timestamp,
+            stepIndex: event.stepIndex,
+            message: [event.target, event.note].filter(Boolean).join(" - "),
+        });
+    }
+    for (const [index, item] of [...(trace?.networkErrors ?? []), ...steps.flatMap((step) => step.networkErrors ?? [])].entries()) {
+        timeline.push({ kind: "network", title: "Network error", message: stringifyShort(item), stepIndex: index + 1 });
+    }
+    for (const [index, item] of [...(trace?.consoleErrors ?? []), ...steps.flatMap((step) => step.consoleErrors ?? [])].entries()) {
+        timeline.push({ kind: "console", title: "Console error", message: stringifyShort(item), stepIndex: index + 1 });
+    }
+    return timeline.sort((left, right) => (left.timestamp ?? "").localeCompare(right.timestamp ?? ""));
+}
+async function collectArtifacts(record, root, trace) {
+    const artifactPaths = new Map();
+    const tracePath = normalizeArtifactPath(record.artifacts.trace);
+    const resultPath = normalizeArtifactPath(record.artifacts.result);
+    const artifactDir = normalizeArtifactPath(record.artifacts.artifactDir);
+    if (tracePath)
+        artifactPaths.set(tracePath, "trace");
+    if (resultPath)
+        artifactPaths.set(resultPath, "json");
+    if (artifactDir)
+        artifactPaths.set(join(artifactDir, "agent-events.jsonl"), "events");
+    for (const step of trace?.steps ?? []) {
+        if (step.screenshotPath && tracePath)
+            artifactPaths.set(join(dirnameLike(tracePath), step.screenshotPath), "screenshot");
+        if (step.domSnapshotPath && tracePath)
+            artifactPaths.set(join(dirnameLike(tracePath), step.domSnapshotPath), "dom");
+    }
+    const artifacts = [];
+    for (const [path, kind] of artifactPaths) {
+        const normalized = normalizeArtifactPath(path);
+        if (!normalized)
+            continue;
+        const fullPath = resolveInside(root, normalized);
+        if (!fullPath)
+            continue;
+        const fileStat = await stat(fullPath).catch(() => undefined);
+        if (!fileStat?.isFile())
+            continue;
+        artifacts.push({
+            label: normalized.split(/[\\/]/).slice(-2).join("/"),
+            kind,
+            path: normalized,
+            url: `/api/artifacts?path=${encodeURIComponent(normalized)}`,
+            sizeBytes: fileStat.size,
+        });
+    }
+    return artifacts.sort((left, right) => artifactKindRank(left.kind) - artifactKindRank(right.kind) || left.path.localeCompare(right.path));
+}
+async function serveArtifact(response, artifactRoot, path) {
+    if (!path) {
+        sendJson(response, 400, { error: "Missing artifact path." });
+        return;
+    }
+    const normalized = normalizeArtifactPath(path);
+    const fullPath = normalized ? resolveInside(artifactRoot, normalized) : undefined;
+    if (!fullPath) {
+        sendJson(response, 403, { error: "Artifact path is outside the artifact root." });
+        return;
+    }
+    try {
+        const file = await readFile(fullPath);
+        response.writeHead(200, {
+            "content-type": mimeType(fullPath),
+            "cache-control": "no-cache",
+        });
+        response.end(file);
+    }
+    catch {
+        sendJson(response, 404, { error: "Artifact was not found." });
+    }
+}
+async function serveStatic(response, staticRoot, pathname) {
+    const requested = pathname === "/" ? "index.html" : pathname.replace(/^\/+/, "");
+    const fullPath = resolveInside(staticRoot, requested);
+    if (!fullPath) {
+        sendJson(response, 403, { error: "Static path is outside the dashboard root." });
+        return;
+    }
+    try {
+        const fileStat = await stat(fullPath);
+        if (fileStat.isDirectory()) {
+            await sendFile(response, join(fullPath, "index.html"));
+            return;
+        }
+        await sendFile(response, fullPath);
+    }
+    catch {
+        await sendFile(response, join(staticRoot, "index.html"));
+    }
+}
+async function sendFile(response, path) {
+    const file = await readFile(path);
+    response.writeHead(200, { "content-type": mimeType(path), "cache-control": "no-cache" });
+    response.end(file);
+}
+async function withStore(options, callback) {
+    const store = await openCorpusStore(options);
+    try {
+        return await callback(store);
+    }
+    finally {
+        await store.close();
+    }
+}
+async function readTripwireResult(root, resultPath) {
+    const candidates = [resultPath, "tripwire-result.json"].filter(Boolean);
+    for (const candidate of candidates) {
+        const normalized = normalizeArtifactPath(candidate);
+        const fullPath = normalized ? resolveInside(root, normalized) : undefined;
+        const result = fullPath ? await readJsonIfExists(fullPath) : undefined;
+        if (result)
+            return result;
+    }
+    return undefined;
+}
+async function readJsonIfExists(path) {
+    try {
+        return JSON.parse(await readFile(path, "utf8"));
+    }
+    catch {
+        return undefined;
+    }
+}
+function assertionsFromFailurePatterns(patterns) {
+    return patterns.map((pattern) => ({ type: pattern.key, pass: false, message: pattern.message }));
+}
+function traceSummary(trace) {
+    const steps = trace?.steps ?? [];
+    if (steps.length === 0)
+        return undefined;
+    return {
+        stepCount: steps.length,
+        firstStepText: steps[0]?.visibleTextSample,
+        lastStepText: steps[steps.length - 1]?.visibleTextSample,
+        firstDivergenceStep: firstDivergenceStep(steps)?.stepIndex,
+    };
+}
+function firstDivergenceStep(steps) {
+    const firstHash = steps[0]?.visibleTextSample;
+    return steps.find((step) => step.visibleTextSample && step.visibleTextSample !== firstHash);
+}
+function normalizeArtifactPath(input) {
+    if (!input)
+        return undefined;
+    const normalized = input.replace(/\\/g, "/");
+    if (normalized.includes(".."))
+        return undefined;
+    if (normalized.startsWith("packages/tripwire-ci/.tripwire/public-demo/")) {
+        return normalized.slice("packages/tripwire-ci/.tripwire/public-demo/".length);
+    }
+    return normalized.replace(/^\/+/, "");
+}
+function resolveInside(root, path) {
+    const fullPath = resolve(root, path);
+    const rel = relative(root, fullPath);
+    if (rel.startsWith("..") || rel === ".." || rel.split(sep).includes("..")) {
+        return undefined;
+    }
+    return fullPath;
+}
+function dirnameLike(path) {
+    const parts = path.split(/[\\/]/);
+    parts.pop();
+    return parts.join("/");
+}
+function artifactKindRank(kind) {
+    return ["screenshot", "dom", "trace", "json", "events", "report", "other"].indexOf(kind);
+}
+function sendJson(response, status, data) {
+    response.writeHead(status, { "content-type": "application/json; charset=utf-8", "cache-control": "no-cache" });
+    response.end(`${JSON.stringify(data, null, 2)}\n`);
+}
+async function readJsonBody(request) {
+    const chunks = [];
+    let totalBytes = 0;
+    for await (const chunk of request) {
+        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        totalBytes += buffer.length;
+        if (totalBytes > 64 * 1024) {
+            throw new Error("Request body is too large.");
+        }
+        chunks.push(buffer);
+    }
+    if (chunks.length === 0)
+        return {};
+    const raw = Buffer.concat(chunks).toString("utf8");
+    return JSON.parse(raw);
+}
+function stringField(input, key) {
+    const value = input[key];
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function numberField(input, key) {
+    const value = input[key];
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function recordField(input, key) {
+    const value = input[key];
+    return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function stringArrayField(input, key) {
+    const value = input[key];
+    return Array.isArray(value) ? value.filter((item) => typeof item === "string" && item.length > 0) : [];
+}
+function reviewEvidenceContextField(input) {
+    const nested = recordField(input, "evidenceContext");
+    const firstDivergenceSnippet = stringField(nested, "firstDivergenceSnippet") ?? stringField(input, "firstDivergenceSnippet");
+    const screenshotPath = stringField(nested, "screenshotPath") ?? stringField(input, "screenshotPath");
+    const screenshotUrl = stringField(nested, "screenshotUrl") ?? stringField(input, "screenshotUrl");
+    const tracePath = stringField(nested, "tracePath") ?? stringField(input, "tracePath");
+    const stepIndex = numberField(nested, "stepIndex") ?? numberField(input, "stepIndex");
+    if (!firstDivergenceSnippet && !screenshotPath && !screenshotUrl && !tracePath && stepIndex === undefined) {
+        return undefined;
+    }
+    return {
+        firstDivergenceSnippet,
+        screenshotPath,
+        screenshotUrl,
+        tracePath,
+        stepIndex,
+    };
+}
+function reviewTaxonomyRationaleField(input) {
+    const nested = recordField(input, "taxonomyRationale");
+    const primaryReason = stringField(nested, "primaryReason") ?? stringField(input, "why");
+    if (!primaryReason) {
+        return undefined;
+    }
+    const supportingSignals = stringArrayField(nested, "supportingSignals");
+    const contradictingSignals = stringArrayField(nested, "contradictingSignals");
+    return {
+        primaryReason,
+        supportingSignals: supportingSignals.length > 0 ? supportingSignals : undefined,
+        contradictingSignals: contradictingSignals.length > 0 ? contradictingSignals : undefined,
+        classifierLimitation: stringField(nested, "classifierLimitation"),
+    };
+}
+function matchRunReviewRoute(pathname) {
+    const suffix = "/failure-reviews";
+    if (!pathname.startsWith("/api/runs/") || !pathname.endsWith(suffix)) {
+        return undefined;
+    }
+    const encoded = pathname.slice("/api/runs/".length, -suffix.length);
+    return { runId: decodeURIComponent(encoded) };
+}
+function stringMetadata(metadata, key) {
+    const value = metadata?.[key];
+    return typeof value === "string" ? value : undefined;
+}
+function stringArray(input) {
+    return Array.isArray(input) ? input.filter((item) => typeof item === "string") : [];
+}
+function stringifyShort(input) {
+    const value = typeof input === "string" ? input : JSON.stringify(input);
+    return value.length > 500 ? `${value.slice(0, 500)}...` : value;
+}
+function mimeType(path) {
+    switch (extname(path).toLowerCase()) {
+        case ".css":
+            return "text/css; charset=utf-8";
+        case ".html":
+            return "text/html; charset=utf-8";
+        case ".js":
+            return "text/javascript; charset=utf-8";
+        case ".json":
+            return "application/json; charset=utf-8";
+        case ".jsonl":
+            return "application/x-ndjson; charset=utf-8";
+        case ".png":
+            return "image/png";
+        case ".svg":
+            return "image/svg+xml";
+        case ".txt":
+            return "text/plain; charset=utf-8";
+        default:
+            return "application/octet-stream";
+    }
+}
+export function dashboardFileUrl(staticDir) {
+    return pathToFileURL(resolve(staticDir, "index.html")).toString();
+}

package/dist/monitor.js

@@ -0,0 +1,100 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import { summarizeCorpus } from "./corpus.js";
+export function buildMonitorSnapshot(records, options) {
+    const summary = summarizeCorpus(records);
+    return {
+        schemaVersion: "1",
+        kind: "agentcert.monitor_snapshot",
+        generatedAt: new Date().toISOString(),
+        subject: options.subject,
+        summary,
+        filters: buildFilters(records),
+        lifecycle: [
+            lifecycleGate(records, {
+                id: "mcpbench",
+                name: "MCPBench",
+                phase: "Before release",
+                description: "MCP servers, exposed tools, policy behavior, and runtime traces.",
+            }),
+            lifecycleGate(records, {
+                id: "tripwire-ci",
+                name: "Tripwire CI",
+                phase: "Before release",
+                description: "Browser and computer-use agents under adversarial UI and network faults.",
+            }),
+            lifecycleGate(records, {
+                id: "onegent-runtime",
+                name: "Onegent Runtime",
+                phase: "After release",
+                description: "High-risk live actions requiring approval, verification, and audit.",
+            }),
+        ],
+        recentRuns: [...records]
+            .sort((left, right) => right.timestamp.localeCompare(left.timestamp))
+            .slice(0, 50)
+            .map((record) => ({
+            id: record.id,
+            product: record.product,
+            phase: record.phase,
+            subject: record.subject,
+            agentName: record.agentName,
+            agentVersion: record.agentVersion,
+            scenarioName: record.scenarioName,
+            faultName: record.faultName,
+            failureTypes: [...new Set(record.failurePatterns.map((pattern) => pattern.type))],
+            passed: record.passed,
+            score: record.score,
+            timestamp: record.timestamp,
+            durationMs: record.durationMs,
+            evidenceCount: record.evidenceCount,
+            primaryFailure: record.failurePatterns[0]?.message,
+            failurePatterns: record.failurePatterns,
+            taxonomyReviewStatus: taxonomyReviewStatus(record.failurePatterns),
+            reviewedFailureCount: record.failurePatterns.filter((pattern) => pattern.reviewStatus === "confirmed" || pattern.reviewStatus === "corrected").length,
+            unreviewedFailureCount: record.failurePatterns.filter((pattern) => (pattern.reviewStatus ?? "unreviewed") === "unreviewed").length,
+            artifacts: record.artifacts,
+        })),
+        failurePatterns: summary.topFailurePatterns,
+        links: {
+            detailUrl: options.detailUrl,
+        },
+    };
+}
+function buildFilters(records) {
+    return {
+        agents: unique(records.map((record) => record.agentName)),
+        faults: unique(records.map((record) => record.faultName).filter((value) => Boolean(value))),
+        versions: unique(records.map((record) => record.agentVersion)),
+        failureTypes: unique(records.flatMap((record) => record.failurePatterns.map((pattern) => pattern.type))),
+        products: unique(records.map((record) => record.product)),
+        reviewStatuses: unique(records.map((record) => taxonomyReviewStatus(record.failurePatterns))),
+    };
+}
+function taxonomyReviewStatus(patterns) {
+    if (patterns.length === 0)
+        return "none";
+    return patterns.every((pattern) => pattern.reviewStatus === "confirmed" || pattern.reviewStatus === "corrected") ? "reviewed" : "needs_review";
+}
+function unique(values) {
+    return [...new Set(values)].sort((left, right) => left.localeCompare(right));
+}
+export async function writeMonitorSnapshot(path, snapshot) {
+    const outPath = resolve(path);
+    await mkdir(dirname(outPath), { recursive: true });
+    await writeFile(outPath, `${JSON.stringify(snapshot, null, 2)}\n`);
+}
+function lifecycleGate(records, gate) {
+    const gateRecords = records.filter((record) => record.product === gate.id);
+    const passedCount = gateRecords.filter((record) => record.passed).length;
+    const failedCount = gateRecords.length - passedCount;
+    const passRate = gateRecords.length === 0 ? 0 : passedCount / gateRecords.length;
+    return {
+        ...gate,
+        recordCount: gateRecords.length,
+        passedCount,
+        failedCount,
+        passRate,
+        status: gateRecords.length === 0 ? "waiting" : passRate >= 0.8 ? "passing" : "failing",
+    };
+}