yandex-direct-mcp-plus 1.3.0

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

@@ -0,0 +1,29 @@
+import { z } from "zod";
+export declare const listAudienceTargetsSchema: z.ZodObject<{
+    limit: z.ZodOptional<z.ZodInt>;
+    offset: z.ZodOptional<z.ZodInt>;
+    audience_target_ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    ad_group_ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    campaign_ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    retargeting_list_ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    interest_ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    states: z.ZodOptional<z.ZodArray<z.ZodLiteral<"ON" | "SUSPENDED">>>;
+}, z.core.$strip>;
+export declare const setAudienceTargetsSchema: z.ZodObject<{
+    action: z.ZodLiteral<"add" | "delete" | "resume" | "set_bids" | "suspend">;
+    targets: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        ad_group_id: z.ZodString;
+        retargeting_list_id: z.ZodOptional<z.ZodString>;
+        interest_id: z.ZodOptional<z.ZodString>;
+        context_bid: z.ZodOptional<z.ZodPipe<z.ZodNumber, z.ZodTransform<number, number>>>;
+        strategy_priority: z.ZodOptional<z.ZodLiteral<"HIGH" | "LOW" | "NORMAL">>;
+    }, z.core.$strip>>>;
+    bids: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        audience_target_id: z.ZodOptional<z.ZodString>;
+        ad_group_id: z.ZodOptional<z.ZodString>;
+        campaign_id: z.ZodOptional<z.ZodString>;
+        context_bid: z.ZodOptional<z.ZodPipe<z.ZodNumber, z.ZodTransform<number, number>>>;
+        strategy_priority: z.ZodOptional<z.ZodLiteral<"HIGH" | "LOW" | "NORMAL">>;
+    }, z.core.$strip>>>;
+    audience_target_ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;

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

@@ -0,0 +1,84 @@
+import { z } from "zod";
+import { AUDIENCE_TARGET_ACTIONS, AUDIENCE_TARGET_STATES, STRATEGY_PRIORITIES } from "#shared/config/enums";
+import { MAX_AD_GROUPS_PER_CALL, MAX_CAMPAIGNS_PER_AUDIENCE_CALL, MAX_IDS_PER_CALL } from "#shared/config/limits";
+import { idField } from "#shared/lib/id";
+import { rublesField } from "#shared/lib/money";
+import { pageFields } from "#shared/lib/pagination";
+export const listAudienceTargetsSchema = z.object({
+    audience_target_ids: z
+        .array(idField("ID условия нацеливания"))
+        .check(z.maxLength(MAX_IDS_PER_CALL, { error: `Не больше ${MAX_IDS_PER_CALL} условий за вызов` }))
+        .optional()
+        .meta({ description: "Конкретные условия нацеливания" }),
+    ad_group_ids: z
+        .array(idField("ID группы объявлений"))
+        .check(z.maxLength(MAX_AD_GROUPS_PER_CALL, { error: `Не больше ${MAX_AD_GROUPS_PER_CALL} групп за вызов` }))
+        .optional()
+        .meta({ description: "Условия выбранных групп" }),
+    campaign_ids: z
+        .array(idField("ID кампании"))
+        .check(z.maxLength(MAX_CAMPAIGNS_PER_AUDIENCE_CALL, {
+        error: `Не больше ${MAX_CAMPAIGNS_PER_AUDIENCE_CALL} кампаний за вызов`
+    }))
+        .optional()
+        .meta({ description: "Условия выбранных кампаний" }),
+    retargeting_list_ids: z
+        .array(idField("ID условия ретаргетинга"))
+        .check(z.maxLength(MAX_AD_GROUPS_PER_CALL, {
+        error: `Не больше ${MAX_AD_GROUPS_PER_CALL} условий ретаргетинга за вызов`
+    }))
+        .optional()
+        .meta({ description: "Условия, построенные на этих списках ретаргетинга" }),
+    interest_ids: z
+        .array(idField("ID интереса к мобильным приложениям"))
+        .check(z.maxLength(MAX_AD_GROUPS_PER_CALL, { error: `Не больше ${MAX_AD_GROUPS_PER_CALL} интересов за вызов` }))
+        .optional()
+        .meta({ description: "Условия, построенные на этих интересах" }),
+    states: z
+        .array(z.literal(AUDIENCE_TARGET_STATES))
+        .optional()
+        .meta({ description: "Фильтр по состоянию: ON или SUSPENDED" }),
+    ...pageFields
+});
+// Цель строится ровно на одном источнике: список ретаргетинга или интерес.
+// Проверку «ровно один» делает хендлер — она про сочетание полей.
+const audienceTarget = z.object({
+    ad_group_id: idField("ID группы, в которую добавляется условие"),
+    retargeting_list_id: idField("ID условия ретаргетинга").optional(),
+    interest_id: idField("ID интереса к мобильным приложениям").optional(),
+    context_bid: rublesField("Ставка в сетях в рублях; 0 — снять ставку", { allowZero: true }).optional(),
+    strategy_priority: z
+        .literal(STRATEGY_PRIORITIES)
+        .optional()
+        .meta({ description: "Приоритет для автоматических стратегий: LOW, NORMAL или HIGH" })
+});
+const audienceBid = z.object({
+    audience_target_id: idField("ID условия нацеливания").optional(),
+    ad_group_id: idField("ID группы: ставка применится ко всем её условиям").optional(),
+    campaign_id: idField("ID кампании: ставка применится ко всем её условиям").optional(),
+    context_bid: rublesField("Ставка в сетях в рублях; 0 — снять ставку", { allowZero: true }).optional(),
+    strategy_priority: z
+        .literal(STRATEGY_PRIORITIES)
+        .optional()
+        .meta({ description: "Приоритет для автоматических стратегий" })
+});
+export const setAudienceTargetsSchema = z.object({
+    action: z.literal(AUDIENCE_TARGET_ACTIONS).meta({
+        description: "Что сделать: add, set_bids, suspend, resume или delete (необратимо)"
+    }),
+    targets: z
+        .array(audienceTarget)
+        .check(z.minLength(1, { error: "Список условий пуст" }), z.maxLength(MAX_AD_GROUPS_PER_CALL, { error: `Не больше ${MAX_AD_GROUPS_PER_CALL} условий за вызов` }))
+        .optional()
+        .meta({ description: "Условия для добавления; обязателен при action=add" }),
+    bids: z
+        .array(audienceBid)
+        .check(z.minLength(1, { error: "Список ставок пуст" }), z.maxLength(MAX_IDS_PER_CALL, { error: `Не больше ${MAX_IDS_PER_CALL} ставок за вызов` }))
+        .optional()
+        .meta({ description: "Новые ставки и приоритеты; обязателен при action=set_bids" }),
+    audience_target_ids: z
+        .array(idField("ID условия нацеливания"))
+        .check(z.minLength(1, { error: "Список условий пуст" }), z.maxLength(MAX_IDS_PER_CALL, { error: `Не больше ${MAX_IDS_PER_CALL} условий за вызов` }))
+        .optional()
+        .meta({ description: "Условия для suspend, resume или delete" })
+});

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

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

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

@@ -0,0 +1,19 @@
+import { DESTRUCTIVE, defineTool, READ } from "#shared/lib/tool";
+import { handleListAudienceTargets, handleSetAudienceTargets } from "./handler.js";
+import { listAudienceTargetsSchema, setAudienceTargetsSchema } from "./schema.js";
+export const listAudienceTargetsTool = defineTool({
+    name: "list_audience_targets",
+    title: "Аудиторные цели",
+    description: "Получить условия нацеливания на аудиторию по ID кампании, группы, ретаргетинга или интереса.",
+    annotations: READ,
+    schema: listAudienceTargetsSchema,
+    handler: handleListAudienceTargets
+});
+export const setAudienceTargetsTool = defineTool({
+    name: "set_audience_targets",
+    title: "Управление аудиторными целями",
+    description: "Добавить, остановить, возобновить, удалить аудиторные цели или изменить их ставки.",
+    annotations: DESTRUCTIVE,
+    schema: setAudienceTargetsSchema,
+    handler: handleSetAudienceTargets
+});

package/dist/tools/bid-adjustments/handler.d.ts

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

package/dist/tools/bid-adjustments/handler.js

@@ -0,0 +1,43 @@
+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 NO_MONEY = { money: false };
+// Значения корректировок лежат в отдельных полях на каждый тип, поэтому запрашиваются
+// все наборы сразу: иначе ответ придёт без самих коэффициентов.
+const FIELD_NAMES = {
+    FieldNames: ["Id", "CampaignId", "AdGroupId", "Level", "Type"],
+    MobileAdjustmentFieldNames: ["BidModifier", "OperatingSystemType"],
+    TabletAdjustmentFieldNames: ["BidModifier", "OperatingSystemType"],
+    DesktopAdjustmentFieldNames: ["BidModifier"],
+    DesktopOnlyAdjustmentFieldNames: ["BidModifier"],
+    DemographicsAdjustmentFieldNames: ["Gender", "Age", "BidModifier", "Enabled"]
+};
+export async function handleGetBidAdjustments(params) {
+    if (!params.campaign_ids && !params.ad_group_ids && !params.adjustment_ids) {
+        throw new Error("Укажите campaign_ids, ad_group_ids или adjustment_ids.");
+    }
+    const selection = { Levels: params.levels };
+    if (params.campaign_ids)
+        selection.CampaignIds = apiIds(params.campaign_ids);
+    if (params.ad_group_ids)
+        selection.AdGroupIds = apiIds(params.ad_group_ids);
+    if (params.adjustment_ids)
+        selection.Ids = apiIds(params.adjustment_ids);
+    if (params.types)
+        selection.Types = params.types;
+    const request = { SelectionCriteria: selection, ...FIELD_NAMES };
+    const page = buildPage(params);
+    if (page)
+        request.Page = page;
+    return formatResult(await apiPost("bidmodifiers", "get", request), NO_MONEY);
+}
+export async function handleSetBidAdjustments(params) {
+    const data = await apiPost("bidmodifiers", "set", {
+        BidModifiers: params.adjustments.map((adjustment) => ({
+            Id: apiId(adjustment.adjustment_id),
+            BidModifier: adjustment.bid_modifier
+        }))
+    });
+    return formatResult(data, NO_MONEY);
+}

package/dist/tools/bid-adjustments/schema.d.ts

@@ -0,0 +1,16 @@
+import { z } from "zod";
+export declare const getBidAdjustmentsSchema: z.ZodObject<{
+    limit: z.ZodOptional<z.ZodInt>;
+    offset: z.ZodOptional<z.ZodInt>;
+    campaign_ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    ad_group_ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    adjustment_ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    types: z.ZodOptional<z.ZodArray<z.ZodLiteral<"DEMOGRAPHICS_ADJUSTMENT" | "DESKTOP_ADJUSTMENT" | "DESKTOP_ONLY_ADJUSTMENT" | "MOBILE_ADJUSTMENT" | "TABLET_ADJUSTMENT">>>;
+    levels: z.ZodArray<z.ZodLiteral<"AD_GROUP" | "CAMPAIGN">>;
+}, z.core.$strip>;
+export declare const setBidAdjustmentsSchema: z.ZodObject<{
+    adjustments: z.ZodArray<z.ZodObject<{
+        adjustment_id: z.ZodString;
+        bid_modifier: z.ZodInt;
+    }, z.core.$strip>>;
+}, z.core.$strip>;

package/dist/tools/bid-adjustments/schema.js

@@ -0,0 +1,50 @@
+// Корректировки ставок: коэффициент в процентах, не деньги — rublesField здесь не к месту.
+import { z } from "zod";
+import { BID_ADJUSTMENT_LEVELS, BID_ADJUSTMENT_TYPES } from "#shared/config/enums";
+import { BID_MODIFIER_RANGE, MAX_AD_GROUPS_PER_CALL, 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";
+export const getBidAdjustmentsSchema = z.object({
+    campaign_ids: z
+        .array(idField("ID кампании"))
+        .check(z.minLength(1, { error: "Список кампаний пуст" }), z.maxLength(MAX_CAMPAIGNS_PER_ADJUSTMENT_CALL, {
+        error: `За один вызов допустимо не больше ${MAX_CAMPAIGNS_PER_ADJUSTMENT_CALL} кампаний`
+    }))
+        .optional()
+        .meta({ description: "Кампании, корректировки которых нужно получить" }),
+    ad_group_ids: z
+        .array(idField("ID группы объявлений"))
+        .check(z.minLength(1, { error: "Список групп пуст" }), z.maxLength(MAX_AD_GROUPS_PER_CALL, {
+        error: `За один вызов допустимо не больше ${MAX_AD_GROUPS_PER_CALL} групп`
+    }))
+        .optional()
+        .meta({ description: "Группы, корректировки которых нужно получить" }),
+    adjustment_ids: z
+        .array(idField("ID корректировки"))
+        .check(z.minLength(1, { error: "Список корректировок пуст" }), z.maxLength(MAX_IDS_PER_CALL, { error: `За один вызов допустимо не больше ${MAX_IDS_PER_CALL} корректировок` }))
+        .optional()
+        .meta({ description: "Конкретные корректировки по их ID" }),
+    types: z.array(z.literal(BID_ADJUSTMENT_TYPES)).optional().meta({ description: "Фильтр по типу корректировки" }),
+    levels: z
+        .array(z.literal(BID_ADJUSTMENT_LEVELS))
+        .check(z.minLength(1, { error: "Укажите хотя бы один уровень" }))
+        .meta({ description: "Уровни корректировок: CAMPAIGN и/или AD_GROUP" }),
+    ...pageFields
+});
+const bidAdjustment = z.object({
+    adjustment_id: idField("ID существующей корректировки"),
+    bid_modifier: z
+        .int()
+        .check(z.gte(BID_MODIFIER_RANGE.min, { error: `Коэффициент не меньше ${BID_MODIFIER_RANGE.min}` }), z.lte(BID_MODIFIER_RANGE.max, { error: `Коэффициент не больше ${BID_MODIFIER_RANGE.max}` }))
+        .meta({
+        description: `Коэффициент в процентах, ${BID_MODIFIER_RANGE.min}–${BID_MODIFIER_RANGE.max}: 100 — ставка без изменений`
+    })
+});
+export const setBidAdjustmentsSchema = z.object({
+    adjustments: z
+        .array(bidAdjustment)
+        .check(z.minLength(1, { error: "Список корректировок пуст" }), z.maxLength(MAX_AD_GROUPS_PER_CALL, {
+        error: `За один вызов допустимо не больше ${MAX_AD_GROUPS_PER_CALL} корректировок`
+    }))
+        .meta({ description: "Корректировки и их новые коэффициенты" })
+});

package/dist/tools/bid-adjustments/tool.d.ts

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

package/dist/tools/bid-adjustments/tool.js

@@ -0,0 +1,19 @@
+import { defineTool, IDEMPOTENT, READ } from "#shared/lib/tool";
+import { handleGetBidAdjustments, handleSetBidAdjustments } from "./handler.js";
+import { getBidAdjustmentsSchema, setBidAdjustmentsSchema } from "./schema.js";
+export const getBidAdjustmentsTool = defineTool({
+    name: "get_bid_adjustments",
+    title: "Корректировки ставок",
+    description: "Получить корректировки ставок по устройствам, полу и возрасту на уровне кампании или группы.",
+    annotations: READ,
+    schema: getBidAdjustmentsSchema,
+    handler: handleGetBidAdjustments
+});
+export const setBidAdjustmentsTool = defineTool({
+    name: "set_bid_adjustments",
+    title: "Изменить корректировки ставок",
+    description: "Изменить коэффициенты существующих корректировок по их ID.",
+    annotations: IDEMPOTENT,
+    schema: setBidAdjustmentsSchema,
+    handler: handleSetBidAdjustments
+});

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

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

package/dist/tools/businesses/handler.js

@@ -0,0 +1,26 @@
+import { apiPost } from "#shared/api/client";
+import { formatResult } from "#shared/lib/format";
+import { apiIds } from "#shared/lib/id";
+import { buildPage } from "#shared/lib/pagination";
+const LIST_FIELDS = [
+    "Id",
+    "Name",
+    "Address",
+    "Phone",
+    "ProfileUrl",
+    "InternalUrl",
+    "IsPublished",
+    "MergedIds",
+    "Rubric",
+    "Urls",
+    "HasOffice"
+];
+export async function handleListBusinesses(params) {
+    const request = { FieldNames: LIST_FIELDS };
+    if (params.business_ids?.length)
+        request.SelectionCriteria = { Ids: apiIds(params.business_ids) };
+    const page = buildPage(params);
+    if (page)
+        request.Page = page;
+    return formatResult(await apiPost("businesses", "get", request), { money: false });
+}

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

@@ -0,0 +1,6 @@
+import { z } from "zod";
+export declare const listBusinessesSchema: z.ZodObject<{
+    limit: z.ZodOptional<z.ZodInt>;
+    offset: z.ZodOptional<z.ZodInt>;
+    business_ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;

package/dist/tools/businesses/schema.js

@@ -0,0 +1,12 @@
+import { z } from "zod";
+import { MAX_IDS_PER_CALL } from "#shared/config/limits";
+import { idField } from "#shared/lib/id";
+import { pageFields } from "#shared/lib/pagination";
+export const listBusinessesSchema = z.object({
+    business_ids: z
+        .array(idField("ID профиля организации"))
+        .check(z.maxLength(MAX_IDS_PER_CALL, { error: `За один вызов допустимо не больше ${MAX_IDS_PER_CALL} профилей` }))
+        .optional()
+        .meta({ description: "Конкретные профили; без них возвращаются все доступные" }),
+    ...pageFields
+});

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

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

package/dist/tools/businesses/tool.js

@@ -0,0 +1,11 @@
+import { defineTool, READ } from "#shared/lib/tool";
+import { handleListBusinesses } from "./handler.js";
+import { listBusinessesSchema } from "./schema.js";
+export const listBusinessesTool = defineTool({
+    name: "list_businesses",
+    title: "Профили организаций",
+    description: "Получить доступные профили организаций из Яндекс Бизнеса.",
+    annotations: READ,
+    schema: listBusinessesSchema,
+    handler: handleListBusinesses
+});

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

@@ -0,0 +1,11 @@
+import type { z } from "zod";
+import type { createCampaignSchema, getCampaignSchema, getStrategySchema, listCampaignsSchema, manageCampaignsSchema, setStrategySchema, updateCampaignSchema } from "./schema.js";
+export declare function handleListCampaigns(params: z.infer<typeof listCampaignsSchema>): Promise<string>;
+export declare function handleGetCampaign(params: z.infer<typeof getCampaignSchema>): Promise<string>;
+export declare function handleCreateCampaign(params: z.infer<typeof createCampaignSchema>): Promise<string>;
+export declare function handleUpdateCampaign(params: z.infer<typeof updateCampaignSchema>): Promise<string>;
+export declare function handleManageCampaigns(params: z.infer<typeof manageCampaignsSchema>): Promise<string>;
+export declare function handleGetStrategy(params: z.infer<typeof getStrategySchema>): Promise<string>;
+type StrategyParams = z.infer<typeof setStrategySchema>;
+export declare function handleSetStrategy(params: StrategyParams): Promise<string>;
+export {};

package/dist/tools/campaigns/handler.js

@@ -0,0 +1,200 @@
+import { apiPost } from "#shared/api/client";
+import { getCampaignSettingsKey } from "#shared/lib/campaign-type";
+import { formatResult } from "#shared/lib/format";
+import { apiId, apiIds } from "#shared/lib/id";
+import { buildPage } from "#shared/lib/pagination";
+const LIST_FIELDS = ["Id", "Name", "Status", "State", "DailyBudget", "StartDate", "Type", "Statistics"];
+const DETAIL_FIELDS = [...LIST_FIELDS, "EndDate"];
+// TrackingParams поддерживают не все типы: сверено с WSDL campaigns 05.09.2026 — поле есть
+// в Text, DynamicText, Smart и Unified, но не в MobileApp и не в CpmBanner. Набор не тот
+// же, что у общих наборов минус-фраз, поэтому список свой, а не общий.
+const TRACKING_PARAMS_TYPES = ["TEXT_CAMPAIGN", "DYNAMIC_TEXT_CAMPAIGN", "SMART_CAMPAIGN", "UNIFIED_CAMPAIGN"];
+async function readTrackingParamsKey(campaignId) {
+    const data = await apiPost("campaigns", "get", {
+        SelectionCriteria: { Ids: [apiId(campaignId)] },
+        FieldNames: ["Id", "Type"]
+    });
+    const campaign = data.result?.Campaigns?.[0];
+    if (!campaign)
+        throw new Error(`Кампания ${campaignId} не найдена или недоступна.`);
+    const type = campaign.Type;
+    const settingsKey = type && TRACKING_PARAMS_TYPES.includes(type) ? getCampaignSettingsKey(type) : undefined;
+    if (!settingsKey) {
+        throw new Error(`Кампания ${campaignId} имеет тип ${type ?? "неизвестный"}, а UTM-разметку поддерживают только ${TRACKING_PARAMS_TYPES.join(", ")}.`);
+    }
+    return settingsKey;
+}
+// Действие со статусом — отдельный метод API, а не поле update.
+const STATUS_METHODS = {
+    SUSPEND: "suspend",
+    RESUME: "resume",
+    ARCHIVE: "archive",
+    UNARCHIVE: "unarchive"
+};
+export async function handleListCampaigns(params) {
+    const selectionCriteria = {};
+    if (params.status)
+        selectionCriteria.Statuses = [params.status];
+    if (params.types)
+        selectionCriteria.Types = params.types;
+    const requestParams = { SelectionCriteria: selectionCriteria, FieldNames: LIST_FIELDS };
+    const page = buildPage(params);
+    if (page)
+        requestParams.Page = page;
+    return formatResult(await apiPost("campaigns", "get", requestParams));
+}
+// TrackingParams лежит внутри объекта настроек, поэтому в общий FieldNames не попадает —
+// его запрашивают отдельным type-specific параметром. Заранее тип неизвестен, но лишние
+// *CampaignFieldNames безвредны: Директ наполняет тот объект, который соответствует
+// реальному типу кампании, а остальные просто не возвращает.
+export async function handleGetCampaign(params) {
+    const data = await apiPost("campaigns", "get", {
+        SelectionCriteria: { Ids: [apiId(params.campaign_id)] },
+        FieldNames: DETAIL_FIELDS,
+        TextCampaignFieldNames: ["TrackingParams"],
+        DynamicTextCampaignFieldNames: ["TrackingParams"],
+        SmartCampaignFieldNames: ["TrackingParams"],
+        UnifiedCampaignFieldNames: ["TrackingParams"]
+    });
+    return formatResult(data);
+}
+export async function handleCreateCampaign(params) {
+    const campaign = { Name: params.name, StartDate: params.start_date };
+    if (params.daily_budget !== undefined) {
+        campaign.DailyBudget = { Amount: params.daily_budget, Mode: "STANDARD" };
+    }
+    if (params.time_zone !== undefined)
+        campaign.TimeZone = params.time_zone;
+    const biddingStrategy = {
+        Search: { BiddingStrategyType: params.search_strategy },
+        Network: { BiddingStrategyType: params.network_strategy }
+    };
+    // TrackingParams живёт в том же объекте настроек, что и стратегия, поэтому собирается
+    // вместе с ним. На создании тип известен из параметров, читать его неоткуда и не нужно.
+    const settings = { BiddingStrategy: biddingStrategy };
+    if (params.tracking_params !== undefined)
+        settings.TrackingParams = params.tracking_params;
+    if (params.type === "DYNAMIC_TEXT_CAMPAIGN") {
+        campaign.DynamicTextCampaign = settings;
+    }
+    else {
+        campaign.TextCampaign = settings;
+    }
+    return formatResult(await apiPost("campaigns", "add", { Campaigns: [campaign] }));
+}
+// Действие со статусом и правка полей — два разных вызова API. Выполняются оба,
+// если заданы оба: иначе при наличии status поля name/daily_budget молча терялись бы.
+// Каждый ответ форматируется отдельно, чтобы per-item ошибки не потерялись.
+export async function handleUpdateCampaign(params) {
+    const sections = [];
+    if (params.status) {
+        const method = STATUS_METHODS[params.status];
+        const data = await apiPost("campaigns", method, { SelectionCriteria: { Ids: [apiId(params.campaign_id)] } });
+        sections.push(formatResult(data));
+    }
+    const changesSettings = params.tracking_params !== undefined;
+    if (params.name !== undefined || params.daily_budget !== undefined || changesSettings) {
+        const campaign = { Id: apiId(params.campaign_id) };
+        if (params.name !== undefined)
+            campaign.Name = params.name;
+        if (params.daily_budget !== undefined) {
+            campaign.DailyBudget = { Amount: params.daily_budget, Mode: "STANDARD" };
+        }
+        // Имя объекта настроек зависит от типа кампании, а в запросе тип не передаётся —
+        // приходится прочитать. Лишний вызов только там, где разметка правда меняется.
+        if (changesSettings) {
+            const settingsKey = await readTrackingParamsKey(params.campaign_id);
+            campaign[settingsKey] = { TrackingParams: params.tracking_params };
+        }
+        sections.push(formatResult(await apiPost("campaigns", "update", { Campaigns: [campaign] })));
+    }
+    if (sections.length === 0) {
+        throw new Error("Нечего обновлять: укажите status и/или name/daily_budget/tracking_params.");
+    }
+    return sections.join("\n\n");
+}
+export async function handleManageCampaigns(params) {
+    const data = await apiPost("campaigns", params.action, {
+        SelectionCriteria: { Ids: apiIds(params.campaign_ids) }
+    });
+    return formatResult(data);
+}
+// Стратегия — часть кампании: читается тем же get, пишется тем же update.
+export async function handleGetStrategy(params) {
+    const data = await apiPost("campaigns", "get", {
+        SelectionCriteria: { Ids: [apiId(params.campaign_id)] },
+        FieldNames: ["Id", "Name", "Type"],
+        TextCampaignFieldNames: ["BiddingStrategy"]
+    });
+    return formatResult(data);
+}
+// Цену стратегии, без которой она не имеет смысла, требуем сами: Директ вернул бы
+// ту же ошибку, но после запроса и на своём языке.
+function required(value, field, type) {
+    if (value === undefined)
+        throw new Error(`${field} обязателен для стратегии ${type}.`);
+    return value;
+}
+// Необязательные поля добавляются только когда заданы: пустое поле в запросе Директ
+// трактует как «сбросить», а не «оставить как есть».
+function withOptional(settings, params) {
+    if (params.weekly_spend_limit !== undefined)
+        settings.WeeklySpendLimit = params.weekly_spend_limit;
+    if (params.goal_id !== undefined)
+        settings.GoalId = apiId(params.goal_id);
+    return settings;
+}
+// Настройки лежат не рядом с типом, а во вложенном объекте, названном по стратегии:
+// имя объекта и есть переключатель, а BiddingStrategyType только дублирует его.
+function strategySettings(type, params) {
+    switch (type) {
+        case "WB_MAXIMUM_CLICKS": {
+            const settings = {
+                WeeklySpendLimit: required(params.weekly_spend_limit, "weekly_spend_limit", type)
+            };
+            if (params.bid_ceiling !== undefined)
+                settings.BidCeiling = params.bid_ceiling;
+            return { WbMaximumClicks: settings };
+        }
+        case "AVERAGE_CPC":
+            return { AverageCpc: withOptional({ AverageCpc: required(params.average_cpc, "average_cpc", type) }, params) };
+        case "AVERAGE_CPA": {
+            const settings = withOptional({ AverageCpa: required(params.average_cpa, "average_cpa", type) }, params);
+            if (params.bid_ceiling !== undefined)
+                settings.BidCeiling = params.bid_ceiling;
+            return { AverageCpa: settings };
+        }
+        // Cpa, а не AverageCpa: у оплаты за конверсию это фиксированная цена конверсии.
+        case "PAY_FOR_CONVERSION":
+            return {
+                PayForConversion: withOptional({ Cpa: required(params.conversion_price, "conversion_price", type) }, params)
+            };
+        case "NETWORK_DEFAULT":
+            return {
+                NetworkDefault: params.network_limit_percent === undefined ? {} : { LimitPercent: params.network_limit_percent }
+            };
+        // HIGHEST_POSITION, MAXIMUM_COVERAGE и SERVING_OFF настроек не имеют:
+        // в TextCampaignStrategyBase структуры под них нет вовсе.
+        default:
+            return undefined;
+    }
+}
+function strategyPart(type, params) {
+    return { BiddingStrategyType: type, ...strategySettings(type, params) };
+}
+export async function handleSetStrategy(params) {
+    const data = await apiPost("campaigns", "update", {
+        Campaigns: [
+            {
+                Id: apiId(params.campaign_id),
+                TextCampaign: {
+                    BiddingStrategy: {
+                        Search: strategyPart(params.search_type, params),
+                        Network: strategyPart(params.network_type, params)
+                    }
+                }
+            }
+        ]
+    });
+    return formatResult(data);
+}

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

@@ -0,0 +1,46 @@
+import { z } from "zod";
+export declare const listCampaignsSchema: z.ZodObject<{
+    limit: z.ZodOptional<z.ZodInt>;
+    offset: z.ZodOptional<z.ZodInt>;
+    status: z.ZodOptional<z.ZodLiteral<"ACCEPTED" | "DRAFT" | "MODERATION" | "REJECTED">>;
+    types: z.ZodOptional<z.ZodArray<z.ZodLiteral<"CPM_BANNER_CAMPAIGN" | "DYNAMIC_TEXT_CAMPAIGN" | "MOBILE_APP_CAMPAIGN" | "SMART_CAMPAIGN" | "TEXT_CAMPAIGN" | "UNIFIED_CAMPAIGN">>>;
+}, z.core.$strip>;
+export declare const getCampaignSchema: z.ZodObject<{
+    campaign_id: z.ZodString;
+}, z.core.$strip>;
+export declare const createCampaignSchema: z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodDefault<z.ZodLiteral<"DYNAMIC_TEXT_CAMPAIGN" | "TEXT_CAMPAIGN">>;
+    start_date: z.ZodString;
+    daily_budget: z.ZodOptional<z.ZodPipe<z.ZodNumber, z.ZodTransform<number, number>>>;
+    search_strategy: z.ZodDefault<z.ZodLiteral<"AVERAGE_CPA" | "AVERAGE_CPA_MULTIPLE_GOALS" | "AVERAGE_CPC" | "AVERAGE_CRR" | "AVERAGE_ROI" | "HIGHEST_POSITION" | "IMPRESSIONS_BELOW_SEARCH" | "MAX_PROFIT" | "PAY_FOR_CONVERSION" | "PAY_FOR_CONVERSION_CRR" | "PAY_FOR_CONVERSION_MULTIPLE_GOALS" | "SERVING_OFF" | "WB_MAXIMUM_CLICKS" | "WB_MAXIMUM_CONVERSION_RATE" | "WEEKLY_CLICK_PACKAGE">>;
+    network_strategy: z.ZodDefault<z.ZodLiteral<"AVERAGE_CPA" | "AVERAGE_CPA_MULTIPLE_GOALS" | "AVERAGE_CPC" | "AVERAGE_CRR" | "AVERAGE_ROI" | "MAXIMUM_COVERAGE" | "MAX_PROFIT" | "NETWORK_DEFAULT" | "PAY_FOR_CONVERSION" | "PAY_FOR_CONVERSION_CRR" | "PAY_FOR_CONVERSION_MULTIPLE_GOALS" | "SERVING_OFF" | "WB_MAXIMUM_CLICKS" | "WB_MAXIMUM_CONVERSION_RATE" | "WEEKLY_CLICK_PACKAGE">>;
+    time_zone: z.ZodOptional<z.ZodString>;
+    tracking_params: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export declare const updateCampaignSchema: z.ZodObject<{
+    campaign_id: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    daily_budget: z.ZodOptional<z.ZodPipe<z.ZodNumber, z.ZodTransform<number, number>>>;
+    status: z.ZodOptional<z.ZodLiteral<"ARCHIVE" | "RESUME" | "SUSPEND" | "UNARCHIVE">>;
+    tracking_params: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export declare const manageCampaignsSchema: z.ZodObject<{
+    campaign_ids: z.ZodArray<z.ZodString>;
+    action: z.ZodLiteral<"archive" | "resume" | "suspend" | "unarchive">;
+}, z.core.$strip>;
+export declare const getStrategySchema: z.ZodObject<{
+    campaign_id: z.ZodString;
+}, z.core.$strip>;
+export declare const setStrategySchema: z.ZodObject<{
+    campaign_id: z.ZodString;
+    search_type: z.ZodLiteral<"AVERAGE_CPA" | "AVERAGE_CPC" | "HIGHEST_POSITION" | "PAY_FOR_CONVERSION" | "SERVING_OFF" | "WB_MAXIMUM_CLICKS">;
+    network_type: z.ZodLiteral<"AVERAGE_CPA" | "AVERAGE_CPC" | "MAXIMUM_COVERAGE" | "NETWORK_DEFAULT" | "PAY_FOR_CONVERSION" | "SERVING_OFF" | "WB_MAXIMUM_CLICKS">;
+    weekly_spend_limit: z.ZodOptional<z.ZodPipe<z.ZodNumber, z.ZodTransform<number, number>>>;
+    bid_ceiling: z.ZodOptional<z.ZodPipe<z.ZodNumber, z.ZodTransform<number, number>>>;
+    average_cpc: z.ZodOptional<z.ZodPipe<z.ZodNumber, z.ZodTransform<number, number>>>;
+    average_cpa: z.ZodOptional<z.ZodPipe<z.ZodNumber, z.ZodTransform<number, number>>>;
+    conversion_price: z.ZodOptional<z.ZodPipe<z.ZodNumber, z.ZodTransform<number, number>>>;
+    goal_id: z.ZodOptional<z.ZodString>;
+    network_limit_percent: z.ZodOptional<z.ZodInt>;
+}, z.core.$strip>;