@usefarol/sdk 0.1.0

package/README.md

@@ -0,0 +1,173 @@
+# farol-sdk
+
+**AI agent observability for Node.js** — wrap your agent entrypoints with a single `trace()` helper to send runs, token usage, cost, and spans to [Farol](https://usefarol.dev).
+
+## Install
+
+```bash
+npm install farol-sdk
+```
+
+Requires **Node.js 18+** (global `fetch`).
+
+## API key
+
+Create or copy your API key from the Farol app: **[usefarol.dev](https://usefarol.dev)** → sign in → dashboard / [usefarol.dev/app](https://usefarol.dev/app).
+
+## Quick start — Anthropic
+
+```typescript
+import Anthropic from "@anthropic-ai/sdk";
+import { trace } from "farol-sdk";
+
+const client = new Anthropic();
+
+const myAgent = trace(
+  async (run, task: string) => {
+    run.topic = task;
+
+    const span = run.startSpan("llm_call", { type: "llm" });
+    try {
+      const response = await client.messages.create({
+        model: "claude-haiku-4-5",
+        max_tokens: 1024,
+        messages: [{ role: "user", content: task }],
+      });
+      span.inputTokens = response.usage.input_tokens;
+      span.outputTokens = response.usage.output_tokens;
+      run.inputTokens += response.usage.input_tokens;
+      run.outputTokens += response.usage.output_tokens;
+      span.end();
+      return response.content[0].type === "text"
+        ? response.content[0].text
+        : "";
+    } catch (e) {
+      span.end(e instanceof Error ? e : new Error(String(e)));
+      throw e;
+    }
+  },
+  {
+    agentName: "my-agent",
+    farolKey: process.env.FAROL_KEY!,
+    model: "claude-haiku-4-5",
+  },
+);
+
+await myAgent("Summarize this week’s metrics.");
+```
+
+## Quick start — OpenAI
+
+```typescript
+import OpenAI from "openai";
+import { trace } from "farol-sdk";
+
+const openai = new OpenAI();
+
+const myAgent = trace(
+  async (run, userMessage: string) => {
+    run.topic = userMessage;
+
+    const span = run.startSpan("chat", { type: "llm" });
+    try {
+      const response = await openai.chat.completions.create({
+        model: "gpt-4o-mini",
+        messages: [{ role: "user", content: userMessage }],
+      });
+      const usage = response.usage;
+      if (usage) {
+        span.inputTokens = usage.prompt_tokens;
+        span.outputTokens = usage.completion_tokens;
+        run.inputTokens += usage.prompt_tokens;
+        run.outputTokens += usage.completion_tokens;
+      }
+      span.end();
+      return response.choices[0]?.message.content ?? "";
+    } catch (e) {
+      span.end(e instanceof Error ? e : new Error(String(e)));
+      throw e;
+    }
+  },
+  {
+    agentName: "support-bot",
+    farolKey: process.env.FAROL_KEY!,
+    model: "gpt-4o-mini",
+  },
+);
+
+await myAgent("Hello!");
+```
+
+## Span tracking (`startSpan` / `end`)
+
+Use `run.startSpan(name, { type, metadata })` for tools, retrieval, or extra LLM steps. Call `span.end()` when the step finishes, or `span.end(error)` on failure. Unclosed spans are auto-ended when the run completes.
+
+```typescript
+import { trace } from "farol-sdk";
+
+const pipeline = trace(
+  async (run, query: string) => {
+    run.topic = query;
+
+    const search = run.startSpan("web_search", {
+      type: "tool",
+      metadata: { engine: "internal" },
+    });
+    const results = await fakeSearch(query);
+    search.end();
+
+    const llm = run.startSpan("answer", { type: "llm" });
+    try {
+      const answer = await fakeLlm(query, results);
+      llm.inputTokens = 100;
+      llm.outputTokens = 50;
+      run.inputTokens += 100;
+      run.outputTokens += 50;
+      llm.end();
+      return answer;
+    } catch (e) {
+      llm.end(e instanceof Error ? e : new Error(String(e)));
+      throw e;
+    }
+  },
+  { agentName: "research-agent", farolKey: process.env.FAROL_KEY! },
+);
+
+async function fakeSearch(q: string) {
+  return [`result for ${q}`];
+}
+async function fakeLlm(_q: string, _ctx: string[]) {
+  return "done";
+}
+
+await pipeline("What is Farol?");
+```
+
+### Optional: capture prompt/response text
+
+Set `captureIo: true` in `trace` options to include `span.input` / `span.output` in the payload (only when you assign them). **Do not enable for sensitive data** without reviewing compliance needs.
+
+## Options
+
+| Option | Description |
+|--------|-------------|
+| `agentName` | Display name in the Farol dashboard |
+| `farolKey` | API key (`frl_…`) |
+| `farolEndpoint` | Override ingest URL (default: hosted Farol ingest) |
+| `model` | Model label on the run |
+| `costPer1kInputTokens` / `costPer1kOutputTokens` | USD per 1k tokens for cost estimates |
+| `captureIo` | When `true`, include span `input`/`output` if set |
+
+## Build (from source)
+
+```bash
+cd farol-sdk-js
+npm install
+npm run build
+```
+
+Outputs `dist/index.js`, `dist/index.mjs`, and `dist/index.d.ts`.
+
+## License
+
+MIT

package/dist/index.d.mts

@@ -0,0 +1,53 @@
+interface TraceOptions {
+    agentName: string;
+    farolKey: string;
+    farolEndpoint?: string;
+    model?: string;
+    costPer1kInputTokens?: number;
+    costPer1kOutputTokens?: number;
+    captureIo?: boolean;
+}
+interface SpanOptions {
+    type?: "tool" | "llm";
+    metadata?: Record<string, unknown>;
+}
+declare class Span {
+    name: string;
+    type: string;
+    metadata: Record<string, unknown>;
+    inputTokens: number;
+    outputTokens: number;
+    costUsd: number;
+    input?: string;
+    output?: string;
+    error?: string;
+    startedAt: string;
+    endedAt?: string;
+    durationMs?: number;
+    private _startTime;
+    constructor(name: string, options?: SpanOptions);
+    end(error?: Error): void;
+    toDict(captureIo: boolean): Record<string, unknown>;
+}
+declare class Run {
+    id: string;
+    agent: string;
+    model: string;
+    topic?: string;
+    status: string;
+    steps: unknown[];
+    spans: Span[];
+    inputTokens: number;
+    outputTokens: number;
+    costUsd: number;
+    durationMs: number;
+    error?: string;
+    timestamp: string;
+    anomaly: boolean;
+    anomalyReason?: string;
+    constructor(agentName: string, model: string);
+    startSpan(name: string, options?: SpanOptions): Span;
+}
+declare function trace<T extends unknown[], R>(fn: (run: Run, ...args: T) => Promise<R>, options: TraceOptions): (...args: T) => Promise<R>;
+
+export { Run, Span, type SpanOptions, type TraceOptions, trace };

package/dist/index.d.ts

@@ -0,0 +1,53 @@
+interface TraceOptions {
+    agentName: string;
+    farolKey: string;
+    farolEndpoint?: string;
+    model?: string;
+    costPer1kInputTokens?: number;
+    costPer1kOutputTokens?: number;
+    captureIo?: boolean;
+}
+interface SpanOptions {
+    type?: "tool" | "llm";
+    metadata?: Record<string, unknown>;
+}
+declare class Span {
+    name: string;
+    type: string;
+    metadata: Record<string, unknown>;
+    inputTokens: number;
+    outputTokens: number;
+    costUsd: number;
+    input?: string;
+    output?: string;
+    error?: string;
+    startedAt: string;
+    endedAt?: string;
+    durationMs?: number;
+    private _startTime;
+    constructor(name: string, options?: SpanOptions);
+    end(error?: Error): void;
+    toDict(captureIo: boolean): Record<string, unknown>;
+}
+declare class Run {
+    id: string;
+    agent: string;
+    model: string;
+    topic?: string;
+    status: string;
+    steps: unknown[];
+    spans: Span[];
+    inputTokens: number;
+    outputTokens: number;
+    costUsd: number;
+    durationMs: number;
+    error?: string;
+    timestamp: string;
+    anomaly: boolean;
+    anomalyReason?: string;
+    constructor(agentName: string, model: string);
+    startSpan(name: string, options?: SpanOptions): Span;
+}
+declare function trace<T extends unknown[], R>(fn: (run: Run, ...args: T) => Promise<R>, options: TraceOptions): (...args: T) => Promise<R>;
+
+export { Run, Span, type SpanOptions, type TraceOptions, trace };

package/dist/index.js

@@ -0,0 +1,164 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Run: () => Run,
+  Span: () => Span,
+  trace: () => trace
+});
+module.exports = __toCommonJS(index_exports);
+var DEFAULT_ENDPOINT = "https://drmyexzztahpudgrfjsk.supabase.co/functions/v1/ingest";
+var Span = class {
+  constructor(name, options = {}) {
+    this.inputTokens = 0;
+    this.outputTokens = 0;
+    this.costUsd = 0;
+    this.name = name;
+    this.type = options.type ?? "tool";
+    this.metadata = options.metadata ?? {};
+    this.startedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this._startTime = Date.now();
+  }
+  end(error) {
+    this.endedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.durationMs = Date.now() - this._startTime;
+    if (error) this.error = error.message;
+  }
+  toDict(captureIo) {
+    const d = {
+      name: this.name,
+      type: this.type,
+      metadata: this.metadata,
+      started_at: this.startedAt,
+      ended_at: this.endedAt,
+      duration_ms: this.durationMs,
+      input_tokens: this.inputTokens,
+      output_tokens: this.outputTokens,
+      cost_usd: this.costUsd,
+      error: this.error ?? null
+    };
+    if (captureIo) {
+      d.input = this.input ?? null;
+      d.output = this.output ?? null;
+    }
+    return d;
+  }
+};
+var Run = class {
+  constructor(agentName, model) {
+    this.status = "running";
+    this.steps = [];
+    this.spans = [];
+    this.inputTokens = 0;
+    this.outputTokens = 0;
+    this.costUsd = 0;
+    this.durationMs = 0;
+    this.anomaly = false;
+    this.id = `run_${Date.now()}`;
+    this.agent = agentName;
+    this.model = model;
+    this.timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  }
+  startSpan(name, options = {}) {
+    const span = new Span(name, options);
+    this.spans.push(span);
+    return span;
+  }
+};
+function trace(fn, options) {
+  const {
+    agentName,
+    farolKey,
+    farolEndpoint = DEFAULT_ENDPOINT,
+    model = "unknown",
+    costPer1kInputTokens = 25e-5,
+    costPer1kOutputTokens = 125e-5,
+    captureIo = false
+  } = options;
+  if (captureIo) {
+    console.warn(
+      "[Farol] WARNING: captureIo is enabled \u2014 prompts are being stored in your Farol dashboard"
+    );
+  }
+  return async (...args) => {
+    const run = new Run(agentName, model);
+    const startTime = Date.now();
+    try {
+      const result = await fn(run, ...args);
+      run.status = "success";
+      return result;
+    } catch (err) {
+      run.status = "error";
+      run.error = err instanceof Error ? err.message : String(err);
+      throw err;
+    } finally {
+      run.durationMs = Date.now() - startTime;
+      run.costUsd = parseFloat(
+        (run.inputTokens / 1e3 * costPer1kInputTokens + run.outputTokens / 1e3 * costPer1kOutputTokens).toFixed(6)
+      );
+      for (const span of run.spans) {
+        if (!span.endedAt) span.end();
+      }
+      await sendToFarol(run, farolKey, farolEndpoint, captureIo);
+    }
+  };
+}
+async function sendToFarol(run, farolKey, endpoint, captureIo) {
+  try {
+    const payload = {
+      id: run.id,
+      agent: run.agent,
+      model: run.model,
+      topic: run.topic ?? null,
+      status: run.status,
+      steps: run.steps,
+      spans: run.spans.map((s) => s.toDict(captureIo)),
+      input_tokens: run.inputTokens,
+      output_tokens: run.outputTokens,
+      cost_usd: run.costUsd,
+      duration_ms: run.durationMs,
+      error: run.error ?? null,
+      timestamp: run.timestamp,
+      anomaly: run.anomaly,
+      anomaly_reason: run.anomalyReason ?? null,
+      farol_key: farolKey
+    };
+    const res = await fetch(endpoint, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(payload)
+    });
+    if (res.ok) {
+      console.log("[Farol] Synced to Farol");
+    } else {
+      const body = await res.text();
+      console.error(`[Farol] Ingest failed (${res.status}): ${body}`);
+    }
+  } catch (err) {
+    console.error(`[Farol] Ingest request failed: ${err}`);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Run,
+  Span,
+  trace
+});

package/dist/index.mjs

@@ -0,0 +1,137 @@
+// src/index.ts
+var DEFAULT_ENDPOINT = "https://drmyexzztahpudgrfjsk.supabase.co/functions/v1/ingest";
+var Span = class {
+  constructor(name, options = {}) {
+    this.inputTokens = 0;
+    this.outputTokens = 0;
+    this.costUsd = 0;
+    this.name = name;
+    this.type = options.type ?? "tool";
+    this.metadata = options.metadata ?? {};
+    this.startedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this._startTime = Date.now();
+  }
+  end(error) {
+    this.endedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.durationMs = Date.now() - this._startTime;
+    if (error) this.error = error.message;
+  }
+  toDict(captureIo) {
+    const d = {
+      name: this.name,
+      type: this.type,
+      metadata: this.metadata,
+      started_at: this.startedAt,
+      ended_at: this.endedAt,
+      duration_ms: this.durationMs,
+      input_tokens: this.inputTokens,
+      output_tokens: this.outputTokens,
+      cost_usd: this.costUsd,
+      error: this.error ?? null
+    };
+    if (captureIo) {
+      d.input = this.input ?? null;
+      d.output = this.output ?? null;
+    }
+    return d;
+  }
+};
+var Run = class {
+  constructor(agentName, model) {
+    this.status = "running";
+    this.steps = [];
+    this.spans = [];
+    this.inputTokens = 0;
+    this.outputTokens = 0;
+    this.costUsd = 0;
+    this.durationMs = 0;
+    this.anomaly = false;
+    this.id = `run_${Date.now()}`;
+    this.agent = agentName;
+    this.model = model;
+    this.timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  }
+  startSpan(name, options = {}) {
+    const span = new Span(name, options);
+    this.spans.push(span);
+    return span;
+  }
+};
+function trace(fn, options) {
+  const {
+    agentName,
+    farolKey,
+    farolEndpoint = DEFAULT_ENDPOINT,
+    model = "unknown",
+    costPer1kInputTokens = 25e-5,
+    costPer1kOutputTokens = 125e-5,
+    captureIo = false
+  } = options;
+  if (captureIo) {
+    console.warn(
+      "[Farol] WARNING: captureIo is enabled \u2014 prompts are being stored in your Farol dashboard"
+    );
+  }
+  return async (...args) => {
+    const run = new Run(agentName, model);
+    const startTime = Date.now();
+    try {
+      const result = await fn(run, ...args);
+      run.status = "success";
+      return result;
+    } catch (err) {
+      run.status = "error";
+      run.error = err instanceof Error ? err.message : String(err);
+      throw err;
+    } finally {
+      run.durationMs = Date.now() - startTime;
+      run.costUsd = parseFloat(
+        (run.inputTokens / 1e3 * costPer1kInputTokens + run.outputTokens / 1e3 * costPer1kOutputTokens).toFixed(6)
+      );
+      for (const span of run.spans) {
+        if (!span.endedAt) span.end();
+      }
+      await sendToFarol(run, farolKey, farolEndpoint, captureIo);
+    }
+  };
+}
+async function sendToFarol(run, farolKey, endpoint, captureIo) {
+  try {
+    const payload = {
+      id: run.id,
+      agent: run.agent,
+      model: run.model,
+      topic: run.topic ?? null,
+      status: run.status,
+      steps: run.steps,
+      spans: run.spans.map((s) => s.toDict(captureIo)),
+      input_tokens: run.inputTokens,
+      output_tokens: run.outputTokens,
+      cost_usd: run.costUsd,
+      duration_ms: run.durationMs,
+      error: run.error ?? null,
+      timestamp: run.timestamp,
+      anomaly: run.anomaly,
+      anomaly_reason: run.anomalyReason ?? null,
+      farol_key: farolKey
+    };
+    const res = await fetch(endpoint, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(payload)
+    });
+    if (res.ok) {
+      console.log("[Farol] Synced to Farol");
+    } else {
+      const body = await res.text();
+      console.error(`[Farol] Ingest failed (${res.status}): ${body}`);
+    }
+  } catch (err) {
+    console.error(`[Farol] Ingest request failed: ${err}`);
+  }
+}
+export {
+  Run,
+  Span,
+  trace
+};

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@usefarol/sdk",
+  "version": "0.1.0",
+  "description": "AI agent observability SDK for Node.js — plug-and-play monitoring for your agents",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": ["ai", "agents", "observability", "monitoring", "llm", "farol"],
+  "author": "Farol",
+  "license": "MIT",
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/src/index.ts

@@ -0,0 +1,191 @@
+const DEFAULT_ENDPOINT =
+  "https://drmyexzztahpudgrfjsk.supabase.co/functions/v1/ingest";
+
+export interface TraceOptions {
+  agentName: string;
+  farolKey: string;
+  farolEndpoint?: string;
+  model?: string;
+  costPer1kInputTokens?: number;
+  costPer1kOutputTokens?: number;
+  captureIo?: boolean;
+}
+
+export interface SpanOptions {
+  type?: "tool" | "llm";
+  metadata?: Record<string, unknown>;
+}
+
+export class Span {
+  name: string;
+  type: string;
+  metadata: Record<string, unknown>;
+  inputTokens = 0;
+  outputTokens = 0;
+  costUsd = 0;
+  input?: string;
+  output?: string;
+  error?: string;
+  startedAt: string;
+  endedAt?: string;
+  durationMs?: number;
+  private _startTime: number;
+
+  constructor(name: string, options: SpanOptions = {}) {
+    this.name = name;
+    this.type = options.type ?? "tool";
+    this.metadata = options.metadata ?? {};
+    this.startedAt = new Date().toISOString();
+    this._startTime = Date.now();
+  }
+
+  end(error?: Error): void {
+    this.endedAt = new Date().toISOString();
+    this.durationMs = Date.now() - this._startTime;
+    if (error) this.error = error.message;
+  }
+
+  toDict(captureIo: boolean): Record<string, unknown> {
+    const d: Record<string, unknown> = {
+      name: this.name,
+      type: this.type,
+      metadata: this.metadata,
+      started_at: this.startedAt,
+      ended_at: this.endedAt,
+      duration_ms: this.durationMs,
+      input_tokens: this.inputTokens,
+      output_tokens: this.outputTokens,
+      cost_usd: this.costUsd,
+      error: this.error ?? null,
+    };
+    if (captureIo) {
+      d.input = this.input ?? null;
+      d.output = this.output ?? null;
+    }
+    return d;
+  }
+}
+
+export class Run {
+  id: string;
+  agent: string;
+  model: string;
+  topic?: string;
+  status = "running";
+  steps: unknown[] = [];
+  spans: Span[] = [];
+  inputTokens = 0;
+  outputTokens = 0;
+  costUsd = 0;
+  durationMs = 0;
+  error?: string;
+  timestamp: string;
+  anomaly = false;
+  anomalyReason?: string;
+
+  constructor(agentName: string, model: string) {
+    this.id = `run_${Date.now()}`;
+    this.agent = agentName;
+    this.model = model;
+    this.timestamp = new Date().toISOString();
+  }
+
+  startSpan(name: string, options: SpanOptions = {}): Span {
+    const span = new Span(name, options);
+    this.spans.push(span);
+    return span;
+  }
+}
+
+export function trace<T extends unknown[], R>(
+  fn: (run: Run, ...args: T) => Promise<R>,
+  options: TraceOptions,
+): (...args: T) => Promise<R> {
+  const {
+    agentName,
+    farolKey,
+    farolEndpoint = DEFAULT_ENDPOINT,
+    model = "unknown",
+    costPer1kInputTokens = 0.00025,
+    costPer1kOutputTokens = 0.00125,
+    captureIo = false,
+  } = options;
+
+  if (captureIo) {
+    console.warn(
+      "[Farol] WARNING: captureIo is enabled — prompts are being stored in your Farol dashboard",
+    );
+  }
+
+  return async (...args: T): Promise<R> => {
+    const run = new Run(agentName, model);
+    const startTime = Date.now();
+
+    try {
+      const result = await fn(run, ...args);
+      run.status = "success";
+      return result;
+    } catch (err) {
+      run.status = "error";
+      run.error = err instanceof Error ? err.message : String(err);
+      throw err;
+    } finally {
+      run.durationMs = Date.now() - startTime;
+      run.costUsd = parseFloat(
+        (
+          (run.inputTokens / 1000) * costPer1kInputTokens +
+          (run.outputTokens / 1000) * costPer1kOutputTokens
+        ).toFixed(6),
+      );
+
+      for (const span of run.spans) {
+        if (!span.endedAt) span.end();
+      }
+
+      await sendToFarol(run, farolKey, farolEndpoint, captureIo);
+    }
+  };
+}
+
+async function sendToFarol(
+  run: Run,
+  farolKey: string,
+  endpoint: string,
+  captureIo: boolean,
+): Promise<void> {
+  try {
+    const payload = {
+      id: run.id,
+      agent: run.agent,
+      model: run.model,
+      topic: run.topic ?? null,
+      status: run.status,
+      steps: run.steps,
+      spans: run.spans.map((s) => s.toDict(captureIo)),
+      input_tokens: run.inputTokens,
+      output_tokens: run.outputTokens,
+      cost_usd: run.costUsd,
+      duration_ms: run.durationMs,
+      error: run.error ?? null,
+      timestamp: run.timestamp,
+      anomaly: run.anomaly,
+      anomaly_reason: run.anomalyReason ?? null,
+      farol_key: farolKey,
+    };
+
+    const res = await fetch(endpoint, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(payload),
+    });
+
+    if (res.ok) {
+      console.log("[Farol] Synced to Farol");
+    } else {
+      const body = await res.text();
+      console.error(`[Farol] Ingest failed (${res.status}): ${body}`);
+    }
+  } catch (err) {
+    console.error(`[Farol] Ingest request failed: ${err}`);
+  }
+}

package/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "declaration": true,
+    "strict": true,
+    "outDir": "dist"
+  },
+  "include": ["src"]
+}