@ap3x/a2a 1.0.0 → 2.0.0

package/src/card/generator.ts

@@ -1,18 +0,0 @@
-import type { AgentCard, GenerateCardOptions } from "../types.js";
-
-export function generateAgentCard(opts: GenerateCardOptions): AgentCard {
-  return {
-    name: opts.name,
-    description: opts.description,
-    url: opts.url,
-    version: opts.version ?? "1.0.0",
-    capabilities: {
-      streaming: opts.streaming ?? false,
-      pushNotifications: false,
-      stateTransitionHistory: true,
-    },
-    skills: opts.skills ?? [],
-    defaultInputModes: ["text"],
-    defaultOutputModes: ["text"],
-  };
-}

package/src/client/index.ts

@@ -1,172 +0,0 @@
-import type { A2AClientConfig, A2ATask, AgentCard } from "../types.js";
-import { A2AAuthExpiredError } from "../errors.js";
-
-export class A2AClient {
-  constructor(private readonly config: A2AClientConfig) {
-    // Validate baseUrl scheme to prevent SSRF via file://, ftp://, or other
-    // non-HTTP schemes when baseUrl is derived from untrusted agent registry data.
-    let parsedUrl: URL;
-    try {
-      parsedUrl = new URL(config.baseUrl);
-    } catch {
-      throw new Error(`Invalid A2A baseUrl: "${config.baseUrl}" is not a valid URL`);
-    }
-    if (parsedUrl.protocol !== "https:" && parsedUrl.protocol !== "http:") {
-      throw new Error(`Invalid A2A baseUrl scheme: "${parsedUrl.protocol}" — only "https:" and "http:" are allowed`);
-    }
-  }
-
-  /** Throw A2AAuthExpiredError on 401, otherwise return the response unchanged. */
-  private assertNotUnauthorized(res: Response, url: string): void {
-    if (res.status === 401) {
-      throw new A2AAuthExpiredError(
-        `A2A request unauthorized (401): credentials may be expired — ${url}`,
-        url,
-      );
-    }
-  }
-
-  async getCard(): Promise<AgentCard> {
-    const url = `${this.config.baseUrl}/.well-known/agent.json`;
-    const res = await fetch(url, {
-      headers: this.config.headers,
-    });
-    this.assertNotUnauthorized(res, url);
-    if (!res.ok) throw new Error(`Failed to fetch agent card: ${res.status}`);
-    return res.json() as Promise<AgentCard>;
-  }
-
-  async sendTask(message: string, opts?: { sessionId?: string }): Promise<string> {
-    const taskId = opts?.sessionId ?? crypto.randomUUID();
-    const body = {
-      jsonrpc: "2.0",
-      id: 1,
-      method: "tasks/send",
-      params: {
-        id: taskId,
-        message: {
-          role: "user",
-          parts: [{ type: "text", text: message }],
-        },
-      },
-    };
-
-    const res = await fetch(this.config.baseUrl, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        ...this.config.headers,
-      },
-      body: JSON.stringify(body),
-      signal: this.config.timeout
-        ? AbortSignal.timeout(this.config.timeout)
-        : undefined,
-    });
-    this.assertNotUnauthorized(res, this.config.baseUrl);
-    if (!res.ok) throw new Error(`A2A tasks/send failed: ${res.status}`);
-    const result = (await res.json()) as { result?: A2ATask; error?: { message: string } };
-    if (result.error) throw new Error(`A2A error: ${result.error.message}`);
-    if (!result.result) {
-      throw new Error(`Server returned invalid JSON-RPC response: missing "result" field`);
-    }
-    const task = result.result;
-    return task.artifacts?.[0]?.parts[0]?.type === "text"
-      ? task.artifacts[0].parts[0].text
-      : task.status.message?.parts?.[0]?.type === "text"
-        ? task.status.message.parts[0].text
-        : JSON.stringify(task);
-  }
-
-  async *streamTask(message: string): AsyncGenerator<string> {
-    const taskId = crypto.randomUUID();
-    const body = {
-      jsonrpc: "2.0",
-      id: 1,
-      method: "tasks/sendSubscribe",
-      params: {
-        id: taskId,
-        message: { role: "user", parts: [{ type: "text", text: message }] },
-      },
-    };
-
-    const res = await fetch(this.config.baseUrl, {
-      method: "POST",
-      headers: { "Content-Type": "application/json", Accept: "text/event-stream", ...this.config.headers },
-      body: JSON.stringify(body),
-      signal: this.config.timeout
-        ? AbortSignal.timeout(this.config.timeout)
-        : undefined,
-    });
-
-    this.assertNotUnauthorized(res, this.config.baseUrl);
-    if (!res.ok || !res.body) throw new Error(`A2A stream failed: ${res.status}`);
-
-    const reader: ReadableStreamDefaultReader<Uint8Array> = res.body.getReader();
-    const decoder = new TextDecoder();
-    let buffer = "";
-    const readTimeoutMs = this.config.timeout ?? 30_000;
-
-    const readWithTimeout = async (
-      r: ReadableStreamDefaultReader<Uint8Array>,
-      timeoutMs: number,
-    ) => {
-      const timer = setTimeout(() => {
-        void r.cancel("A2A stream read timeout");
-      }, timeoutMs);
-      try {
-        return await r.read();
-      } finally {
-        clearTimeout(timer);
-      }
-    };
-
-    try {
-      while (true) {
-        const { done, value } = await readWithTimeout(reader, readTimeoutMs);
-        if (done) break;
-        buffer += decoder.decode(value, { stream: true });
-        const lines = buffer.split("\n");
-        buffer = lines.pop() ?? "";
-        for (const line of lines) {
-          if (line.startsWith("data: ")) {
-            const data = line.slice(6).trim();
-            if (data === "[DONE]") return;
-            try {
-              const event = JSON.parse(data) as { result?: A2ATask };
-              const text = event.result?.status?.message?.parts?.[0];
-              // BUG-0028: A2A TextPart declares `text` as optional, meaning
-              // text.text may be undefined even when type === "text". The != null
-              // check ensures we never yield undefined to stream consumers.
-              if (text?.type === "text" && text.text != null) yield text.text;
-            } catch { /* ignore parse errors */ }
-          }
-        }
-      }
-    } finally {
-      reader.releaseLock();
-    }
-  }
-
-  /** Convert this A2A client into an AP3X ToolDefinition-compatible object */
-  asToolDefinition(opts: { name: string; description: string }): {
-    name: string;
-    description: string;
-    schema: { type: "object"; properties: { message: { type: "string"; description: string } }; required: string[] };
-    parallelSafe: boolean;
-    execute: (input: { message: string }) => Promise<string>;
-  } {
-    return {
-      name: opts.name,
-      description: opts.description,
-      schema: {
-        type: "object",
-        properties: {
-          message: { type: "string", description: "Message to send to the remote agent" },
-        },
-        required: ["message"],
-      },
-      parallelSafe: true,
-      execute: (input: { message: string }) => this.sendTask(input.message),
-    };
-  }
-}

package/src/errors.ts

@@ -1,21 +0,0 @@
-/**
- * Thrown when an A2A request receives a 401 Unauthorized response,
- * indicating that auth credentials (e.g. an OAuth2 token) have expired
- * or are invalid.
- *
- * Callers can catch this specific error type to trigger token refresh
- * and retry logic without needing changes to A2AClientConfig.
- */
-export class A2AAuthExpiredError extends Error {
-  /** HTTP status code (always 401). */
-  readonly statusCode = 401;
-
-  constructor(
-    message: string,
-    /** The URL that returned 401. */
-    public readonly url: string,
-  ) {
-    super(message);
-    this.name = "A2AAuthExpiredError";
-  }
-}

package/src/index.ts

@@ -1,15 +0,0 @@
-export { A2AAuthExpiredError } from "./errors.js";
-export { generateAgentCard } from "./card/generator.js";
-export { A2AClient } from "./client/index.js";
-export { A2AServer } from "./server/index.js";
-export { a2aAgent } from "./swarm/a2a-agent.js";
-export type {
-  AgentCard,
-  A2AMessage,
-  A2ATask,
-  A2AClientConfig,
-  AgentSkill,
-  AgentCapabilities,
-  GenerateCardOptions,
-} from "./types.js";
-export type { A2AAgentDef } from "./swarm/a2a-agent.js";

package/src/server/handler.ts

@@ -1,90 +0,0 @@
-import type { A2ATask } from "../types.js";
-
-export type TaskHandler = (
-  message: string,
-  taskId: string,
-) => string | Promise<string> | AsyncGenerator<string>;
-
-/** Extract a safe error message from an unknown throw value (BUG-0029). */
-function errorMessage(e: unknown): string {
-  return e instanceof Error ? e.message : String(e);
-}
-
-function isAsyncGenerator(value: unknown): value is AsyncGenerator<string> {
-  return (
-    typeof value === "object" &&
-    value !== null &&
-    typeof (value as { [Symbol.asyncIterator]?: unknown })[Symbol.asyncIterator] === "function"
-  );
-}
-
-export async function handleJsonRPC(
-  body: unknown,
-  handler: TaskHandler,
-  agentCard: import("../types.js").AgentCard,
-): Promise<{ response?: unknown; stream?: AsyncGenerator<string>; taskId?: string }> {
-  const req = body as { jsonrpc: string; id: unknown; method: string; params?: { id?: string; message?: { parts?: Array<{ type: string; text?: string }> } } };
-
-  if (req.jsonrpc !== "2.0") {
-    return { response: { jsonrpc: "2.0", id: req.id, error: { code: -32600, message: "Invalid Request" } } };
-  }
-
-  const taskId = req.params?.id ?? crypto.randomUUID();
-  const messageText = req.params?.message?.parts?.find(p => p.type === "text")?.text ?? "";
-
-  if (req.method === "tasks/send") {
-    try {
-      const result = await handler(messageText, taskId);
-      let output: string;
-      if (isAsyncGenerator(result)) {
-        const chunks: string[] = [];
-        for await (const chunk of result) chunks.push(chunk);
-        output = chunks.join("");
-      } else {
-        output = result;
-      }
-      const task: A2ATask = {
-        id: taskId,
-        status: { state: "completed" },
-        artifacts: [{ parts: [{ type: "text", text: output }] }],
-      };
-      return { response: { jsonrpc: "2.0", id: req.id, result: task } };
-    } catch (e: unknown) {
-      console.error("[a2a] tasks/send error:", errorMessage(e));
-      return { response: { jsonrpc: "2.0", id: req.id, error: { code: -32603, message: "Internal server error" } } };
-    }
-  }
-
-  if (req.method === "tasks/sendSubscribe") {
-    // If agentCard is provided and streaming is not enabled, reject with method-not-found
-    if (agentCard && !agentCard.capabilities?.streaming) {
-      return { response: { jsonrpc: "2.0", id: req.id, error: { code: -32601, message: "Method not found: streaming not supported" } } };
-    }
-    try {
-      const result = await handler(messageText, taskId);
-      async function* safeStream(gen: AsyncGenerator<string>): AsyncGenerator<string> {
-        yield* gen;
-      }
-      if (isAsyncGenerator(result)) {
-        return { stream: safeStream(result), taskId };
-      }
-      const output: string = result;
-      // Wrap promise as single-item stream
-      async function* single(): AsyncGenerator<string> {
-        yield output;
-      }
-      return { stream: safeStream(single()), taskId };
-    } catch (e: unknown) {
-      console.error("[a2a] tasks/sendSubscribe error:", errorMessage(e));
-      return { response: { jsonrpc: "2.0", id: req.id, error: { code: -32603, message: errorMessage(e) } } };
-    }
-  }
-
-  if (req.method === "tasks/get") {
-    // Basic: return empty completed task (no persistence in this server)
-    const task: A2ATask = { id: taskId, status: { state: "completed" } };
-    return { response: { jsonrpc: "2.0", id: req.id, result: task } };
-  }
-
-  return { response: { jsonrpc: "2.0", id: req.id, error: { code: -32601, message: "Method not found" } } };
-}

package/src/server/index.ts

@@ -1,208 +0,0 @@
-import crypto from "node:crypto";
-import type { AgentCard } from "../types.js";
-import { handleJsonRPC, type TaskHandler } from "./handler.js";
-import { createSSEResponse } from "./sse.js";
-
-const MAX_BODY_SIZE = 1 * 1024 * 1024; // 1 MB
-
-const SECURITY_HEADERS: Record<string, string> = {
-  "X-Content-Type-Options": "nosniff",
-  "X-Frame-Options": "DENY",
-  "Content-Security-Policy": "default-src 'none'",
-};
-
-export interface A2AServerOptions {
-  /** API key for Bearer token authentication. When set, every request (except
-   *  CORS preflight) must include an `Authorization: Bearer <key>` header.
-   *
-   *  BUG-0256: In production (NODE_ENV=production), apiKey is required unless
-   *  `allowUnauthenticated` is explicitly set to true. */
-  apiKey?: string;
-  /** Explicitly opt out of authentication. Required in production when no
-   *  apiKey is provided. Defaults to false. */
-  allowUnauthenticated?: boolean;
-}
-
-export class A2AServer {
-  private readonly apiKey?: string;
-
-  constructor(
-    private readonly agentCard: AgentCard,
-    private readonly handler: TaskHandler,
-    options?: A2AServerOptions,
-  ) {
-    this.apiKey = options?.apiKey;
-    if (!this.apiKey) {
-      if (process.env.NODE_ENV === "production" && !options?.allowUnauthenticated) {
-        throw new Error(
-          "[A2AServer] apiKey is required in production. " +
-          "Set options.apiKey or pass allowUnauthenticated: true to explicitly opt out.",
-        );
-      }
-      console.warn("[A2AServer] WARNING: No apiKey configured — all endpoints are unauthenticated");
-    }
-  }
-
-  requestHandler(): (req: Request) => Promise<Response> {
-    return async (req: Request): Promise<Response> => {
-      const url = new URL(req.url);
-
-      // Handle CORS preflight — deny all cross-origin requests by returning
-      // no Access-Control-Allow-Origin header, which causes the browser to
-      // block the subsequent actual request.
-      if (req.method === "OPTIONS") {
-        return new Response(null, { status: 204, headers: { ...SECURITY_HEADERS } });
-      }
-
-      // Optional API key authentication — if configured, require a matching
-      // Bearer token on every non-preflight request.
-      if (this.apiKey) {
-        const token = req.headers.get("authorization") ?? "";
-        const expected = `Bearer ${this.apiKey}`;
-        const tokenBuf = Buffer.from(token);
-        const expectedBuf = Buffer.from(expected);
-        if (tokenBuf.length !== expectedBuf.length || !crypto.timingSafeEqual(tokenBuf, expectedBuf)) {
-          return new Response(
-            JSON.stringify({ jsonrpc: "2.0", id: null, error: { code: -32600, message: "Unauthorized" } }),
-            { status: 401, headers: { "Content-Type": "application/json", ...SECURITY_HEADERS } },
-          );
-        }
-      }
-
-      if (req.method === "GET" && url.pathname === "/.well-known/agent.json") {
-        return new Response(JSON.stringify(this.agentCard), {
-          headers: { "Content-Type": "application/json", ...SECURITY_HEADERS },
-        });
-      }
-
-      if (req.method !== "POST") {
-        return new Response("Method Not Allowed", { status: 405, headers: { ...SECURITY_HEADERS } });
-      }
-
-      // Require application/json Content-Type on POST requests. This is not a
-      // CORS "simple" content type, so browsers must send a preflight OPTIONS
-      // request first. Since we return no CORS allow headers, the preflight
-      // fails and the cross-origin POST is never sent — preventing CSRF.
-      const ct = req.headers.get("content-type") ?? "";
-      if (!ct.includes("application/json")) {
-        return new Response(
-          JSON.stringify({ jsonrpc: "2.0", id: null, error: { code: -32600, message: "Content-Type must be application/json" } }),
-          { status: 415, headers: { "Content-Type": "application/json", ...SECURITY_HEADERS } },
-        );
-      }
-
-      // Enforce body size limit for Fetch-API callers (mirrors listen() guard)
-      const contentLength = parseInt(req.headers.get("content-length") ?? "", 10);
-      if (contentLength > MAX_BODY_SIZE) {
-        return new Response(JSON.stringify({ jsonrpc: "2.0", id: null, error: { code: -32600, message: "Request body too large" } }), { status: 413, headers: { "Content-Type": "application/json", ...SECURITY_HEADERS } });
-      }
-      let body: unknown;
-      try {
-        const text = await req.text();
-        if (text.length > MAX_BODY_SIZE) {
-          return new Response(JSON.stringify({ jsonrpc: "2.0", id: null, error: { code: -32600, message: "Request body too large" } }), { status: 413, headers: { "Content-Type": "application/json", ...SECURITY_HEADERS } });
-        }
-        body = JSON.parse(text);
-      }
-      catch { return new Response(JSON.stringify({ jsonrpc: "2.0", id: null, error: { code: -32700, message: "Parse error" } }), { status: 400, headers: { "Content-Type": "application/json", ...SECURITY_HEADERS } }); }
-
-      const acceptsSSE = req.headers.get("Accept")?.includes("text/event-stream");
-      const result = await handleJsonRPC(body, this.handler, this.agentCard);
-
-      if (result.stream && acceptsSSE) {
-        return createSSEResponse(result.stream, result.taskId ?? "");
-      }
-
-      if (result.stream) {
-        // Client does not accept SSE but the handler returned a stream.
-        // Close the AsyncGenerator to prevent a resource leak, then return
-        // a 406 so the client knows it must use Accept: text/event-stream.
-        await result.stream.return(undefined);
-        return new Response(
-          JSON.stringify({
-            jsonrpc: "2.0",
-            id: (body as Record<string, unknown>)?.id ?? null,
-            error: { code: -32600, message: "This method requires Accept: text/event-stream" },
-          }),
-          { status: 406, headers: { "Content-Type": "application/json", ...SECURITY_HEADERS } },
-        );
-      }
-
-      return new Response(JSON.stringify(result.response), {
-        headers: { "Content-Type": "application/json", ...SECURITY_HEADERS },
-      });
-    };
-  }
-
-  async listen(port = 3000): Promise<void> {
-    const { createServer } = await import("node:http");
-    const handler = this.requestHandler();
-    const server = createServer(async (req, res) => {
-      const url = `http://localhost:${port}${req.url}`;
-      const headers: Record<string, string> = {};
-      for (const [k, v] of Object.entries(req.headers)) {
-        if (typeof v === "string") headers[k] = v;
-      }
-      let body: Buffer | undefined;
-      try {
-        body = req.method !== "GET" && req.method !== "HEAD"
-          ? await new Promise<Buffer>((resolve, reject) => {
-              const chunks: Buffer[] = [];
-              let totalBytes = 0;
-              req.on("data", (c: Buffer) => {
-                totalBytes += c.length;
-                if (totalBytes > MAX_BODY_SIZE) {
-                  req.destroy();
-                  res.writeHead(413, { "Content-Type": "text/plain", ...SECURITY_HEADERS });
-                  res.end("Payload Too Large");
-                  reject(new Error("Payload Too Large"));
-                  return;
-                }
-                chunks.push(c);
-              });
-              req.on("end", () => resolve(Buffer.concat(chunks)));
-              req.on("error", reject);
-            })
-          : undefined;
-      } catch {
-        return; // already responded with 413
-      }
-
-      try {
-        const fetchReq = new Request(url, { method: req.method, headers, body });
-        const fetchRes = await handler(fetchReq);
-
-        res.writeHead(fetchRes.status, { ...Object.fromEntries(fetchRes.headers.entries()), ...SECURITY_HEADERS });
-        const contentType = fetchRes.headers.get("content-type") ?? "";
-        if (contentType.includes("text/event-stream") && fetchRes.body) {
-          const reader = fetchRes.body.getReader();
-          try {
-            while (true) {
-              const { done, value } = await reader.read();
-              if (done) break;
-              res.write(value);
-            }
-          } finally {
-            res.end();
-          }
-        } else {
-          const buf = await fetchRes.arrayBuffer();
-          res.end(Buffer.from(buf));
-        }
-      } catch {
-        if (!res.headersSent) {
-          res.writeHead(500, { "Content-Type": "text/plain", ...SECURITY_HEADERS });
-        }
-        if (!res.writableEnded) {
-          res.end("Internal Server Error");
-        }
-      }
-    });
-
-    await new Promise<void>((resolve, reject) => {
-      server.listen(port, () => resolve());
-      server.once("error", reject);
-    });
-    console.log(`A2AServer listening on port ${port}`);
-  }
-}

package/src/server/sse.ts

@@ -1,49 +0,0 @@
-export function createSSEResponse(
-  stream: AsyncGenerator<string>,
-  taskId: string,
-): Response {
-  const encoder = new TextEncoder();
-  const readable = new ReadableStream({
-    async start(controller) {
-      try {
-        for await (const chunk of stream) {
-          const event = JSON.stringify({
-            result: {
-              id: taskId,
-              status: { state: "working", message: { role: "agent", parts: [{ type: "text", text: chunk }] } },
-            },
-          });
-          controller.enqueue(encoder.encode(`data: ${event}\n\n`));
-        }
-        const doneEvent = JSON.stringify({
-          result: { id: taskId, status: { state: "completed" } },
-        });
-        controller.enqueue(encoder.encode(`data: ${doneEvent}\n\n`));
-        controller.enqueue(encoder.encode("data: [DONE]\n\n"));
-      } catch (err) {
-        console.error("[a2a] SSE task handler error:", err);
-        const errEvent = JSON.stringify({ error: { code: -32603, message: "Internal server error" } });
-        try {
-          controller.enqueue(encoder.encode(`data: ${errEvent}\n\n`));
-        } catch { /* stream may already be cancelled */ }
-        controller.error(err);
-        return;
-      }
-      controller.close();
-    },
-    cancel() {
-      stream.return(undefined);
-    },
-  });
-  return new Response(readable, {
-    headers: {
-      "Content-Type": "text/event-stream",
-      "Cache-Control": "no-cache",
-      Connection: "keep-alive",
-      "X-Content-Type-Options": "nosniff",
-      "X-Frame-Options": "DENY",
-      "Content-Security-Policy": "default-src 'none'",
-      "X-XSS-Protection": "0",
-    },
-  });
-}

package/src/swarm/a2a-agent.ts

@@ -1,34 +0,0 @@
-import { A2AClient } from "../client/index.js";
-import type { A2AClientConfig } from "../types.js";
-
-export interface A2AAgentDef {
-  id: string;
-  role: string;
-  /** Call this to invoke the remote A2A agent */
-  invoke: (message: string) => Promise<string>;
-  /** Compatible with AP3X ToolDefinition for use in agent loops */
-  asTool: () => {
-    name: string;
-    description: string;
-    schema: { type: "object"; properties: { message: { type: "string" } }; required: string[] };
-    parallelSafe: boolean;
-    execute: (input: { message: string }) => Promise<string>;
-  };
-  capabilities?: string[];
-}
-
-export function a2aAgent(opts: {
-  id: string;
-  role: string;
-  clientConfig: A2AClientConfig;
-  capabilities?: string[];
-}): A2AAgentDef {
-  const client = new A2AClient(opts.clientConfig);
-  return {
-    id: opts.id,
-    role: opts.role,
-    capabilities: opts.capabilities,
-    invoke: (message) => client.sendTask(message),
-    asTool: () => client.asToolDefinition({ name: opts.id, description: opts.role }),
-  };
-}

package/src/types.ts

@@ -1,50 +0,0 @@
-// A2A Protocol types (based on A2A spec)
-export interface AgentSkill {
-  id: string;
-  name: string;
-  description?: string;
-  tags?: string[];
-}
-
-export interface AgentCapabilities {
-  streaming?: boolean;
-  pushNotifications?: boolean;
-  stateTransitionHistory?: boolean;
-}
-
-export interface AgentCard {
-  name: string;
-  description: string;
-  url: string;
-  version?: string;
-  capabilities: AgentCapabilities;
-  skills: AgentSkill[];
-  defaultInputModes?: string[];
-  defaultOutputModes?: string[];
-}
-
-export interface A2AMessage {
-  role: "user" | "agent";
-  parts: Array<{ type: "text"; text: string } | { type: "data"; data: unknown }>;
-}
-
-export interface A2ATask {
-  id: string;
-  status: { state: "submitted" | "working" | "completed" | "failed"; message?: A2AMessage };
-  artifacts?: Array<{ name?: string; parts: A2AMessage["parts"] }>;
-}
-
-export interface A2AClientConfig {
-  baseUrl: string;
-  headers?: Record<string, string>;
-  timeout?: number;
-}
-
-export interface GenerateCardOptions {
-  name: string;
-  description: string;
-  url: string;
-  version?: string;
-  skills?: AgentSkill[];
-  streaming?: boolean;
-}

package/tsconfig.json

@@ -1,20 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext",
-    "lib": ["ES2022"],
-    "rootDir": "./src",
-    "outDir": "./dist",
-    "declaration": true,
-    "declarationDir": "./dist",
-    "sourceMap": true,
-    "strict": true,
-    "noUncheckedIndexedAccess": false,
-    "noImplicitOverride": true,
-    "exactOptionalPropertyTypes": false,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true
-  },
-  "include": ["src/**/*"]
-}