yandex-direct-mcp-plus 1.3.0

package/dist/tools/statistics/tool.js

@@ -0,0 +1,11 @@
+import { defineTool, READ } from "#shared/lib/tool";
+import { handleGetStatistics } from "./handler.js";
+import { getStatisticsSchema } from "./schema.js";
+export const getStatisticsTool = defineTool({
+    name: "get_statistics",
+    title: "Статистика",
+    description: "Статистика кампаний за период: показы, клики, расход (руб), CTR, CPC (ReportService, TSV).",
+    annotations: READ,
+    schema: getStatisticsSchema,
+    handler: handleGetStatistics
+});

package/dist/tools/time-targeting/handler.d.ts

@@ -0,0 +1,6 @@
+import type { z } from "zod";
+import type { getTimeTargetingSchema, setTimeTargetingSchema } from "./schema.js";
+type SetParams = z.infer<typeof setTimeTargetingSchema>;
+export declare function handleSetTimeTargeting(params: SetParams): Promise<string>;
+export declare function handleGetTimeTargeting(params: z.infer<typeof getTimeTargetingSchema>): Promise<string>;
+export {};

package/dist/tools/time-targeting/handler.js

@@ -0,0 +1,124 @@
+import { apiPost } from "#shared/api/client";
+import { WEEKDAYS } from "#shared/config/enums";
+import { HOURS_IN_DAY } from "#shared/config/limits";
+import { formatResult } from "#shared/lib/format";
+import { apiId } from "#shared/lib/id";
+const FIELDS = ["Id", "Name", "TimeZone", "TimeTargeting"];
+// День недели в строке Schedule — число: 1 — понедельник, 7 — воскресенье.
+const DAY_NUMBERS = new Map(WEEKDAYS.map((day, index) => [day, index + 1]));
+// Расписание собирается сразу на все семь дней. Пропустить день нельзя: Директ
+// трактует отсутствующий элемент как «круглосуточно 100%», и «показы только в
+// будни» молча превратилось бы в показы всю неделю.
+function compileSchedule(rules) {
+    const week = WEEKDAYS.map(() => new Array(HOURS_IN_DAY).fill(0));
+    for (const rule of rules) {
+        for (const day of rule.days) {
+            const hours = week[DAY_NUMBERS.get(day) - 1];
+            for (let hour = rule.start_hour; hour < rule.end_hour; hour++)
+                hours[hour] = rule.bid_percent;
+        }
+    }
+    return week.map((hours, index) => [index + 1, ...hours].join(","));
+}
+function buildHolidaysSchedule(params) {
+    const configured = params.suspend_on_holidays !== undefined ||
+        params.holiday_bid_percent !== undefined ||
+        params.holiday_start_hour !== undefined ||
+        params.holiday_end_hour !== undefined;
+    if (!configured)
+        return undefined;
+    const schedule = {
+        SuspendOnHolidays: params.suspend_on_holidays ? "YES" : "NO"
+    };
+    if (params.holiday_bid_percent !== undefined)
+        schedule.BidPercent = params.holiday_bid_percent;
+    if (params.holiday_start_hour !== undefined)
+        schedule.StartHour = params.holiday_start_hour;
+    if (params.holiday_end_hour !== undefined)
+        schedule.EndHour = params.holiday_end_hour;
+    return schedule;
+}
+export async function handleSetTimeTargeting(params) {
+    const timeTargeting = {
+        Schedule: { Items: compileSchedule(params.schedule) },
+        ConsiderWorkingWeekends: params.consider_working_weekends ? "YES" : "NO"
+    };
+    const holidays = buildHolidaysSchedule(params);
+    if (holidays)
+        timeTargeting.HolidaysSchedule = holidays;
+    const campaign = { Id: apiId(params.campaign_id), TimeTargeting: timeTargeting };
+    if (params.time_zone !== undefined)
+        campaign.TimeZone = params.time_zone;
+    return formatResult(await apiPost("campaigns", "update", { Campaigns: [campaign] }));
+}
+// Часы с одинаковым коэффициентом сворачиваются в интервал: 24 числа в строке
+// модель прочитает, но пересказать пользователю «когда идут показы» по ним сложно.
+function toIntervals(hours) {
+    const intervals = [];
+    for (let hour = 0; hour < HOURS_IN_DAY; hour++) {
+        const percent = hours[hour];
+        if (percent === 0)
+            continue;
+        const last = intervals[intervals.length - 1];
+        if (last && last.To === hour && last.BidPercent === percent)
+            last.To = hour + 1;
+        else
+            intervals.push({ From: hour, To: hour + 1, BidPercent: percent });
+    }
+    return intervals;
+}
+function describe(intervals) {
+    if (intervals.length === 0)
+        return "показов нет";
+    if (intervals.length === 1 && intervals[0].From === 0 && intervals[0].To === HOURS_IN_DAY) {
+        return intervals[0].BidPercent === 100 ? "круглосуточно" : `круглосуточно, ${intervals[0].BidPercent}%`;
+    }
+    return intervals
+        .map(({ From, To, BidPercent }) => `${From}–${To}${BidPercent === 100 ? "" : ` (${BidPercent}%)`}`)
+        .join(", ");
+}
+// Отсутствующий в ответе день — круглосуточные показы со 100%: таково правило
+// самого Директа, а не наша догадка. Поэтому неделя заполняется сотнями, и уже
+// поверх ложатся присланные строки.
+function decodeSchedule(items) {
+    const week = WEEKDAYS.map(() => new Array(HOURS_IN_DAY).fill(100));
+    for (const item of Array.isArray(items) ? items : []) {
+        const numbers = String(item)
+            .split(",")
+            .map((part) => Number(part.trim()));
+        const dayNumber = numbers[0];
+        if (!Number.isInteger(dayNumber) || dayNumber < 1 || dayNumber > WEEKDAYS.length)
+            continue;
+        week[dayNumber - 1] = numbers.slice(1, HOURS_IN_DAY + 1).map((percent) => (Number.isFinite(percent) ? percent : 0));
+    }
+    return week.map((hours, index) => {
+        const intervals = toIntervals(hours);
+        return { Day: WEEKDAYS[index], Around: describe(intervals), Intervals: intervals };
+    });
+}
+function scheduleItems(targeting) {
+    const schedule = targeting?.Schedule;
+    if (Array.isArray(schedule))
+        return schedule;
+    return schedule?.Items;
+}
+export async function handleGetTimeTargeting(params) {
+    const data = (await apiPost("campaigns", "get", {
+        SelectionCriteria: { Ids: [apiId(params.campaign_id)] },
+        FieldNames: FIELDS
+    }));
+    const campaign = data?.result?.Campaigns?.[0];
+    if (!campaign)
+        return formatResult(data, { money: false });
+    const items = scheduleItems(campaign.TimeTargeting);
+    const note = items === undefined ? "ℹ️ Расписание не задано: показы идут круглосуточно.\n\n" : "";
+    return (note +
+        formatResult({
+            CampaignId: campaign.Id,
+            Name: campaign.Name,
+            TimeZone: campaign.TimeZone ?? "Europe/Moscow",
+            ConsiderWorkingWeekends: campaign.TimeTargeting?.ConsiderWorkingWeekends === "YES",
+            HolidaysSchedule: campaign.TimeTargeting?.HolidaysSchedule ?? null,
+            Schedule: decodeSchedule(items)
+        }, { money: false }));
+}

package/dist/tools/time-targeting/schema.d.ts

@@ -0,0 +1,19 @@
+import { z } from "zod";
+export declare const getTimeTargetingSchema: z.ZodObject<{
+    campaign_id: z.ZodString;
+}, z.core.$strip>;
+export declare const setTimeTargetingSchema: z.ZodObject<{
+    campaign_id: z.ZodString;
+    schedule: z.ZodArray<z.ZodObject<{
+        days: z.ZodArray<z.ZodLiteral<"FRI" | "MON" | "SAT" | "SUN" | "THU" | "TUE" | "WED">>;
+        start_hour: z.ZodInt;
+        end_hour: z.ZodInt;
+        bid_percent: z.ZodDefault<z.ZodInt>;
+    }, z.core.$strip>>;
+    consider_working_weekends: z.ZodDefault<z.ZodBoolean>;
+    suspend_on_holidays: z.ZodOptional<z.ZodBoolean>;
+    holiday_bid_percent: z.ZodOptional<z.ZodInt>;
+    holiday_start_hour: z.ZodOptional<z.ZodInt>;
+    holiday_end_hour: z.ZodOptional<z.ZodInt>;
+    time_zone: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;

package/dist/tools/time-targeting/schema.js

@@ -0,0 +1,73 @@
+import { z } from "zod";
+import { WEEKDAYS } from "#shared/config/enums";
+import { HOLIDAY_BID_RANGE, HOURLY_BID_RANGE } from "#shared/config/limits";
+import { idField } from "#shared/lib/id";
+export const getTimeTargetingSchema = z.object({
+    campaign_id: idField("ID кампании, десятичная строка")
+});
+// Час — это z.int(), а не z.number().int(): в zod v4 целое есть отдельным типом,
+// и границы задаются проверками, а не цепочкой методов v3.
+const startHour = (description) => z
+    .int()
+    .check(z.gte(0, { error: "Час начала не меньше 0" }), z.lte(23, { error: "Час начала не больше 23" }))
+    .meta({ description });
+const endHour = (description) => z
+    .int()
+    .check(z.gte(1, { error: "Час окончания не меньше 1" }), z.lte(24, { error: "Час окончания не больше 24" }))
+    .meta({ description });
+const bidPercent = (range, description) => z
+    .int()
+    .check(z.gte(range.min, { error: `Коэффициент не меньше ${range.min}%` }), z.lte(range.max, { error: `Коэффициент не больше ${range.max}%` }), z.multipleOf(range.step, { error: `Коэффициент кратен ${range.step}` }))
+    .meta({ description });
+// Наружу расписание задаётся правилами «дни + интервал часов + коэффициент», а не
+// строками из 25 чисел, как в API: собрать такую строку модель обязана без ошибок,
+// а проверить её глазами нельзя. Компиляцию правил в строки делает хендлер.
+const scheduleRule = z
+    .object({
+    days: z
+        .array(z.literal(WEEKDAYS))
+        .check(z.minLength(1, { error: "Укажите хотя бы один день недели" }))
+        .meta({ description: "Дни недели, на которые распространяется правило: MON, TUE, WED, THU, FRI, SAT, SUN" }),
+    start_hour: startHour("Час начала показов включительно, 0–23"),
+    end_hour: endHour("Час окончания показов, не включая его: end_hour=21 — показы идут до 20:59. 1–24"),
+    bid_percent: bidPercent(HOURLY_BID_RANGE, `Коэффициент к ставке в эти часы, % от текущей: ${HOURLY_BID_RANGE.min}–${HOURLY_BID_RANGE.max} с шагом ${HOURLY_BID_RANGE.step}, 100 — без изменений`).default(100)
+})
+    .refine((rule) => rule.end_hour > rule.start_hour, {
+    error: "end_hour должен быть больше start_hour: интервал 9–21 — это start_hour=9, end_hour=21"
+});
+export const setTimeTargetingSchema = z
+    .object({
+    campaign_id: idField("ID кампании, десятичная строка"),
+    schedule: z
+        .array(scheduleRule)
+        .check(z.minLength(1, { error: "Расписание пустое: без единого правила показов не будет вовсе" }))
+        .meta({
+        description: "Правила показов. Часы, не покрытые ни одним правилом, показов не получают — расписание задаётся целиком, а не дополняется. Правила применяются по порядку, последнее переопределяет предыдущие"
+    }),
+    consider_working_weekends: z.boolean().default(true).meta({
+        description: "Показывать ли в рабочие выходные по расписанию переносимого буднего дня; false — по расписанию выходного"
+    }),
+    suspend_on_holidays: z.boolean().optional().meta({
+        description: "true — в праздники показов нет; false — идут по правилам holiday_*. Не задан — праздники отдельно не настраиваются"
+    }),
+    holiday_bid_percent: bidPercent(HOLIDAY_BID_RANGE, `Коэффициент к ставке в праздники, % от текущей: ${HOLIDAY_BID_RANGE.min}–${HOLIDAY_BID_RANGE.max} с шагом ${HOLIDAY_BID_RANGE.step}. Ноль запрещён — показы отключает suspend_on_holidays`).optional(),
+    holiday_start_hour: startHour("Час начала показов в праздники включительно, 0–23").optional(),
+    holiday_end_hour: endHour("Час окончания показов в праздники, не включая его, 1–24").optional(),
+    time_zone: z
+        .string()
+        .check(z.minLength(1, { error: "Часовой пояс не может быть пустым" }))
+        .optional()
+        .meta({
+        description: "Часовой пояс кампании, например Europe/Moscow. Допустимые значения — в справочнике list_time_zones. Не задан — остаётся прежним"
+    })
+})
+    // Директ отклоняет часы и коэффициент праздников при SuspendOnHolidays=YES.
+    // Ловим это схемой: иначе модель отправит взаимоисключающие настройки и получит
+    // ошибку API вместо подсказки.
+    .refine((params) => params.suspend_on_holidays !== true ||
+    (params.holiday_bid_percent === undefined &&
+        params.holiday_start_hour === undefined &&
+        params.holiday_end_hour === undefined), { error: "При suspend_on_holidays=true часы и коэффициент праздников задавать нельзя: показов не будет вовсе" })
+    .refine((params) => params.holiday_start_hour === undefined ||
+    params.holiday_end_hour === undefined ||
+    params.holiday_end_hour > params.holiday_start_hour, { error: "holiday_end_hour должен быть больше holiday_start_hour" });

package/dist/tools/time-targeting/tool.d.ts

@@ -0,0 +1,2 @@
+export declare const getTimeTargetingTool: import("#shared/lib/tool").ToolDescriptor;
+export declare const setTimeTargetingTool: import("#shared/lib/tool").ToolDescriptor;

package/dist/tools/time-targeting/tool.js

@@ -0,0 +1,20 @@
+import { defineTool, IDEMPOTENT, READ } from "#shared/lib/tool";
+import { handleGetTimeTargeting, handleSetTimeTargeting } from "./handler.js";
+import { getTimeTargetingSchema, setTimeTargetingSchema } from "./schema.js";
+export const getTimeTargetingTool = defineTool({
+    name: "get_time_targeting",
+    title: "Расписание показов кампании",
+    description: "Временной таргетинг кампании: часовой пояс, часы показов по дням недели, почасовые коэффициенты и настройка праздников.",
+    annotations: READ,
+    schema: getTimeTargetingSchema,
+    handler: handleGetTimeTargeting
+});
+export const setTimeTargetingTool = defineTool({
+    name: "set_time_targeting",
+    title: "Задать расписание показов",
+    description: "Задать расписание показов кампании: дни, часы, почасовые коэффициенты, праздники и часовой пояс. " +
+        "⚠️ Расписание заменяется целиком: часы вне переданных правил показов не получат.",
+    annotations: IDEMPOTENT,
+    schema: setTimeTargetingSchema,
+    handler: handleSetTimeTargeting
+});

package/dist/tools/vcards/handler.d.ts

@@ -0,0 +1,4 @@
+import type { z } from "zod";
+import type { addVcardSchema, listVcardsSchema } from "./schema.js";
+export declare function handleListVcards(params: z.infer<typeof listVcardsSchema>): Promise<string>;
+export declare function handleAddVcard(params: z.infer<typeof addVcardSchema>): Promise<string>;

package/dist/tools/vcards/handler.js

@@ -0,0 +1,105 @@
+import { apiPost } from "#shared/api/client";
+import { PAGE_MAX_LIMIT } from "#shared/config/limits";
+import { formatResult } from "#shared/lib/format";
+import { apiId, apiIds } from "#shared/lib/id";
+import { buildPage } from "#shared/lib/pagination";
+const NO_MONEY = { money: false };
+const DECIMAL_ID = /^[1-9]\d*$/;
+const VCARD_FIELDS = [
+    "Id",
+    "CampaignId",
+    "Country",
+    "City",
+    "CompanyName",
+    "WorkTime",
+    "Phone",
+    "Street",
+    "House",
+    "Building",
+    "Apartment",
+    "InstantMessenger",
+    "ExtraMessage",
+    "ContactEmail",
+    "Ogrn",
+    "ContactPerson",
+    "MetroStationId"
+];
+// VCardId приезжает строкой (json-bigint) либо числом, если ID короткий.
+// Чистая функция, поэтому проверяется без сети.
+function collectVCardIds(response) {
+    const ids = new Set();
+    for (const ad of response.result?.Ads ?? []) {
+        const value = ad.TextAd?.VCardId;
+        if (typeof value === "string" && DECIMAL_ID.test(value))
+            ids.add(value);
+        if (typeof value === "number" && Number.isSafeInteger(value) && value > 0)
+            ids.add(String(value));
+    }
+    return [...ids];
+}
+async function findVCardIdsByCampaigns(campaignIds) {
+    const response = (await apiPost("ads", "get", {
+        SelectionCriteria: { CampaignIds: apiIds(campaignIds) },
+        FieldNames: ["Id"],
+        TextAdFieldNames: ["VCardId"],
+        Page: { Limit: PAGE_MAX_LIMIT }
+    }));
+    return collectVCardIds(response);
+}
+export async function handleListVcards(params) {
+    const ids = new Set(params.vcard_ids ?? []);
+    if (params.campaign_ids?.length) {
+        for (const id of await findVCardIdsByCampaigns(params.campaign_ids))
+            ids.add(id);
+    }
+    if (ids.size === 0) {
+        // Поиск по кампаниям, не нашедший визиток, — обычный пустой результат, а не ошибка.
+        if (params.campaign_ids?.length)
+            return formatResult({ result: { VCards: [] } }, NO_MONEY);
+        throw new Error("Передайте vcard_ids и/или campaign_ids.");
+    }
+    const request = {
+        SelectionCriteria: { Ids: apiIds([...ids]) },
+        FieldNames: VCARD_FIELDS
+    };
+    const page = buildPage(params);
+    if (page)
+        request.Page = page;
+    return formatResult(await apiPost("vcards", "get", request), NO_MONEY);
+}
+// Необязательные поля визитки: имя параметра → имя поля Директа.
+const OPTIONAL_FIELDS = [
+    ["street", "Street"],
+    ["house", "House"],
+    ["building", "Building"],
+    ["apartment", "Apartment"],
+    ["extra_message", "ExtraMessage"],
+    ["contact_email", "ContactEmail"],
+    ["ogrn", "Ogrn"],
+    ["contact_person", "ContactPerson"]
+];
+export async function handleAddVcard(params) {
+    const phone = {
+        CountryCode: params.phone_country_code,
+        CityCode: params.phone_city_code,
+        PhoneNumber: params.phone_number
+    };
+    if (params.phone_extension !== undefined)
+        phone.Extension = params.phone_extension;
+    const vcard = {
+        CampaignId: apiId(params.campaign_id),
+        Country: params.country,
+        City: params.city,
+        CompanyName: params.company_name,
+        WorkTime: params.work_time,
+        Phone: phone
+    };
+    for (const [source, target] of OPTIONAL_FIELDS) {
+        const value = params[source];
+        if (value !== undefined)
+            vcard[target] = value;
+    }
+    if (params.metro_station_id)
+        vcard.MetroStationId = apiId(params.metro_station_id);
+    return formatResult(await apiPost("vcards", "add", { VCards: [vcard] }), NO_MONEY);
+}

package/dist/tools/vcards/schema.d.ts

@@ -0,0 +1,27 @@
+import { z } from "zod";
+export declare const listVcardsSchema: z.ZodObject<{
+    limit: z.ZodOptional<z.ZodInt>;
+    offset: z.ZodOptional<z.ZodInt>;
+    vcard_ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    campaign_ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export declare const addVcardSchema: z.ZodObject<{
+    campaign_id: z.ZodString;
+    country: z.ZodString;
+    city: z.ZodString;
+    company_name: z.ZodString;
+    work_time: z.ZodString;
+    phone_country_code: z.ZodString;
+    phone_city_code: z.ZodString;
+    phone_number: z.ZodString;
+    phone_extension: z.ZodOptional<z.ZodString>;
+    street: z.ZodOptional<z.ZodString>;
+    house: z.ZodOptional<z.ZodString>;
+    building: z.ZodOptional<z.ZodString>;
+    apartment: z.ZodOptional<z.ZodString>;
+    extra_message: z.ZodOptional<z.ZodString>;
+    contact_email: z.ZodOptional<z.ZodEmail>;
+    ogrn: z.ZodOptional<z.ZodString>;
+    contact_person: z.ZodOptional<z.ZodString>;
+    metro_station_id: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;

package/dist/tools/vcards/schema.js

@@ -0,0 +1,43 @@
+import { z } from "zod";
+import { MAX_CAMPAIGNS_PER_ADJUSTMENT_CALL, MAX_IDS_PER_CALL } from "#shared/config/limits";
+import { idField } from "#shared/lib/id";
+import { pageFields } from "#shared/lib/pagination";
+// Обязательное поле визитки: непустая строка с собственным текстом ошибки.
+const required = (error, description) => z.string().check(z.minLength(1, { error })).meta({ description });
+export const listVcardsSchema = z.object({
+    vcard_ids: z
+        .array(idField("ID визитки"))
+        .check(z.maxLength(MAX_IDS_PER_CALL, { error: `За один вызов допустимо не больше ${MAX_IDS_PER_CALL} визиток` }))
+        .optional()
+        .meta({ description: "Конкретные визитки по их ID" }),
+    campaign_ids: z
+        .array(idField("ID кампании"))
+        .check(z.maxLength(MAX_CAMPAIGNS_PER_ADJUSTMENT_CALL, {
+        error: `За один вызов допустимо не больше ${MAX_CAMPAIGNS_PER_ADJUSTMENT_CALL} кампаний`
+    }))
+        .optional()
+        .meta({ description: "Найти визитки, привязанные к объявлениям этих кампаний" }),
+    ...pageFields
+});
+export const addVcardSchema = z.object({
+    campaign_id: idField("ID кампании, к которой привязывается визитка"),
+    country: required("Страна обязательна", "Страна, например «Россия»"),
+    city: required("Город обязателен", "Город"),
+    company_name: required("Название организации обязательно", "Название организации"),
+    work_time: required("Режим работы обязателен", "Режим работы в формате API: день_с#день_по#час_с#мин_с#час_по#мин_по, например 1#5#9#0#18#0"),
+    phone_country_code: required("Код страны обязателен", "Код страны, «+7»"),
+    phone_city_code: required("Код города обязателен", "Код города или оператора"),
+    phone_number: required("Номер телефона обязателен", "Номер телефона"),
+    phone_extension: z.string().optional().meta({ description: "Добавочный номер" }),
+    street: z.string().optional().meta({ description: "Улица" }),
+    house: z.string().optional().meta({ description: "Дом" }),
+    building: z.string().optional().meta({ description: "Корпус" }),
+    apartment: z.string().optional().meta({ description: "Офис или квартира" }),
+    extra_message: z.string().optional().meta({ description: "Дополнительная информация в визитке" }),
+    contact_email: z.email({ error: "Некорректный адрес электронной почты" }).optional().meta({
+        description: "Контактный адрес электронной почты"
+    }),
+    ogrn: z.string().optional().meta({ description: "ОГРН или ОГРНИП организации" }),
+    contact_person: z.string().optional().meta({ description: "Контактное лицо" }),
+    metro_station_id: idField("ID станции метро из справочника MetroStations").optional()
+});

package/dist/tools/vcards/tool.d.ts

@@ -0,0 +1,2 @@
+export declare const listVcardsTool: import("#shared/lib/tool").ToolDescriptor;
+export declare const addVcardTool: import("#shared/lib/tool").ToolDescriptor;

package/dist/tools/vcards/tool.js

@@ -0,0 +1,19 @@
+import { defineTool, READ, WRITE } from "#shared/lib/tool";
+import { handleAddVcard, handleListVcards } from "./handler.js";
+import { addVcardSchema, listVcardsSchema } from "./schema.js";
+export const listVcardsTool = defineTool({
+    name: "list_vcards",
+    title: "Список визиток",
+    description: "Получить виртуальные визитки по ID или найти их через объявления выбранных кампаний.",
+    annotations: READ,
+    schema: listVcardsSchema,
+    handler: handleListVcards
+});
+export const addVcardTool = defineTool({
+    name: "add_vcard",
+    title: "Создать визитку",
+    description: "Создать виртуальную визитку для кампании.",
+    annotations: WRITE,
+    schema: addVcardSchema,
+    handler: handleAddVcard
+});

package/package.json

@@ -0,0 +1,121 @@
+{
+  "name": "yandex-direct-mcp-plus",
+  "version": "1.3.0",
+  "description": "MCP-сервер для API Яндекс.Директа v5: кампании, объявления, ключевые фразы, ставки, минус-фразы, статистика. Деньги в рублях, ID без потери точности.",
+  "type": "module",
+  "main": "dist/app/index.js",
+  "imports": {
+    "#shared/*": {
+      "types": "./src/shared/*.ts",
+      "development": "./src/shared/*.ts",
+      "default": "./dist/shared/*.js"
+    },
+    "#tools/*": {
+      "types": "./src/tools/*.ts",
+      "development": "./src/tools/*.ts",
+      "default": "./dist/tools/*.js"
+    },
+    "#app/*": {
+      "types": "./src/app/*.ts",
+      "development": "./src/app/*.ts",
+      "default": "./dist/app/*.js"
+    },
+    "#testing/*": {
+      "types": "./src/testing/*.ts",
+      "development": "./src/testing/*.ts",
+      "default": "./dist/testing/*.js"
+    }
+  },
+  "bin": {
+    "yandex-direct-mcp-plus": "dist/app/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "scripts": {
+    "clean": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\"",
+    "build": "npm run clean && tsc -p tsconfig.build.json",
+    "dev": "tsx --env-file-if-exists=.env --conditions=development src/app/index.ts",
+    "probe": "node --env-file-if-exists=.env --import tsx --conditions=development",
+    "start": "node --env-file-if-exists=.env dist/app/index.js",
+    "test": "vitest run --project unit",
+    "test:watch": "vitest --project unit",
+    "test:int": "node --env-file-if-exists=.env ./node_modules/vitest/vitest.mjs run --project int",
+    "prepublishOnly": "npm run build",
+    "typecheck": "tsc --noEmit",
+    "lint": "biome check",
+    "lint:fix": "biome check --write",
+    "lint:dead": "knip",
+    "api:snapshot": "node scripts/wsdl-snapshot.mjs",
+    "prepare": "lefthook install"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.30.0",
+    "json-bigint": "^1.0.0",
+    "zod": "^4.5.4"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.5.12",
+    "@commitlint/cli": "^21.2.2",
+    "@commitlint/config-conventional": "^21.2.2",
+    "@commitlint/types": "^21.2.0",
+    "@semantic-release/changelog": "^7.0.0",
+    "@semantic-release/git": "^11.0.1",
+    "@types/json-bigint": "^1.0.4",
+    "@types/node": "^26.4.1",
+    "@vitest/coverage-v8": "^4.1.11",
+    "knip": "^6.34.0",
+    "lefthook": "^2.1.12",
+    "semantic-release": "^25.0.9",
+    "tsx": "^4.23.13",
+    "typescript": "^7.0.2",
+    "vitest": "^4.1.11"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "mcp",
+    "mcp-server",
+    "model-context-protocol",
+    "modelcontextprotocol",
+    "claude",
+    "ai",
+    "llm",
+    "anthropic",
+    "cursor",
+    "ai-tools",
+    "ai-agent",
+    "russian-api",
+    "yandex",
+    "direct",
+    "advertising",
+    "ppc",
+    "ads",
+    "marketing",
+    "typescript",
+    "yandex-direct",
+    "api"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Pavelsiba/yandex-direct-mcp-plus.git"
+  },
+  "homepage": "https://github.com/Pavelsiba/yandex-direct-mcp-plus#readme",
+  "author": "Pavelsiba (https://github.com/Pavelsiba)",
+  "bugs": {
+    "url": "https://github.com/Pavelsiba/yandex-direct-mcp-plus/issues"
+  },
+  "contributors": [
+    "theYahia (https://github.com/theYahia)",
+    "Maxim DrSeedon (https://github.com/DrSeedon)"
+  ],
+  "allowScripts": {
+    "esbuild@0.28.2": true,
+    "lefthook@2.1.12": true
+  }
+}