@chat-ads/chatads-sdk 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 ChatAds
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,149 @@
+# ChatAds TypeScript SDK
+
+Type-safe client for the ChatAds `/v1/chatads/messages` endpoint. Works in Node.js 18+ (uses the built-in `fetch`) and modern edge runtimes so you can score leads directly from JavaScript, TypeScript, or serverless environments.
+
+> **Node 18+ required:** The SDK relies on the built-in `fetch`. For Node 16, pass `fetchImplementation` (e.g. `undici`) or transpile to CJS yourself.
+
+## Installation
+
+```bash
+npm install @chat-ads/chatads-sdk
+# or: pnpm add @chat-ads/chatads-sdk
+yarn add @chat-ads/chatads-sdk
+```
+
+## Quickstart
+
+```ts
+import { ChatAdsClient } from "@chat-ads/chatads-sdk";
+
+const client = new ChatAdsClient({
+  apiKey: process.env.CHATADS_API_KEY!,
+  baseUrl: "https://chatads--chatads-api-fastapiserver-serve.modal.run",
+  maxRetries: 2,
+  raiseOnFailure: true,
+});
+
+const response = await client.analyze({
+  message: "Looking for CRM tools for a 10-person sales team",
+  ip: "8.8.8.8",
+  userAgent: "Mozilla/5.0",
+});
+
+if (response.success && response.data?.ad) {
+  console.log(response.data.ad);
+} else {
+  console.error(response.error);
+}
+```
+
+### Convenience helper
+
+```ts
+const result = await client.analyzeMessage("Need scheduling ideas", {
+  pageUrl: "https://acme.com/contact",
+  domain: "acme.com",
+  extraFields: {
+    formId: "lead-gen-7",
+  },
+});
+```
+
+- Reserved payload keys (like `message`, `pageUrl`, etc.) cannot be overwritten inside `extraFields`; the client throws if it detects a collision.
+- Pass `raiseOnFailure: true` to throw `ChatAdsAPIError` when the API returns `success: false` with HTTP 200 responses.
+- Retries honor `Retry-After` headers and exponential backoff (`maxRetries` + `retryBackoffFactorMs`).
+
+## Error handling
+
+```ts
+import { ChatAdsAPIError, ChatAdsSDKError } from "@chat-ads/chatads-sdk";
+
+try {
+  await client.analyze({ message: "Hi" });
+} catch (error) {
+  if (error instanceof ChatAdsAPIError) {
+    console.error(error.statusCode, error.response?.error);
+  } else if (error instanceof ChatAdsSDKError) {
+    console.error("Transport/config error", error);
+  } else {
+    console.error("Unexpected error", error);
+  }
+}
+```
+
+`ChatAdsAPIError` wraps non-2xx API responses (and optionally `success:false`). `ChatAdsSDKError` covers local issues like invalid payloads, timeouts, or missing `fetch`.
+
+## Configuration options
+
+| Option | Description |
+| --- | --- |
+| `apiKey` | Required. Value for the `x-api-key` header. |
+| `baseUrl` | Required HTTPS base URL to your ChatAds deployment. |
+| `endpoint` | Defaults to `/v1/chatads/messages`. Override if you host multiple versions. |
+| `timeoutMs` | Request timeout (default 10s). |
+| `maxRetries` | How many automatic retries to attempt for retryable HTTP statuses. |
+| `retryStatuses` | Array of status codes treated as retryable (defaults to `408, 429, 5xx`). |
+| `retryBackoffFactorMs` | Base backoff delay in milliseconds (default 500). |
+| `raiseOnFailure` | Throw when the API returns `success:false` even if HTTP 200. |
+| `fetchImplementation` | Provide a custom `fetch` for Node < 18 or custom runtimes. |
+| `logger` | Optional logger (any object with `debug`). Useful for redacted request logs. |
+
+## Response shape
+
+```json
+{
+  "success": true,
+  "data": {
+    "matched": true,
+    "ad": {
+      "product": "CRM Pro",
+      "link": "https://getchatads.com/example",
+      "message": "Try CRM Pro for your sales team",
+      "category": "Software"
+    }
+  },
+  "error": null,
+  "meta": {
+    "request_id": "req_123",
+    "processing_time_ms": 42.3,
+    "usage": {
+      "monthly_requests": 120,
+      "free_tier_limit": 1000,
+      "free_tier_remaining": 880,
+      "is_free_tier": false,
+      "has_credit_card": true
+    }
+  }
+}
+```
+
+TypeScript projects can import `ChatAdsResponseEnvelope` and related interfaces for full type safety.
+
+## Examples
+
+```bash
+npm run build
+CHATADS_API_KEY=... CHATADS_BASE_URL=https://chatads--chatads-api-fastapiserver-serve.modal.run \
+  node dist/examples/basic.js
+```
+
+Prefer running the compiled output (after `npm run build`). If you need to run the TypeScript source directly, use `npx ts-node --esm examples/basic.ts` after setting the same env vars.
+
+## Development
+
+```bash
+npm install
+npm run lint
+npm test
+npm run build
+```
+
+This compiles TypeScript to `dist/` (ESM output). CommonJS consumers should transpile or use dynamic `import()`. Publish the folder via npm (`npm publish`) or reference it locally. Tests/linting can be added via Vitest/ESLint if required.
+
+## Changelog
+
+See [CHANGELOG.md](./CHANGELOG.md).
+
+## License
+
+MIT © ChatAds

package/dist/examples/basic.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/examples/basic.js

@@ -0,0 +1,22 @@
+import { ChatAdsClient } from "../src/index.js";
+async function main() {
+    const apiKey = process.env.CHATADS_API_KEY;
+    if (!apiKey) {
+        throw new Error("CHATADS_API_KEY env var is required");
+    }
+    const client = new ChatAdsClient({
+        apiKey,
+        baseUrl: process.env.CHATADS_BASE_URL ?? "https://chatads--chatads-api-fastapiserver-serve.modal.run",
+        maxRetries: 1,
+        raiseOnFailure: true,
+    });
+    const response = await client.analyze({
+        message: "A great home gym always includes a yoga mat",
+        ip: "",
+    });
+    console.log(JSON.stringify(response, null, 2));
+}
+main().catch((error) => {
+    console.error(error);
+    process.exit(1);
+});

package/dist/src/client.d.ts

@@ -0,0 +1,42 @@
+import type { ChatAdsResponseEnvelope, FunctionItemPayload } from "./models.js";
+type FetchLike = typeof fetch;
+type Logger = Pick<Console, "debug">;
+export interface ChatAdsClientOptions {
+    apiKey: string;
+    baseUrl: string;
+    endpoint?: string;
+    timeoutMs?: number;
+    maxRetries?: number;
+    retryStatuses?: number[];
+    retryBackoffFactorMs?: number;
+    raiseOnFailure?: boolean;
+    fetchImplementation?: FetchLike;
+    logger?: Logger;
+    userAgent?: string;
+}
+export interface AnalyzeOptions {
+    timeoutMs?: number;
+    headers?: Record<string, string>;
+}
+export type AnalyzeMessageOptions = Omit<FunctionItemPayload, "message"> & {
+    extraFields?: Record<string, unknown>;
+};
+export declare class ChatAdsClient {
+    private readonly apiKey;
+    private readonly baseUrl;
+    private readonly endpoint;
+    private readonly timeoutMs;
+    private readonly maxRetries;
+    private readonly retryStatuses;
+    private readonly retryBackoffFactorMs;
+    private readonly raiseOnFailure;
+    private readonly fetchImpl;
+    private readonly logger?;
+    private readonly userAgent?;
+    constructor(options: ChatAdsClientOptions);
+    analyze(payload: FunctionItemPayload, options?: AnalyzeOptions): Promise<ChatAdsResponseEnvelope>;
+    analyzeMessage(message: string, extra?: AnalyzeMessageOptions, options?: AnalyzeOptions): Promise<ChatAdsResponseEnvelope>;
+    private post;
+    private logDebug;
+}
+export {};

package/dist/src/client.js

@@ -0,0 +1,258 @@
+import { ChatAdsAPIError, ChatAdsSDKError } from "./errors.js";
+import { RESERVED_PAYLOAD_KEYS } from "./models.js";
+const DEFAULT_ENDPOINT = "/v1/chatads/messages";
+const DEFAULT_TIMEOUT_MS = 10000;
+const DEFAULT_BACKOFF_FACTOR = 500; // ms
+const DEFAULT_RETRYABLE_STATUSES = new Set([408, 409, 425, 429, 500, 502, 503, 504]);
+const FIELD_ALIASES = {
+    pageurl: "pageUrl",
+    page_url: "pageUrl",
+    pagetitle: "pageTitle",
+    page_title: "pageTitle",
+    useragent: "userAgent",
+    user_agent: "userAgent",
+};
+export class ChatAdsClient {
+    constructor(options) {
+        if (!options?.apiKey) {
+            throw new ChatAdsSDKError("apiKey is required");
+        }
+        this.apiKey = options.apiKey;
+        this.baseUrl = normalizeBaseUrl(options.baseUrl);
+        this.endpoint = normalizeEndpoint(options.endpoint ?? DEFAULT_ENDPOINT);
+        this.timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+        this.maxRetries = Math.max(0, options.maxRetries ?? 0);
+        this.retryBackoffFactorMs = Math.max(0, options.retryBackoffFactorMs ?? DEFAULT_BACKOFF_FACTOR);
+        this.retryStatuses = new Set(options.retryStatuses ?? Array.from(DEFAULT_RETRYABLE_STATUSES));
+        this.raiseOnFailure = Boolean(options.raiseOnFailure);
+        this.fetchImpl = options.fetchImplementation ?? globalThis.fetch;
+        if (!this.fetchImpl) {
+            throw new ChatAdsSDKError("Global fetch implementation not found. Pass fetchImplementation explicitly or upgrade to Node 18+");
+        }
+        this.logger = options.logger;
+        this.userAgent = options.userAgent;
+    }
+    async analyze(payload, options) {
+        const body = buildPayload(payload);
+        return this.post(body, options);
+    }
+    async analyzeMessage(message, extra, options) {
+        const payload = {
+            message,
+            ...normalizeOptionalFields(extra ?? {}),
+        };
+        if (extra?.extraFields) {
+            payload.extraFields = extra.extraFields;
+        }
+        return this.analyze(payload, options);
+    }
+    async post(body, options) {
+        const url = `${this.baseUrl}${this.endpoint}`;
+        const headers = {
+            "content-type": "application/json",
+            "x-api-key": this.apiKey,
+            ...lowercaseHeaders(options?.headers),
+        };
+        if (this.userAgent) {
+            headers["user-agent"] = this.userAgent;
+        }
+        let attempt = 0;
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            const timeout = options?.timeoutMs ?? this.timeoutMs;
+            const controller = new AbortController();
+            const timer = setTimeout(() => controller.abort(), timeout);
+            try {
+                this.logDebug(() => ["ChatAds request", { url, headers: sanitizeHeaders(headers), body: sanitizePayload(body) }]);
+                const response = await this.fetchImpl(url, {
+                    method: "POST",
+                    headers,
+                    body: JSON.stringify(body),
+                    signal: controller.signal,
+                });
+                const parsed = await parseResponse(response);
+                const httpError = !response.ok;
+                const logicalError = this.raiseOnFailure && parsed.success === false;
+                if (!httpError && !logicalError) {
+                    clearTimeout(timer);
+                    return parsed;
+                }
+                throw new ChatAdsAPIError({
+                    statusCode: response.status,
+                    response: parsed,
+                    headers: Object.fromEntries(response.headers.entries()),
+                    requestBody: body,
+                    url,
+                });
+            }
+            catch (error) {
+                clearTimeout(timer);
+                const isAbort = error instanceof DOMException && error.name === "AbortError";
+                if (isAbort) {
+                    throw new ChatAdsSDKError(`ChatAds request timed out after ${timeout}ms`, error);
+                }
+                if (error instanceof ChatAdsAPIError) {
+                    if (attempt < this.maxRetries && this.retryStatuses.has(error.statusCode)) {
+                        const delayMs = computeRetryDelay(this.retryBackoffFactorMs, attempt, error.retryAfter);
+                        await sleep(delayMs);
+                        attempt += 1;
+                        continue;
+                    }
+                    throw error;
+                }
+                if (attempt < this.maxRetries) {
+                    const delayMs = computeRetryDelay(this.retryBackoffFactorMs, attempt, null);
+                    await sleep(delayMs);
+                    attempt += 1;
+                    continue;
+                }
+                throw new ChatAdsSDKError("Unexpected error while calling ChatAds", error);
+            }
+        }
+    }
+    logDebug(messageFactory) {
+        if (!this.logger?.debug) {
+            return;
+        }
+        const [msg, payload] = messageFactory();
+        this.logger.debug(msg, payload);
+    }
+}
+function normalizeBaseUrl(raw) {
+    if (!raw) {
+        throw new ChatAdsSDKError("baseUrl is required");
+    }
+    const trimmed = raw.trim().replace(/\/$/, "");
+    try {
+        const url = new URL(trimmed);
+        if (url.protocol !== "https:") {
+            throw new ChatAdsSDKError("baseUrl must start with https://");
+        }
+        return url.toString().replace(/\/$/, "");
+    }
+    catch (error) {
+        throw new ChatAdsSDKError(`Invalid baseUrl: ${raw}`, error);
+    }
+}
+function normalizeEndpoint(raw) {
+    if (!raw.startsWith("/")) {
+        return `/${raw}`;
+    }
+    return raw;
+}
+function buildPayload(payload) {
+    if (!payload || typeof payload.message !== "string" || !payload.message.trim()) {
+        throw new ChatAdsSDKError("payload.message must be a non-empty string");
+    }
+    const normalized = {
+        message: payload.message.trim(),
+    };
+    const extra = payload.extraFields ? { ...payload.extraFields } : {};
+    for (const [key, value] of Object.entries(payload)) {
+        if (key === "message" || key === "extraFields" || value === undefined || value === null) {
+            continue;
+        }
+        normalized[key] = value;
+    }
+    const conflicts = Object.keys(extra).filter((key) => RESERVED_PAYLOAD_KEYS.has(key));
+    if (conflicts.length > 0) {
+        throw new ChatAdsSDKError(`extraFields contains reserved keys: ${conflicts.join(", ")}`);
+    }
+    return { ...normalized, ...extra };
+}
+function normalizeOptionalFields(data) {
+    const normalized = {};
+    for (const [key, value] of Object.entries(data)) {
+        if (value === undefined || value === null) {
+            continue;
+        }
+        if (key === "extraFields") {
+            continue;
+        }
+        const aliasKey = FIELD_ALIASES[key.toLowerCase()] ?? key;
+        normalized[aliasKey] = value;
+    }
+    return normalized;
+}
+async function parseResponse(response) {
+    const text = await response.text();
+    try {
+        return text ? JSON.parse(text) : { success: false, meta: { request_id: "unknown" } };
+    }
+    catch (error) {
+        throw new ChatAdsSDKError("Failed to parse ChatAds response as JSON", error);
+    }
+}
+function computeRetryDelay(backoffFactor, attempt, retryAfter) {
+    const headerDelay = parseRetryAfter(retryAfter);
+    if (headerDelay !== null) {
+        return headerDelay;
+    }
+    if (backoffFactor <= 0) {
+        return 0;
+    }
+    return backoffFactor * 2 ** attempt;
+}
+function parseRetryAfter(value) {
+    if (!value) {
+        return null;
+    }
+    const numeric = Number(value);
+    if (!Number.isNaN(numeric)) {
+        return Math.max(0, numeric * 1000);
+    }
+    const date = Date.parse(value);
+    if (!Number.isNaN(date)) {
+        return Math.max(0, date - Date.now());
+    }
+    return null;
+}
+function sleep(durationMs) {
+    if (durationMs <= 0) {
+        return Promise.resolve();
+    }
+    return new Promise((resolve) => setTimeout(resolve, durationMs));
+}
+function sanitizePayload(body) {
+    return Object.entries(body).reduce((acc, [key, value]) => {
+        if (typeof value === "string") {
+            acc[key] = { type: "string", length: value.length };
+        }
+        else if (typeof value === "number") {
+            acc[key] = { type: "number" };
+        }
+        else if (typeof value === "boolean") {
+            acc[key] = { type: "boolean" };
+        }
+        else if (value === null) {
+            acc[key] = { type: "null" };
+        }
+        else if (value === undefined) {
+            acc[key] = { type: "undefined" };
+        }
+        else {
+            acc[key] = { type: "object" };
+        }
+        return acc;
+    }, {});
+}
+function sanitizeHeaders(headers) {
+    return Object.entries(headers).reduce((acc, [key, value]) => {
+        if (key.toLowerCase() === "x-api-key") {
+            acc[key] = value.slice(0, 4) + "...";
+        }
+        else {
+            acc[key] = value;
+        }
+        return acc;
+    }, {});
+}
+function lowercaseHeaders(headers) {
+    if (!headers) {
+        return {};
+    }
+    return Object.entries(headers).reduce((acc, [key, value]) => {
+        acc[key.toLowerCase()] = value;
+        return acc;
+    }, {});
+}

package/dist/src/errors.d.ts

@@ -0,0 +1,20 @@
+import type { ChatAdsResponseEnvelope } from "./models.js";
+export declare class ChatAdsSDKError extends Error {
+    cause?: unknown;
+    constructor(message: string, cause?: unknown);
+}
+export declare class ChatAdsAPIError extends ChatAdsSDKError {
+    readonly statusCode: number;
+    readonly response: ChatAdsResponseEnvelope | null;
+    readonly headers: Record<string, string>;
+    readonly requestBody?: Record<string, unknown>;
+    readonly url?: string;
+    constructor(params: {
+        statusCode: number;
+        response: ChatAdsResponseEnvelope | null;
+        headers: Record<string, string>;
+        requestBody?: Record<string, unknown>;
+        url?: string;
+    });
+    get retryAfter(): string | null;
+}

package/dist/src/errors.js

@@ -0,0 +1,26 @@
+export class ChatAdsSDKError extends Error {
+    constructor(message, cause) {
+        super(message);
+        this.name = "ChatAdsSDKError";
+        this.cause = cause;
+    }
+}
+export class ChatAdsAPIError extends ChatAdsSDKError {
+    constructor(params) {
+        const { statusCode, response } = params;
+        const baseMessage = response?.error
+            ? `${response.error.code}: ${response.error.message}`
+            : `HTTP ${statusCode}`;
+        super(`ChatAds API error ${statusCode}: ${baseMessage}`);
+        this.name = "ChatAdsAPIError";
+        this.statusCode = statusCode;
+        this.response = response;
+        this.headers = params.headers;
+        this.requestBody = params.requestBody;
+        this.url = params.url;
+    }
+    get retryAfter() {
+        const header = Object.entries(this.headers).find(([key]) => key.toLowerCase() === "retry-after");
+        return header ? header[1] : null;
+    }
+}

package/dist/src/index.d.ts

@@ -0,0 +1,4 @@
+export { ChatAdsClient } from "./client.js";
+export { ChatAdsAPIError, ChatAdsSDKError } from "./errors.js";
+export type { ChatAdsClientOptions, AnalyzeOptions, AnalyzeMessageOptions, } from "./client.js";
+export type { ChatAdsResponseEnvelope, ChatAdsAd, ChatAdsData, ChatAdsError, ChatAdsMeta, UsageInfo, FunctionItemPayload, FunctionItemOptionalFields, } from "./models.js";

package/dist/src/index.js

@@ -0,0 +1,2 @@
+export { ChatAdsClient } from "./client.js";
+export { ChatAdsAPIError, ChatAdsSDKError } from "./errors.js";

package/dist/src/models.d.ts

@@ -0,0 +1,65 @@
+export type FunctionItemOptionalFields = {
+    pageUrl?: string;
+    pageTitle?: string;
+    referrer?: string;
+    address?: string;
+    email?: string;
+    type?: string;
+    domain?: string;
+    userAgent?: string;
+    ip?: string;
+    reason?: string;
+    company?: string;
+    name?: string;
+    country?: string;
+    language?: string;
+    website?: string;
+};
+export type FunctionItemPayload = {
+    message: string;
+    extraFields?: Record<string, unknown>;
+} & FunctionItemOptionalFields;
+export interface ChatAdsAd {
+    product: string;
+    link: string;
+    message: string;
+    category: string;
+}
+export interface ChatAdsData {
+    matched: boolean;
+    ad?: ChatAdsAd | null;
+    reason?: string | null;
+}
+export interface ChatAdsError {
+    code: string;
+    message: string;
+    details?: Record<string, unknown>;
+}
+export interface UsageInfo {
+    monthly_requests: number;
+    free_tier_limit: number;
+    free_tier_remaining: number;
+    is_free_tier: boolean;
+    has_credit_card: boolean;
+    daily_requests?: number | null;
+    daily_limit?: number | null;
+    minute_requests?: number | null;
+    minute_limit?: number | null;
+}
+export interface ChatAdsMeta {
+    request_id: string;
+    user_id?: string | null;
+    country?: string | null;
+    language?: string | null;
+    processing_time_ms?: number | null;
+    usage?: UsageInfo | null;
+    [key: string]: unknown;
+}
+export interface ChatAdsResponseEnvelope {
+    success: boolean;
+    data?: ChatAdsData | null;
+    error?: ChatAdsError | null;
+    meta: ChatAdsMeta;
+    [key: string]: unknown;
+}
+export declare const RESERVED_PAYLOAD_KEYS: ReadonlySet<string>;

package/dist/src/models.js

@@ -0,0 +1,18 @@
+export const RESERVED_PAYLOAD_KEYS = new Set([
+    "message",
+    "pageUrl",
+    "pageTitle",
+    "referrer",
+    "address",
+    "email",
+    "type",
+    "domain",
+    "userAgent",
+    "ip",
+    "reason",
+    "company",
+    "name",
+    "country",
+    "language",
+    "website",
+]);

package/dist/tests/chatads-client.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/chatads-client.test.js

@@ -0,0 +1,7 @@
+import { describe, expect, test } from "vitest";
+import { ChatAdsClient } from "../src/client.js";
+describe("ChatAdsClient", () => {
+    test("throws when baseUrl is missing", () => {
+        expect(() => new ChatAdsClient({ apiKey: "abc", baseUrl: "" })).toThrowError();
+    });
+});

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@chat-ads/chatads-sdk",
+  "version": "0.1.0",
+  "description": "TypeScript/JavaScript client for the ChatAds prospect scoring API",
+  "license": "MIT",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "clean": "rm -rf dist",
+    "lint": "tsc --noEmit && eslint 'src/**/*.ts' 'tests/**/*.ts'",
+    "test": "vitest run"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "chatads",
+    "sdk",
+    "typescript",
+    "javascript",
+    "ads"
+  ],
+  "author": "ChatAds",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Chat-Ads/chatads-typescript-sdk"
+  },
+  "bugs": {
+    "url": "https://github.com/Chat-Ads/chatads-typescript-sdk/issues"
+  },
+  "homepage": "https://github.com/Chat-Ads/chatads-typescript-sdk",
+  "devDependencies": {
+    "@types/node": "22.5.0",
+    "@typescript-eslint/eslint-plugin": "^7.17.0",
+    "@typescript-eslint/parser": "^7.17.0",
+    "eslint": "^8.57.0",
+    "typescript": "^5.5.4",
+    "vitest": "^1.6.0"
+  }
+}