@prism-llm-labs/mcp-sdk 0.2.0

package/src/prism-mcp.ts

@@ -0,0 +1,352 @@
+/**
+ * PrismMCP — instruments any MCP Server with full observability:
+ *   - tools/call   → wrapToolCall() / patchHandler()
+ *   - resources/read → wrapResourceRead() / patchResourceHandler()
+ *   - prompts/get  → wrapPromptGet() / patchPromptHandler()
+ *   - sampling/createMessage → wrapSamplingHandler()
+ *
+ * Features:
+ *   - Session budget circuit breaker (throws before execution if over budget)
+ *   - Tool loop detection (throws if max_tool_calls_per_session exceeded)
+ *   - Opt-in I/O capture (captureInputs / captureOutputs)
+ *   - Streaming tool latency: correctly measures time-to-stream-end, not first-chunk
+ */
+
+import type { McpPrimitiveType, PrismMcpOptions } from "./types";
+import { McpEventTracker }     from "./tracker";
+import { SessionBudgetChecker } from "./budget";
+import { lookupToolCost }      from "./pricing";
+
+// ── Private helpers ────────────────────────────────────────────────────────────
+
+function orgFromKey(key: string): string {
+  const parts = key.split("_");
+  return parts.length >= 4 ? (parts[2] ?? "") : "";
+}
+
+const DEFAULT_REDACT_KEYS = ["password", "token", "key", "secret", "api_key", "authorization"];
+
+function redactObject(
+  obj: unknown,
+  redactKeys: string[],
+): unknown {
+  if (typeof obj !== "object" || obj === null) return obj;
+  if (Array.isArray(obj)) return obj.map((v) => redactObject(v, redactKeys));
+  const out: Record<string, unknown> = {};
+  for (const [k, v] of Object.entries(obj as Record<string, unknown>)) {
+    out[k] = redactKeys.some((r) => k.toLowerCase().includes(r.toLowerCase()))
+      ? "[REDACTED]"
+      : redactObject(v, redactKeys);
+  }
+  return out;
+}
+
+function truncate(s: string, max: number): string {
+  return s.length <= max ? s : s.slice(0, max) + "…";
+}
+
+function safeJson(val: unknown, redactKeys: string[], maxLen: number): string {
+  try {
+    return truncate(JSON.stringify(redactObject(val, redactKeys)), maxLen);
+  } catch {
+    return "[unserializable]";
+  }
+}
+
+// ── Streaming proxy (Epic 6) ───────────────────────────────────────────────────
+
+function isAsyncIterable(val: unknown): val is AsyncIterable<unknown> {
+  return val != null &&
+    typeof (val as AsyncIterable<unknown>)[Symbol.asyncIterator] === "function";
+}
+
+/**
+ * Wraps an async iterable so that `onEnd` is called with the total elapsed ms
+ * when the stream is fully consumed or throws. All values are forwarded unchanged.
+ */
+async function* proxyAsyncIterable<T>(
+  source: AsyncIterable<T>,
+  start: number,
+  onEnd: (latencyMs: number, threw: boolean) => void,
+): AsyncGenerator<T> {
+  let threw = false;
+  try {
+    for await (const value of source) {
+      yield value;
+    }
+  } catch (err) {
+    threw = true;
+    throw err;
+  } finally {
+    onEnd(Date.now() - start, threw);
+  }
+}
+
+// ── WrapContext — passed to the fn() callback for actual cost self-reporting ──
+
+export class WrapContext {
+  /** @internal - read by _wrap() after fn() completes */
+  _actualCostUsd: number | null = null;
+
+  /**
+   * Override the catalog-estimated tool cost with the real billing figure.
+   * Call this inside your tool handler when you have access to actual cost data
+   * (e.g. from AWS SDK response metadata, a billing header, or a usage API).
+   *
+   * @example
+   * await prismMcp.wrapToolCall("invoke_lambda", async (ctx) => {
+   *   const res = await lambda.invoke({ FunctionName: "fn", Payload: payload });
+   *   const billedMs = res.$metadata.httpHeaders?.["x-amz-billed-duration-ms"] ?? "0";
+   *   ctx.reportActualCost(parseInt(billedMs) * 0.000016667 / 1000);
+   *   return res;
+   * });
+   */
+  reportActualCost(usd: number): void {
+    this._actualCostUsd = usd;
+  }
+}
+
+// ── Main class ────────────────────────────────────────────────────────────────
+
+export class PrismMCP {
+  private readonly tracker:    McpEventTracker;
+  private readonly budget:     SessionBudgetChecker;
+  private readonly redactKeys: string[];
+  private readonly opts: Required<Pick<PrismMcpOptions,
+    "project" | "team" | "environment" | "sessionId" | "serverName" |
+    "captureInputs" | "captureOutputs">> &
+    Pick<PrismMcpOptions, "sessionBudgetUsd" | "maxToolCallsPerSession">;
+
+  constructor(options: PrismMcpOptions = {}) {
+    const key = options.prismKey ?? process.env["PRISM_API_KEY"] ?? "";
+    if (!key) {
+      console.warn("[prism-mcp] PRISM_API_KEY not set — MCP observability disabled.");
+    }
+
+    this.opts = {
+      project:                options.project        ?? process.env["PRISM_PROJECT"]     ?? "",
+      team:                   options.team           ?? process.env["PRISM_TEAM"]        ?? "",
+      environment:            options.environment    ?? process.env["PRISM_ENVIRONMENT"] ?? "production",
+      sessionId:              options.sessionId      ?? crypto.randomUUID(),
+      serverName:             options.serverName     ?? "mcp-server",
+      sessionBudgetUsd:       options.sessionBudgetUsd,
+      maxToolCallsPerSession: options.maxToolCallsPerSession,
+      captureInputs:          options.captureInputs  ?? false,
+      captureOutputs:         options.captureOutputs ?? false,
+    };
+    this.redactKeys = options.redactKeys ?? DEFAULT_REDACT_KEYS;
+    this.tracker = new McpEventTracker(key, this.opts.serverName, options.ingestUrl);
+    this.budget  = new SessionBudgetChecker(orgFromKey(key));
+  }
+
+  // ── Core primitive wrapper ─────────────────────────────────────────────────
+
+  /**
+   * Internal wrapper used by all four MCP primitives.
+   * Handles: budget check, I/O capture, streaming proxy, fire-and-forget telemetry,
+   * and actual cost self-reporting via ctx.reportActualCost().
+   */
+  private async _wrap<T>(
+    primitiveType: McpPrimitiveType,
+    name:          string,
+    fn:            (ctx: WrapContext) => Promise<T>,
+    extra: {
+      llmRequestId?:       string;
+      tags?:               Record<string, string>;
+      downstreamResource?: string;
+      inputs?:             Record<string, unknown>;
+    } = {},
+  ): Promise<T> {
+    // 1. Pre-call budget/loop guard
+    await this.budget.checkOrThrow(
+      this.opts.sessionId,
+      this.opts.sessionBudgetUsd,
+      this.opts.maxToolCallsPerSession,
+    );
+
+    const start    = Date.now();
+    let   status:   "ok" | "error" | "timeout" = "ok";
+    let   errorMsg = "";
+    let   result:  T;
+    const ctx      = new WrapContext();
+
+    // Build tags — I/O capture applied here
+    const eventTags: Record<string, string> = { ...extra.tags };
+    if (this.opts.captureInputs && extra.inputs != null) {
+      eventTags["tool_input"] = safeJson(extra.inputs, this.redactKeys, 1000);
+    }
+
+    // Cost lookup — overridden by ctx.reportActualCost() if called during fn()
+    const estimatedCost = primitiveType === "tool" ? lookupToolCost(name) : 0;
+
+    const fireEvent = (latencyMs: number, finalStatus: "ok" | "error" | "timeout") => {
+      const actualCostUsd = ctx._actualCostUsd;
+      this.tracker.capture({
+        timestamp:            new Date().toISOString().replace("T", " ").slice(0, 23),
+        session_id:           this.opts.sessionId,
+        project_id:           this.opts.project,
+        team_id:              this.opts.team,
+        user_id:              "",
+        environment:          this.opts.environment,
+        tool_name:            name,
+        downstream_resource:  extra.downstreamResource ?? "",
+        execution_latency_ms: latencyMs,
+        tool_cost_usd:        actualCostUsd ?? estimatedCost,
+        cost_status:          actualCostUsd != null ? "actual" : "estimated",
+        status:               finalStatus,
+        error_message:        errorMsg,
+        llm_request_id:       extra.llmRequestId ?? "",
+        primitive_type:       primitiveType,
+        tags:                 eventTags,
+      }).catch(() => {});
+    };
+
+    try {
+      result = await fn(ctx);
+    } catch (err) {
+      status   = "error";
+      errorMsg = err instanceof Error ? err.message : String(err);
+      fireEvent(Date.now() - start, status);
+      throw err;
+    }
+
+    // Capture output if requested (non-streaming path)
+    if (this.opts.captureOutputs && result != null && !isAsyncIterable(result)) {
+      eventTags["tool_output"] = safeJson(result, this.redactKeys, 1000);
+    }
+
+    // Streaming path — defer telemetry until stream is exhausted
+    if (isAsyncIterable(result)) {
+      return proxyAsyncIterable(
+        result as AsyncIterable<unknown>,
+        start,
+        (latencyMs, threw) => {
+          fireEvent(latencyMs, threw ? "error" : "ok");
+        },
+      ) as unknown as T;
+    }
+
+    // Non-streaming path — fire immediately
+    fireEvent(Date.now() - start, status);
+    return result;
+  }
+
+  // ── Public API: tools ──────────────────────────────────────────────────────
+
+  /**
+   * Wrap a tools/call execution with Prism instrumentation.
+   */
+  async wrapToolCall<T>(
+    toolName: string,
+    fn: (ctx: WrapContext) => Promise<T>,
+    extra: {
+      llmRequestId?:       string;
+      tags?:               Record<string, string>;
+      downstreamResource?: string;
+      /** Raw tool arguments — captured if captureInputs: true */
+      inputs?:             Record<string, unknown>;
+    } = {},
+  ): Promise<T> {
+    return this._wrap("tool", toolName, fn, extra);
+  }
+
+  /**
+   * Drop-in patch for MCP SDK's CallToolRequestSchema handler.
+   * Automatically passes req.params.arguments as inputs when captureInputs: true.
+   * ctx is available for reportActualCost() inside the handler.
+   */
+  patchHandler<TReq extends { params: { name: string; arguments?: Record<string, unknown> } }, TRes>(
+    handler: (req: TReq, ctx: WrapContext) => Promise<TRes>,
+  ): (req: TReq) => Promise<TRes> {
+    const self = this;
+    return async function patchedHandler(req: TReq): Promise<TRes> {
+      return self.wrapToolCall(
+        req.params.name,
+        (ctx) => handler(req, ctx),
+        { inputs: req.params.arguments },
+      );
+    };
+  }
+
+  // ── Public API: resources ──────────────────────────────────────────────────
+
+  /**
+   * Wrap a resources/read execution with Prism instrumentation.
+   *
+   * @param resourceUri - The resource URI being read (e.g. "file:///path/to/file")
+   */
+  async wrapResourceRead<T>(
+    resourceUri: string,
+    fn: (ctx: WrapContext) => Promise<T>,
+    extra: {
+      llmRequestId?: string;
+      tags?:         Record<string, string>;
+    } = {},
+  ): Promise<T> {
+    return this._wrap("resource", resourceUri, fn, extra);
+  }
+
+  patchResourceHandler<TReq extends { params: { uri: string } }, TRes>(
+    handler: (req: TReq, ctx: WrapContext) => Promise<TRes>,
+  ): (req: TReq) => Promise<TRes> {
+    const self = this;
+    return async function patchedResourceHandler(req: TReq): Promise<TRes> {
+      return self.wrapResourceRead(req.params.uri, (ctx) => handler(req, ctx));
+    };
+  }
+
+  // ── Public API: prompts ────────────────────────────────────────────────────
+
+  async wrapPromptGet<T>(
+    promptName: string,
+    fn: (ctx: WrapContext) => Promise<T>,
+    extra: {
+      llmRequestId?: string;
+      tags?:         Record<string, string>;
+    } = {},
+  ): Promise<T> {
+    return this._wrap("prompt", promptName, fn, extra);
+  }
+
+  patchPromptHandler<TReq extends { params: { name: string } }, TRes>(
+    handler: (req: TReq, ctx: WrapContext) => Promise<TRes>,
+  ): (req: TReq) => Promise<TRes> {
+    const self = this;
+    return async function patchedPromptHandler(req: TReq): Promise<TRes> {
+      return self.wrapPromptGet(req.params.name, (ctx) => handler(req, ctx));
+    };
+  }
+
+  // ── Public API: sampling ───────────────────────────────────────────────────
+
+  /**
+   * Wrap the MCP client's sampling/createMessage callback so LLM calls
+   * requested by the MCP server appear in the session timeline.
+   *
+   * Usage with @modelcontextprotocol/sdk:
+   *   client.setRequestHandler(
+   *     CreateMessageRequestSchema,
+   *     prismMcp.wrapSamplingHandler(async (req) => {
+   *       const res = await openai.chat.completions.create({ ... });
+   *       return { role: "assistant", content: [{ type: "text", text: res.choices[0].message.content }] };
+   *     })
+   *   );
+   */
+  wrapSamplingHandler<
+    TReq extends { params?: { modelPreferences?: { hints?: Array<{ name?: string }> } } },
+    TRes,
+  >(
+    handler: (req: TReq) => Promise<TRes>,
+  ): (req: TReq) => Promise<TRes> {
+    const self = this;
+    return async function patchedSamplingHandler(req: TReq): Promise<TRes> {
+      // Use model hint as the "tool_name" for display in the session timeline
+      const modelHint =
+        req.params?.modelPreferences?.hints?.[0]?.name ?? "sampling";
+      return self._wrap("sampling", modelHint, (_ctx) => handler(req));
+    };
+  }
+
+  /** The session_id assigned to this instance (useful for logging). */
+  get sessionId(): string { return this.opts.sessionId; }
+}

package/src/session.ts

@@ -0,0 +1,132 @@
+/**
+ * PrismSession — shared session context for multi-server agent runs.
+ *
+ * Creates a single session_id that is automatically threaded through:
+ *   - Multiple PrismMCP server instances (files, database, search, etc.)
+ *   - LLM SDK clients (OpenAI, Anthropic) via toLLMOptions()
+ *
+ * This ensures every LLM call and every tool/resource/prompt call in one
+ * agent run appears under the same session in /dashboard/sessions/[id].
+ *
+ * Usage:
+ *   const session = new PrismSession({
+ *     prismKey: process.env.PRISM_API_KEY,
+ *     project:  "customer-support",
+ *     sessionBudgetUsd: 2.00,   // hard cap for the whole agent run
+ *   });
+ *
+ *   // MCP servers — all share session.sessionId automatically
+ *   const filesMcp  = session.createServer({ serverName: "files" });
+ *   const dbMcp     = session.createServer({ serverName: "database" });
+ *   const searchMcp = session.createServer({ serverName: "search" });
+ *
+ *   // LLM SDK client — same session_id
+ *   import { OpenAI } from "@prism-llm-labs/sdk";
+ *   const openai = new OpenAI(session.toLLMOptions());
+ */
+
+import { PrismMCP }         from "./prism-mcp";
+import type { PrismMcpOptions } from "./types";
+
+export interface PrismSessionOptions {
+  /** Prism API key — or set PRISM_API_KEY env var */
+  prismKey?:               string;
+  /** Project ID for cost attribution */
+  project?:                string;
+  /** Team attribution tag */
+  team?:                   string;
+  /** "production" | "staging" | "development" */
+  environment?:            string;
+  /**
+   * Explicit session ID. Auto-generated UUID if omitted.
+   * Pass an explicit ID when the session ID is determined by an external
+   * orchestrator (e.g. a LangGraph run ID, a task queue job ID).
+   */
+  sessionId?:              string;
+  /** Hard cost cap across ALL servers in this session */
+  sessionBudgetUsd?:       number;
+  /** Hard tool-call cap across ALL servers in this session */
+  maxToolCallsPerSession?: number;
+  /** Opt-in I/O capture for all servers created from this session */
+  captureInputs?:          boolean;
+  captureOutputs?:         boolean;
+  redactKeys?:             string[];
+  /** Override ingest URL (for testing) */
+  ingestUrl?:              string;
+}
+
+/** Options for individual servers within a session */
+export type PerServerOptions = Omit<
+  PrismMcpOptions,
+  "prismKey" | "project" | "team" | "environment" | "sessionId" |
+  "sessionBudgetUsd" | "maxToolCallsPerSession" | "captureInputs" |
+  "captureOutputs" | "redactKeys" | "ingestUrl"
+>;
+
+export class PrismSession {
+  readonly sessionId: string;
+
+  private readonly key:         string;
+  private readonly project:     string;
+  private readonly team:        string;
+  private readonly environment: string;
+  private readonly sharedOpts:  PrismSessionOptions;
+
+  constructor(options: PrismSessionOptions = {}) {
+    this.key         = options.prismKey   ?? process.env["PRISM_API_KEY"]     ?? "";
+    this.project     = options.project    ?? process.env["PRISM_PROJECT"]     ?? "";
+    this.team        = options.team       ?? process.env["PRISM_TEAM"]        ?? "";
+    this.environment = options.environment ?? process.env["PRISM_ENVIRONMENT"] ?? "production";
+    this.sessionId   = options.sessionId  ?? crypto.randomUUID();
+    this.sharedOpts  = options;
+
+    if (!this.key) {
+      console.warn("[prism-mcp] PrismSession: PRISM_API_KEY not set — observability disabled.");
+    }
+  }
+
+  /**
+   * Create a PrismMCP instance bound to this session.
+   * All servers created from the same session share the same session_id.
+   */
+  createServer(perServer: PerServerOptions = {}): PrismMCP {
+    return new PrismMCP({
+      prismKey:               this.key,
+      project:                this.project,
+      team:                   this.team,
+      environment:            this.environment,
+      sessionId:              this.sessionId,
+      sessionBudgetUsd:       this.sharedOpts.sessionBudgetUsd,
+      maxToolCallsPerSession: this.sharedOpts.maxToolCallsPerSession,
+      captureInputs:          this.sharedOpts.captureInputs,
+      captureOutputs:         this.sharedOpts.captureOutputs,
+      redactKeys:             this.sharedOpts.redactKeys,
+      ingestUrl:              this.sharedOpts.ingestUrl,
+      // per-server overrides
+      serverName:             perServer.serverName,
+    });
+  }
+
+  /**
+   * Returns options to pass to the Prism LLM SDK clients (@prism-llm-labs/sdk)
+   * so that LLM completions share this session's session_id.
+   *
+   *   import { OpenAI } from "@prism-llm-labs/sdk";
+   *   const openai = new OpenAI(session.toLLMOptions());
+   */
+  toLLMOptions(): {
+    prismKey:    string;
+    project:     string;
+    team:        string;
+    environment: string;
+    sessionId:   string;
+  } {
+    return {
+      prismKey:    this.key,
+      project:     this.project,
+      team:        this.team,
+      environment: this.environment,
+      sessionId:   this.sessionId,
+    };
+  }
+}

package/src/tracker.ts

@@ -0,0 +1,56 @@
+import type { McpEvent } from "./types";
+
+function defaultIngestUrl(): string {
+  const appUrl = (
+    process.env["PRISM_APP_URL"] ??
+    process.env["NEXT_PUBLIC_APP_URL"] ??
+    "https://useprism.dev"
+  ).replace(/\/$/, "");
+  return `${appUrl}/api/mcp/ingest`;
+}
+
+function orgFromKey(key: string): string {
+  const parts = key.split("_");
+  return parts.length >= 4 ? (parts[2] ?? "") : "";
+}
+
+export class McpEventTracker {
+  private readonly key:        string;
+  private readonly ingestUrl:  string;
+  private readonly serverName: string;
+  private readonly orgId:      string;
+
+  constructor(key: string, serverName: string, ingestUrl?: string) {
+    this.key        = key;
+    this.ingestUrl  = ingestUrl ?? defaultIngestUrl();
+    this.serverName = serverName;
+    this.orgId      = orgFromKey(key);
+  }
+
+  async capture(event: Omit<McpEvent, "event_id" | "org_id" | "mcp_server_name">): Promise<void> {
+    try {
+      const full: McpEvent = {
+        ...event,
+        event_id:        crypto.randomUUID(),
+        org_id:          this.orgId,
+        mcp_server_name: this.serverName,
+      };
+
+      const res = await fetch(this.ingestUrl, {
+        method:  "POST",
+        headers: {
+          Authorization:  `Bearer ${this.key}`,
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({ events: [full] }),
+      });
+
+      if (!res.ok && res.status !== 422) {
+        // Silently ignore — observability must never break the agent
+        console.warn(`[prism-mcp] Ingest returned ${res.status}`);
+      }
+    } catch {
+      // Never propagate
+    }
+  }
+}

package/src/types.ts

@@ -0,0 +1,90 @@
+export type McpPrimitiveType = "tool" | "resource" | "prompt" | "sampling";
+
+export interface McpEvent {
+  event_id:             string;
+  timestamp:            string;
+  session_id:           string;
+  org_id:               string;
+  project_id:           string;
+  team_id:              string;
+  user_id:              string;
+  environment:          string;
+  mcp_server_name:      string;
+  /** tool name, resource URI, prompt name, or model hint for sampling */
+  tool_name:            string;
+  downstream_resource:  string;
+  execution_latency_ms: number;
+  tool_cost_usd:        number;
+  status:               "ok" | "error" | "timeout";
+  error_message:        string;
+  llm_request_id:       string;
+  primitive_type:       McpPrimitiveType;
+  /**
+   * Whether tool_cost_usd is an estimate from the built-in catalog ("estimated")
+   * or a real figure provided by the tool via ctx.reportActualCost() ("actual").
+   */
+  cost_status:          "estimated" | "actual";
+  tags:                 Record<string, string>;
+}
+
+export interface PrismMcpOptions {
+  /** Prism API key — or set PRISM_API_KEY env var */
+  prismKey?:      string;
+  /** Project ID for cost attribution */
+  project?:       string;
+  /** Team attribution tag */
+  team?:          string;
+  /** "production" | "staging" | "development" */
+  environment?:   string;
+  /** Explicit session ID. Auto-generated UUID if omitted. */
+  sessionId?:     string;
+  /** MCP server name shown in the dashboard */
+  serverName?:    string;
+  /** Override ingest URL (for testing) */
+  ingestUrl?:     string;
+  /**
+   * Session budget in USD. Tool/resource/prompt calls are blocked when the
+   * combined session cost exceeds this value.
+   */
+  sessionBudgetUsd?: number;
+  /**
+   * Maximum MCP primitive calls per session. Blocks further calls when exceeded.
+   * Loop detection guard — default unlimited.
+   */
+  maxToolCallsPerSession?: number;
+  /**
+   * Log call arguments into tags['tool_input'] (truncated to 1000 chars).
+   * Opt-in only — disabled by default for privacy.
+   */
+  captureInputs?: boolean;
+  /**
+   * Log call results into tags['tool_output'] (truncated to 1000 chars).
+   * Opt-in only — disabled by default for privacy.
+   */
+  captureOutputs?: boolean;
+  /**
+   * Keys to redact from captured inputs/outputs.
+   * Default: ['password', 'token', 'key', 'secret', 'api_key', 'authorization']
+   */
+  redactKeys?: string[];
+}
+
+export class PrismSessionBudgetExceededError extends Error {
+  constructor(sessionId: string, budgetUsd: number) {
+    super(
+      `[prism-mcp] Session budget of $${budgetUsd} exceeded for session ${sessionId}. ` +
+      `Tool call blocked to prevent runaway agent costs.`,
+    );
+    this.name = "PrismSessionBudgetExceededError";
+  }
+}
+
+export class PrismToolCallLimitError extends Error {
+  constructor(sessionId: string, limit: number) {
+    super(
+      `[prism-mcp] Tool call limit of ${limit} reached for session ${sessionId}. ` +
+      `Possible agent loop detected — tool call blocked.`,
+    );
+    this.name = "PrismToolCallLimitError";
+  }
+}

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target":          "ES2020",
+    "module":          "ESNext",
+    "moduleResolution": "bundler",
+    "lib":             ["ES2020"],
+    "strict":          true,
+    "declaration":     true,
+    "outDir":          "./dist",
+    "rootDir":         "./src",
+    "skipLibCheck":    true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/tsup.config.ts

@@ -0,0 +1,9 @@
+import { defineConfig } from "tsup";
+
+export default defineConfig({
+  entry:     ["src/index.ts"],
+  format:    ["cjs", "esm"],
+  dts:       true,
+  clean:     true,
+  sourcemap: true,
+});