yandex-direct-mcp-plus 1.3.0

package/dist/tools/ad-extensions/schema.d.ts

@@ -0,0 +1,14 @@
+import { z } from "zod";
+export declare const listAdExtensionsSchema: z.ZodObject<{
+    limit: z.ZodOptional<z.ZodInt>;
+    offset: z.ZodOptional<z.ZodInt>;
+    ad_extension_ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    states: z.ZodOptional<z.ZodArray<z.ZodLiteral<"DELETED" | "ON">>>;
+    statuses: z.ZodOptional<z.ZodArray<z.ZodLiteral<"ACCEPTED" | "DRAFT" | "MODERATION" | "REJECTED">>>;
+}, z.core.$strip>;
+export declare const addAdExtensionsSchema: z.ZodObject<{
+    callouts: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export declare const deleteAdExtensionsSchema: z.ZodObject<{
+    ad_extension_ids: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;

package/dist/tools/ad-extensions/schema.js

@@ -0,0 +1,37 @@
+// Уточнения (Callout) — единственный тип расширений, который покрывает сервер.
+import { z } from "zod";
+import { AD_EXTENSION_STATES, AD_EXTENSION_STATUSES } from "#shared/config/enums";
+import { CALLOUT_TEXT_MAX, MAX_CALLOUTS_PER_CALL, MAX_IDS_PER_CALL } from "#shared/config/limits";
+import { idField } from "#shared/lib/id";
+import { pageFields } from "#shared/lib/pagination";
+export const listAdExtensionsSchema = z.object({
+    ad_extension_ids: z
+        .array(idField("ID уточнения"))
+        .check(z.maxLength(MAX_IDS_PER_CALL, { error: `За один вызов допустимо не больше ${MAX_IDS_PER_CALL} уточнений` }))
+        .optional()
+        .meta({ description: "Конкретные уточнения; без них возвращаются все" }),
+    states: z.array(z.literal(AD_EXTENSION_STATES)).optional().meta({ description: "Фильтр по состоянию уточнения" }),
+    statuses: z
+        .array(z.literal(AD_EXTENSION_STATUSES))
+        .optional()
+        .meta({ description: "Фильтр по статусу модерации уточнения" }),
+    ...pageFields
+});
+export const addAdExtensionsSchema = z.object({
+    callouts: z
+        .array(z
+        .string()
+        .check(z.minLength(1, { error: "Текст уточнения не может быть пустым" }), z.maxLength(CALLOUT_TEXT_MAX, { error: `Текст уточнения длиннее ${CALLOUT_TEXT_MAX} символов` })))
+        .check(z.minLength(1, { error: "Список уточнений пуст" }), z.maxLength(MAX_CALLOUTS_PER_CALL, {
+        error: `За один вызов допустимо не больше ${MAX_CALLOUTS_PER_CALL} уточнений`
+    }))
+        .meta({ description: `Тексты уточнений, каждый до ${CALLOUT_TEXT_MAX} символов` })
+});
+export const deleteAdExtensionsSchema = z.object({
+    ad_extension_ids: z
+        .array(idField("ID уточнения"))
+        .check(z.minLength(1, { error: "Список уточнений пуст" }), z.maxLength(MAX_CALLOUTS_PER_CALL, {
+        error: `За один вызов допустимо не больше ${MAX_CALLOUTS_PER_CALL} уточнений`
+    }))
+        .meta({ description: "Уточнения, которые будут удалены безвозвратно" })
+});

package/dist/tools/ad-extensions/tool.d.ts

@@ -0,0 +1,3 @@
+export declare const listAdExtensionsTool: import("#shared/lib/tool").ToolDescriptor;
+export declare const addAdExtensionsTool: import("#shared/lib/tool").ToolDescriptor;
+export declare const deleteAdExtensionsTool: import("#shared/lib/tool").ToolDescriptor;

package/dist/tools/ad-extensions/tool.js

@@ -0,0 +1,27 @@
+import { DESTRUCTIVE, defineTool, READ, WRITE } from "#shared/lib/tool";
+import { handleAddAdExtensions, handleDeleteAdExtensions, handleListAdExtensions } from "./handler.js";
+import { addAdExtensionsSchema, deleteAdExtensionsSchema, listAdExtensionsSchema } from "./schema.js";
+export const listAdExtensionsTool = defineTool({
+    name: "list_ad_extensions",
+    title: "Список уточнений",
+    description: "Получить уточнения (callouts) с их статусами и текстом.",
+    annotations: READ,
+    schema: listAdExtensionsSchema,
+    handler: handleListAdExtensions
+});
+export const addAdExtensionsTool = defineTool({
+    name: "add_ad_extensions",
+    title: "Создать уточнения",
+    description: "Создать уточнения (callouts), каждый текст до 25 символов.",
+    annotations: WRITE,
+    schema: addAdExtensionsSchema,
+    handler: handleAddAdExtensions
+});
+export const deleteAdExtensionsTool = defineTool({
+    name: "delete_ad_extensions",
+    title: "Удалить уточнения",
+    description: "Удалить уточнения по ID. ⚠️ Необратимо.",
+    annotations: DESTRUCTIVE,
+    schema: deleteAdExtensionsSchema,
+    handler: handleDeleteAdExtensions
+});

package/dist/tools/ad-groups/handler.d.ts

@@ -0,0 +1,5 @@
+import type { z } from "zod";
+import type { createAdGroupSchema, deleteAdGroupsSchema, listAdGroupsSchema } from "./schema.js";
+export declare function handleListAdGroups(params: z.infer<typeof listAdGroupsSchema>): Promise<string>;
+export declare function handleCreateAdGroup(params: z.infer<typeof createAdGroupSchema>): Promise<string>;
+export declare function handleDeleteAdGroups(params: z.infer<typeof deleteAdGroupsSchema>): Promise<string>;

package/dist/tools/ad-groups/handler.js

@@ -0,0 +1,33 @@
+import { apiPost } from "#shared/api/client";
+import { formatResult } from "#shared/lib/format";
+import { apiId, apiIds } from "#shared/lib/id";
+import { buildPage } from "#shared/lib/pagination";
+const LIST_FIELDS = ["Id", "Name", "CampaignId", "RegionIds", "Status", "Type"];
+export async function handleListAdGroups(params) {
+    const requestParams = {
+        SelectionCriteria: { CampaignIds: apiIds(params.campaign_ids) },
+        FieldNames: LIST_FIELDS
+    };
+    const page = buildPage(params);
+    if (page)
+        requestParams.Page = page;
+    return formatResult(await apiPost("adgroups", "get", requestParams));
+}
+export async function handleCreateAdGroup(params) {
+    const data = await apiPost("adgroups", "add", {
+        AdGroups: [
+            {
+                Name: params.name,
+                CampaignId: apiId(params.campaign_id),
+                RegionIds: apiIds(params.region_ids)
+            }
+        ]
+    });
+    return formatResult(data);
+}
+export async function handleDeleteAdGroups(params) {
+    const data = await apiPost("adgroups", "delete", {
+        SelectionCriteria: { Ids: apiIds(params.ad_group_ids) }
+    });
+    return formatResult(data);
+}

package/dist/tools/ad-groups/schema.d.ts

@@ -0,0 +1,14 @@
+import { z } from "zod";
+export declare const listAdGroupsSchema: z.ZodObject<{
+    limit: z.ZodOptional<z.ZodInt>;
+    offset: z.ZodOptional<z.ZodInt>;
+    campaign_ids: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export declare const createAdGroupSchema: z.ZodObject<{
+    campaign_id: z.ZodString;
+    name: z.ZodString;
+    region_ids: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export declare const deleteAdGroupsSchema: z.ZodObject<{
+    ad_group_ids: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;

package/dist/tools/ad-groups/schema.js

@@ -0,0 +1,27 @@
+import { z } from "zod";
+import { idField } from "#shared/lib/id";
+import { pageFields } from "#shared/lib/pagination";
+export const listAdGroupsSchema = z.object({
+    campaign_ids: z
+        .array(idField("ID кампании, десятичная строка"))
+        .check(z.minLength(1, { error: "Укажите хотя бы одну кампанию" }))
+        .meta({ description: "Кампании, группы которых нужно выбрать" }),
+    ...pageFields
+});
+export const createAdGroupSchema = z.object({
+    campaign_id: idField("ID кампании, в которой создаётся группа"),
+    name: z
+        .string()
+        .check(z.minLength(1, { error: "Название не может быть пустым" }))
+        .meta({ description: "Название группы" }),
+    region_ids: z
+        .array(idField("ID региона показа"))
+        .check(z.minLength(1, { error: "Укажите хотя бы один регион" }))
+        .meta({ description: 'Регионы показа, например ["225"] — Россия. Коды берутся из get_regions' })
+});
+export const deleteAdGroupsSchema = z.object({
+    ad_group_ids: z
+        .array(idField("ID группы объявлений"))
+        .check(z.minLength(1, { error: "Список групп пуст" }))
+        .meta({ description: "Группы, которые будут удалены безвозвратно" })
+});

package/dist/tools/ad-groups/tool.d.ts

@@ -0,0 +1,3 @@
+export declare const listAdGroupsTool: import("#shared/lib/tool").ToolDescriptor;
+export declare const createAdGroupTool: import("#shared/lib/tool").ToolDescriptor;
+export declare const deleteAdGroupsTool: import("#shared/lib/tool").ToolDescriptor;

package/dist/tools/ad-groups/tool.js

@@ -0,0 +1,27 @@
+import { DESTRUCTIVE, defineTool, READ, WRITE } from "#shared/lib/tool";
+import { handleCreateAdGroup, handleDeleteAdGroups, handleListAdGroups } from "./handler.js";
+import { createAdGroupSchema, deleteAdGroupsSchema, listAdGroupsSchema } from "./schema.js";
+export const listAdGroupsTool = defineTool({
+    name: "list_ad_groups",
+    title: "Список групп",
+    description: "Группы объявлений выбранных кампаний: названия, регионы, статусы.",
+    annotations: READ,
+    schema: listAdGroupsSchema,
+    handler: handleListAdGroups
+});
+export const createAdGroupTool = defineTool({
+    name: "create_ad_group",
+    title: "Создать группу",
+    description: "Создать группу объявлений в кампании с таргетингом по регионам (см. get_regions).",
+    annotations: WRITE,
+    schema: createAdGroupSchema,
+    handler: handleCreateAdGroup
+});
+export const deleteAdGroupsTool = defineTool({
+    name: "delete_ad_groups",
+    title: "Удалить группы",
+    description: "Удалить группы объявлений по их ID. ⚠️ Необратимо.",
+    annotations: DESTRUCTIVE,
+    schema: deleteAdGroupsSchema,
+    handler: handleDeleteAdGroups
+});

package/dist/tools/ad-images/handler.d.ts

@@ -0,0 +1,5 @@
+import type { z } from "zod";
+import type { manageAdImagesSchema } from "./schema.js";
+type Params = z.infer<typeof manageAdImagesSchema>;
+export declare function handleManageAdImages(params: Params): Promise<string>;
+export {};

package/dist/tools/ad-images/handler.js

@@ -0,0 +1,47 @@
+import { apiPost } from "#shared/api/client";
+import { formatResult } from "#shared/lib/format";
+import { buildPage } from "#shared/lib/pagination";
+const NO_MONEY = { money: false };
+const GET_FIELDS = ["AdImageHash", "OriginalUrl", "PreviewUrl", "Name", "Type", "Subtype", "Associated"];
+async function addImages(params) {
+    if (!params.images?.length)
+        throw new Error("Для action=add передайте images.");
+    const data = await apiPost("adimages", "add", {
+        AdImages: params.images.map((image) => {
+            const item = { ImageData: image.image_data, Name: image.name };
+            if (image.type)
+                item.Type = image.type;
+            return item;
+        })
+    });
+    return formatResult(data, NO_MONEY);
+}
+async function deleteImages(params) {
+    if (!params.ad_image_hashes?.length)
+        throw new Error("Для action=delete передайте ad_image_hashes.");
+    const data = await apiPost("adimages", "delete", {
+        SelectionCriteria: { AdImageHashes: params.ad_image_hashes }
+    });
+    return formatResult(data, NO_MONEY);
+}
+async function getImages(params) {
+    const selection = {};
+    if (params.ad_image_hashes?.length)
+        selection.AdImageHashes = params.ad_image_hashes;
+    if (params.associated)
+        selection.Associated = params.associated;
+    const request = { FieldNames: GET_FIELDS };
+    if (Object.keys(selection).length > 0)
+        request.SelectionCriteria = selection;
+    const page = buildPage(params);
+    if (page)
+        request.Page = page;
+    return formatResult(await apiPost("adimages", "get", request), NO_MONEY);
+}
+export async function handleManageAdImages(params) {
+    if (params.action === "add")
+        return addImages(params);
+    if (params.action === "delete")
+        return deleteImages(params);
+    return getImages(params);
+}

package/dist/tools/ad-images/schema.d.ts

@@ -0,0 +1,13 @@
+import { z } from "zod";
+export declare const manageAdImagesSchema: z.ZodObject<{
+    limit: z.ZodOptional<z.ZodInt>;
+    offset: z.ZodOptional<z.ZodInt>;
+    action: z.ZodLiteral<"add" | "delete" | "get">;
+    images: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        image_data: z.ZodString;
+        name: z.ZodString;
+        type: z.ZodOptional<z.ZodLiteral<"AUTO" | "FIXED_IMAGE" | "REGULAR" | "WIDE">>;
+    }, z.core.$strip>>>;
+    ad_image_hashes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    associated: z.ZodOptional<z.ZodLiteral<"NO" | "YES">>;
+}, z.core.$strip>;

package/dist/tools/ad-images/schema.js

@@ -0,0 +1,37 @@
+import { z } from "zod";
+import { AD_IMAGE_ACTIONS, AD_IMAGE_TYPES, ASSOCIATED_FLAGS } from "#shared/config/enums";
+import { AD_IMAGE_NAME_MAX, MAX_IDS_PER_CALL, MAX_IMAGES_PER_CALL } from "#shared/config/limits";
+import { pageFields } from "#shared/lib/pagination";
+// Изображение адресуется хешем, а не числовым ID: idField здесь неприменим.
+const adImageHash = z.string().check(z.minLength(1, { error: "Хеш изображения не может быть пустым" }));
+const adImage = z.object({
+    image_data: z
+        .string()
+        .check(z.minLength(1, { error: "Данные изображения не могут быть пустыми" }))
+        .meta({ description: "Содержимое файла изображения в base64" }),
+    name: z
+        .string()
+        .check(z.minLength(1, { error: "Название не может быть пустым" }), z.maxLength(AD_IMAGE_NAME_MAX, { error: `Название длиннее ${AD_IMAGE_NAME_MAX} символов` }))
+        .meta({ description: "Название изображения в интерфейсе" }),
+    type: z.literal(AD_IMAGE_TYPES).optional().meta({ description: "Тип изображения; AUTO определяет его по размеру" })
+});
+export const manageAdImagesSchema = z.object({
+    action: z.literal(AD_IMAGE_ACTIONS).meta({ description: "Что сделать: add, get или delete (необратимо)" }),
+    images: z
+        .array(adImage)
+        .check(z.minLength(1, { error: "Список изображений пуст" }), z.maxLength(MAX_IMAGES_PER_CALL, {
+        error: `За один вызов допустимо не больше ${MAX_IMAGES_PER_CALL} изображений`
+    }))
+        .optional()
+        .meta({ description: "Изображения для загрузки; обязателен при action=add" }),
+    ad_image_hashes: z
+        .array(adImageHash)
+        .check(z.minLength(1, { error: "Список хешей пуст" }), z.maxLength(MAX_IDS_PER_CALL, { error: `За один вызов допустимо не больше ${MAX_IDS_PER_CALL} хешей` }))
+        .optional()
+        .meta({ description: "Хеши изображений: фильтр при action=get, обязателен при action=delete" }),
+    associated: z
+        .literal(ASSOCIATED_FLAGS)
+        .optional()
+        .meta({ description: "Фильтр при action=get: YES — только привязанные к объявлениям, NO — только свободные" }),
+    ...pageFields
+});

package/dist/tools/ad-images/tool.d.ts

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

package/dist/tools/ad-images/tool.js

@@ -0,0 +1,11 @@
+import { DESTRUCTIVE, defineTool } from "#shared/lib/tool";
+import { handleManageAdImages } from "./handler.js";
+import { manageAdImagesSchema } from "./schema.js";
+export const manageAdImagesTool = defineTool({
+    name: "manage_ad_images",
+    title: "Управление изображениями",
+    description: "Загрузить, получить или удалить изображения объявлений (AdImages). Для add данные передаются в base64.",
+    annotations: DESTRUCTIVE,
+    schema: manageAdImagesSchema,
+    handler: handleManageAdImages
+});

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

@@ -0,0 +1,7 @@
+import type { z } from "zod";
+import type { createTextAdSchema, listAdsSchema, manageAdsSchema, moderateAdsSchema, updateTextAdSchema } from "./schema.js";
+export declare function handleListAds(params: z.infer<typeof listAdsSchema>): Promise<string>;
+export declare function handleCreateTextAd(params: z.infer<typeof createTextAdSchema>): Promise<string>;
+export declare function handleUpdateTextAd(params: z.infer<typeof updateTextAdSchema>): Promise<string>;
+export declare function handleManageAds(params: z.infer<typeof manageAdsSchema>): Promise<string>;
+export declare function handleModerateAds(params: z.infer<typeof moderateAdsSchema>): Promise<string>;

package/dist/tools/ads/handler.js

@@ -0,0 +1,54 @@
+import { apiPost } from "#shared/api/client";
+import { formatResult } from "#shared/lib/format";
+import { apiId, apiIds } from "#shared/lib/id";
+import { buildPage } from "#shared/lib/pagination";
+const LIST_FIELDS = ["Id", "CampaignId", "AdGroupId", "State", "Status"];
+const TEXT_AD_FIELDS = ["Title", "Title2", "Text", "Href", "DisplayDomain"];
+export async function handleListAds(params) {
+    const requestParams = {
+        SelectionCriteria: { AdGroupIds: apiIds(params.ad_group_ids) },
+        FieldNames: LIST_FIELDS,
+        TextAdFieldNames: TEXT_AD_FIELDS
+    };
+    const page = buildPage(params);
+    if (page)
+        requestParams.Page = page;
+    return formatResult(await apiPost("ads", "get", requestParams));
+}
+export async function handleCreateTextAd(params) {
+    const textAd = { Title: params.title, Text: params.text, Href: params.href };
+    if (params.title2)
+        textAd.Title2 = params.title2;
+    const data = await apiPost("ads", "add", {
+        Ads: [{ AdGroupId: apiId(params.ad_group_id), TextAd: textAd }]
+    });
+    return formatResult(data);
+}
+export async function handleUpdateTextAd(params) {
+    const textAd = {};
+    if (params.title !== undefined)
+        textAd.Title = params.title;
+    if (params.title2 !== undefined)
+        textAd.Title2 = params.title2;
+    if (params.text !== undefined)
+        textAd.Text = params.text;
+    if (params.href !== undefined)
+        textAd.Href = params.href;
+    if (Object.keys(textAd).length === 0) {
+        throw new Error("Нечего обновлять: укажите хотя бы одно из title/title2/text/href.");
+    }
+    const data = await apiPost("ads", "update", { Ads: [{ Id: apiId(params.ad_id), TextAd: textAd }] });
+    return formatResult(data);
+}
+export async function handleManageAds(params) {
+    const data = await apiPost("ads", params.action, {
+        SelectionCriteria: { Ids: apiIds(params.ad_ids) }
+    });
+    return formatResult(data);
+}
+export async function handleModerateAds(params) {
+    const data = await apiPost("ads", "moderate", {
+        SelectionCriteria: { Ids: apiIds(params.ad_ids) }
+    });
+    return formatResult(data);
+}

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

@@ -0,0 +1,27 @@
+import { z } from "zod";
+export declare const listAdsSchema: z.ZodObject<{
+    limit: z.ZodOptional<z.ZodInt>;
+    offset: z.ZodOptional<z.ZodInt>;
+    ad_group_ids: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export declare const createTextAdSchema: z.ZodObject<{
+    ad_group_id: z.ZodString;
+    title: z.ZodString;
+    title2: z.ZodOptional<z.ZodString>;
+    text: z.ZodString;
+    href: z.ZodString;
+}, z.core.$strip>;
+export declare const updateTextAdSchema: z.ZodObject<{
+    ad_id: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    title2: z.ZodOptional<z.ZodString>;
+    text: z.ZodOptional<z.ZodString>;
+    href: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const manageAdsSchema: z.ZodObject<{
+    ad_ids: z.ZodArray<z.ZodString>;
+    action: z.ZodLiteral<"archive" | "delete" | "moderate" | "resume" | "suspend" | "unarchive">;
+}, z.core.$strip>;
+export declare const moderateAdsSchema: z.ZodObject<{
+    ad_ids: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;

package/dist/tools/ads/schema.js

@@ -0,0 +1,68 @@
+import { z } from "zod";
+import { AD_ACTIONS } from "#shared/config/enums";
+import { AD_TEXT_LIMITS, MAX_ADS_PER_MODERATION } from "#shared/config/limits";
+import { idField } from "#shared/lib/id";
+import { pageFields } from "#shared/lib/pagination";
+export const listAdsSchema = z.object({
+    ad_group_ids: z
+        .array(idField("ID группы объявлений"))
+        .check(z.minLength(1, { error: "Укажите хотя бы одну группу" }))
+        .meta({ description: "Группы, объявления которых нужно выбрать" }),
+    ...pageFields
+});
+export const createTextAdSchema = z.object({
+    ad_group_id: idField("ID группы, в которой создаётся объявление"),
+    title: z
+        .string()
+        .check(z.minLength(1, { error: "Заголовок не может быть пустым" }), z.maxLength(AD_TEXT_LIMITS.title, { error: `Заголовок длиннее ${AD_TEXT_LIMITS.title} символов` }))
+        .meta({ description: `Заголовок объявления, до ${AD_TEXT_LIMITS.title} символов` }),
+    title2: z
+        .string()
+        .check(z.maxLength(AD_TEXT_LIMITS.title2, { error: `Второй заголовок длиннее ${AD_TEXT_LIMITS.title2} символов` }))
+        .optional()
+        .meta({ description: `Второй заголовок, до ${AD_TEXT_LIMITS.title2} символов` }),
+    text: z
+        .string()
+        .check(z.minLength(1, { error: "Текст не может быть пустым" }), z.maxLength(AD_TEXT_LIMITS.text, { error: `Текст длиннее ${AD_TEXT_LIMITS.text} символов` }))
+        .meta({ description: `Текст объявления, до ${AD_TEXT_LIMITS.text} символов` }),
+    href: z
+        .string()
+        .check(z.minLength(1, { error: "Ссылка не может быть пустой" }))
+        .meta({ description: "Ссылка на сайт" })
+});
+export const updateTextAdSchema = z.object({
+    ad_id: idField("ID обновляемого объявления"),
+    title: z
+        .string()
+        .check(z.maxLength(AD_TEXT_LIMITS.title, { error: `Заголовок длиннее ${AD_TEXT_LIMITS.title} символов` }))
+        .optional()
+        .meta({ description: "Новый заголовок" }),
+    title2: z
+        .string()
+        .check(z.maxLength(AD_TEXT_LIMITS.title2, { error: `Второй заголовок длиннее ${AD_TEXT_LIMITS.title2} символов` }))
+        .optional()
+        .meta({ description: "Новый второй заголовок" }),
+    text: z
+        .string()
+        .check(z.maxLength(AD_TEXT_LIMITS.text, { error: `Текст длиннее ${AD_TEXT_LIMITS.text} символов` }))
+        .optional()
+        .meta({ description: "Новый текст объявления" }),
+    href: z.string().optional().meta({ description: "Новая ссылка на сайт" })
+});
+export const manageAdsSchema = z.object({
+    ad_ids: z
+        .array(idField("ID объявления"))
+        .check(z.minLength(1, { error: "Список объявлений пуст" }))
+        .meta({ description: "Объявления, над которыми выполняется действие" }),
+    action: z.literal(AD_ACTIONS).meta({
+        description: "Действие: suspend, resume, archive, unarchive, moderate или delete (необратимо)"
+    })
+});
+export const moderateAdsSchema = z.object({
+    ad_ids: z
+        .array(idField("ID объявления"))
+        .check(z.minLength(1, { error: "Список объявлений пуст" }), z.maxLength(MAX_ADS_PER_MODERATION, {
+        error: `За один вызов допустимо не больше ${MAX_ADS_PER_MODERATION} объявлений`
+    }))
+        .meta({ description: "Объявления, отправляемые на модерацию" })
+});

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

@@ -0,0 +1,5 @@
+export declare const listAdsTool: import("#shared/lib/tool").ToolDescriptor;
+export declare const createTextAdTool: import("#shared/lib/tool").ToolDescriptor;
+export declare const updateTextAdTool: import("#shared/lib/tool").ToolDescriptor;
+export declare const manageAdsTool: import("#shared/lib/tool").ToolDescriptor;
+export declare const moderateAdsTool: import("#shared/lib/tool").ToolDescriptor;

package/dist/tools/ads/tool.js

@@ -0,0 +1,43 @@
+import { DESTRUCTIVE, defineTool, IDEMPOTENT, READ, WRITE } from "#shared/lib/tool";
+import { handleCreateTextAd, handleListAds, handleManageAds, handleModerateAds, handleUpdateTextAd } from "./handler.js";
+import { createTextAdSchema, listAdsSchema, manageAdsSchema, moderateAdsSchema, updateTextAdSchema } from "./schema.js";
+export const listAdsTool = defineTool({
+    name: "list_ads",
+    title: "Список объявлений",
+    description: "Объявления в группах: заголовки, тексты, ссылки, статусы.",
+    annotations: READ,
+    schema: listAdsSchema,
+    handler: handleListAds
+});
+export const createTextAdTool = defineTool({
+    name: "create_text_ad",
+    title: "Создать объявление",
+    description: "Создать текстовое объявление: заголовок (≤56), второй заголовок (≤30), текст (≤81), ссылка.",
+    annotations: WRITE,
+    schema: createTextAdSchema,
+    handler: handleCreateTextAd
+});
+export const updateTextAdTool = defineTool({
+    name: "update_text_ad",
+    title: "Обновить объявление",
+    description: "Обновить текстовое объявление: заголовок, текст, ссылка. Изменённое объявление уходит на модерацию.",
+    annotations: IDEMPOTENT,
+    schema: updateTextAdSchema,
+    handler: handleUpdateTextAd
+});
+export const manageAdsTool = defineTool({
+    name: "manage_ads",
+    title: "Управление объявлениями",
+    description: "Действие над объявлениями: suspend/resume/archive/unarchive/moderate/delete. ⚠️ delete необратимо.",
+    annotations: DESTRUCTIVE,
+    schema: manageAdsSchema,
+    handler: handleManageAds
+});
+export const moderateAdsTool = defineTool({
+    name: "moderate_ads",
+    title: "Отправить объявления на модерацию",
+    description: "Отправить выбранные объявления на модерацию.",
+    annotations: IDEMPOTENT,
+    schema: moderateAdsSchema,
+    handler: handleModerateAds
+});

package/dist/tools/audience-targets/handler.d.ts

@@ -0,0 +1,6 @@
+import type { z } from "zod";
+import type { listAudienceTargetsSchema, setAudienceTargetsSchema } from "./schema.js";
+type Params = z.infer<typeof setAudienceTargetsSchema>;
+export declare function handleListAudienceTargets(params: z.infer<typeof listAudienceTargetsSchema>): Promise<string>;
+export declare function handleSetAudienceTargets(params: Params): Promise<string>;
+export {};

package/dist/tools/audience-targets/handler.js

@@ -0,0 +1,96 @@
+import { apiPost } from "#shared/api/client";
+import { formatResult } from "#shared/lib/format";
+import { apiId, apiIds } from "#shared/lib/id";
+import { buildPage } from "#shared/lib/pagination";
+const LIST_FIELDS = [
+    "Id",
+    "AdGroupId",
+    "CampaignId",
+    "RetargetingListId",
+    "InterestId",
+    "ContextBid",
+    "StrategyPriority",
+    "State"
+];
+export async function handleListAudienceTargets(params) {
+    const selection = {};
+    if (params.audience_target_ids?.length)
+        selection.Ids = apiIds(params.audience_target_ids);
+    if (params.ad_group_ids?.length)
+        selection.AdGroupIds = apiIds(params.ad_group_ids);
+    if (params.campaign_ids?.length)
+        selection.CampaignIds = apiIds(params.campaign_ids);
+    if (params.retargeting_list_ids?.length)
+        selection.RetargetingListIds = apiIds(params.retargeting_list_ids);
+    if (params.interest_ids?.length)
+        selection.InterestIds = apiIds(params.interest_ids);
+    if (params.states?.length)
+        selection.States = params.states;
+    // States сам по себе выборку не задаёт: Директ требует хотя бы один фильтр по ID.
+    if (!Object.keys(selection).some((key) => key !== "States")) {
+        throw new Error("Укажите хотя бы один фильтр ID для list_audience_targets.");
+    }
+    const request = { SelectionCriteria: selection, FieldNames: LIST_FIELDS };
+    const page = buildPage(params);
+    if (page)
+        request.Page = page;
+    return formatResult(await apiPost("audiencetargets", "get", request));
+}
+function buildTarget(target) {
+    const sources = [target.retargeting_list_id, target.interest_id].filter(Boolean);
+    if (sources.length !== 1) {
+        throw new Error("Каждая цель должна содержать ровно одно из retargeting_list_id/interest_id.");
+    }
+    const item = { AdGroupId: apiId(target.ad_group_id) };
+    if (target.retargeting_list_id)
+        item.RetargetingListId = apiId(target.retargeting_list_id);
+    if (target.interest_id)
+        item.InterestId = apiId(target.interest_id);
+    if (target.context_bid !== undefined)
+        item.ContextBid = target.context_bid;
+    if (target.strategy_priority)
+        item.StrategyPriority = target.strategy_priority;
+    return item;
+}
+function buildBid(bid) {
+    const selectors = [bid.audience_target_id, bid.ad_group_id, bid.campaign_id].filter(Boolean);
+    if (selectors.length !== 1) {
+        throw new Error("Каждая ставка должна содержать ровно один ID цели, группы или кампании.");
+    }
+    if (bid.context_bid === undefined && bid.strategy_priority === undefined) {
+        throw new Error("Для каждой ставки укажите context_bid и/или strategy_priority.");
+    }
+    const item = {};
+    if (bid.audience_target_id)
+        item.Id = apiId(bid.audience_target_id);
+    if (bid.ad_group_id)
+        item.AdGroupId = apiId(bid.ad_group_id);
+    if (bid.campaign_id)
+        item.CampaignId = apiId(bid.campaign_id);
+    if (bid.context_bid !== undefined)
+        item.ContextBid = bid.context_bid;
+    if (bid.strategy_priority)
+        item.StrategyPriority = bid.strategy_priority;
+    return item;
+}
+export async function handleSetAudienceTargets(params) {
+    if (params.action === "add") {
+        if (!params.targets?.length)
+            throw new Error("Для action=add передайте targets.");
+        const targets = params.targets.map(buildTarget);
+        return formatResult(await apiPost("audiencetargets", "add", { AudienceTargets: targets }));
+    }
+    if (params.action === "set_bids") {
+        if (!params.bids?.length)
+            throw new Error("Для action=set_bids передайте bids.");
+        const bids = params.bids.map(buildBid);
+        return formatResult(await apiPost("audiencetargets", "setBids", { Bids: bids }));
+    }
+    if (!params.audience_target_ids?.length) {
+        throw new Error(`Для action=${params.action} передайте audience_target_ids.`);
+    }
+    const data = await apiPost("audiencetargets", params.action, {
+        SelectionCriteria: { Ids: apiIds(params.audience_target_ids) }
+    });
+    return formatResult(data);
+}