@affset/mcp 0.3.0 → 0.4.0

package/README.md

@@ -39,6 +39,8 @@ unless you set `AFFSET_READ_ONLY=true`.
 | `list_traffic_sources`  | List traffic sources — the networks bought from, each with the tracking/postback templates its linked zones use. API token shown only as set/none.                                                                                                                                                                                                                                                                                                                                                                            |
 | `create_traffic_source` | Create a traffic source, optionally from a network preset (`exoclick`, `trafficstars`, `propellerads`, `adsterra`, `richads`) that copies verified templates into an editable row. **Dry-run by default**; `confirm: true` to apply.                                                                                                                                                                                                                                                                                          |
 | `update_traffic_source` | Partial update (name, templates, api_token, status). Linked zones pick the new tracking template up immediately. **Dry-run by default**; `confirm: true` to apply.                                                                                                                                                                                                                                                                                                                                                            |
+| `list_source_bids`      | The network campaigns of one traffic source with their **current bids**, read live from the network account (ExoClick, TrafficStars, RichAds — needs the source's API token): status, pricing model, bid in USD, last change that entered Affset's mutation stage. Read-only.                                                                                                                                                                                                                                                 |
+| `set_source_bid`        | Set one network campaign's bid in USD using its existing pricing model (for RichAds: CPM for pops, CPC for push/display). The dry run returns `expected_current_bid`; pass that value back with `confirm: true` to bind the write to the bid reviewed, so a concurrent change is refused rather than overwritten. Records the attempt in the source's bid history and reports applied only when the network echoes the new value. Raising a bid above 5× needs `allow_large_increase: true`. **Dry-run by default**.          |
 | `get_zone_url`          | The `/serve` URL to paste into a network's campaign settings — rotates across the zone's **active** campaigns. A zone linked to a traffic source renders that source's tracking template; otherwise prefilled sub convention + optional `cost` macro. Warns when no active campaigns are visible.                                                                                                                                                                                                                             |
 | `get_tracking_link`     | The `/track/click` link for an existing campaign + zone — straight to one active campaign, with no rotation or targeting checks. Renders a linked source's template like `get_zone_url`. Re-derives what `create_campaign` echoed on create.                                                                                                                                                                                                                                                                                  |
 | `cut_zones`             | Blacklist underperforming zones on a campaign by threshold (CR / spend / ROI). **Dry-run by default**; `confirm: true` to apply.                                                                                                                                                                                                                                                                                                                                                                                              |

package/dist/lib/bids.d.ts

@@ -0,0 +1,21 @@
+import type { SourceBidCampaign, SourceBidChange } from "../types.js";
+/** The precision accepted by the source-bid API. */
+export declare const BID_DECIMALS = 6;
+/** The API's own guard (docs/api.md § Set bid): increases above this multiple need allow_large_increase. */
+export declare const LARGE_INCREASE_FACTOR = 5;
+/** Network campaign names come from the network account — third-party text in model context. */
+export declare const NETWORK_NAME_MAX = 120;
+export declare function pricingModelLabel(model: string): string;
+/** Preserve every decimal place that can be sent to the network. */
+export declare function formatBid(bid: number | null | undefined): string;
+/** Network-supplied error text that can land in the model's context. */
+export declare function networkErrorText(message: string): string;
+/** Match the API's optimistic-concurrency comparison, including unknown bids. */
+export declare function bidsMatch(left: number | null, right: number | null): boolean;
+/** "$0.20 → $0.25" with sub-cent precision (pops bids sit at $0.005). */
+export declare function describeBidChange(previous: number | null | undefined, next: number): string;
+export declare function isLargeIncrease(previous: number | null | undefined, next: number): boolean;
+/** One-line rendering of a change row for tables and confirmations. */
+export declare function describeChangeRow(change: SourceBidChange): string;
+/** Markdown table of a source's network campaigns with their live bids. */
+export declare function formatBidsTable(campaigns: SourceBidCampaign[]): string;

package/dist/lib/bids.js

@@ -0,0 +1,84 @@
+import { capUntrusted, mdCell } from "./format.js";
+/** The precision accepted by the source-bid API. */
+export const BID_DECIMALS = 6;
+/** The API's own guard (docs/api.md § Set bid): increases above this multiple need allow_large_increase. */
+export const LARGE_INCREASE_FACTOR = 5;
+/** Network campaign names come from the network account — third-party text in model context. */
+export const NETWORK_NAME_MAX = 120;
+const NETWORK_TOKEN_MAX = 40;
+const MODEL_LABEL = {
+    cpc: "CPC",
+    cpm: "CPM",
+    cpa: "CPA",
+    cpv: "CPV",
+    smart_cpm: "Smart CPM",
+    smart_cpc: "Smart CPC",
+    smart_bid: "Smart bid",
+};
+export function pricingModelLabel(model) {
+    if (!model)
+        return "—";
+    return MODEL_LABEL[model] ?? mdCell(capUntrusted(model, NETWORK_TOKEN_MAX));
+}
+/** Preserve every decimal place that can be sent to the network. */
+export function formatBid(bid) {
+    if (bid == null || !Number.isFinite(bid))
+        return "—";
+    return `$${bid.toLocaleString("en-US", {
+        minimumFractionDigits: 2,
+        maximumFractionDigits: BID_DECIMALS,
+    })}`;
+}
+/** Network-supplied error text that can land in the model's context. */
+export function networkErrorText(message) {
+    return mdCell(capUntrusted(message));
+}
+function roundBid(bid) {
+    const scale = 10 ** BID_DECIMALS;
+    return Math.round(bid * scale) / scale;
+}
+/** Match the API's optimistic-concurrency comparison, including unknown bids. */
+export function bidsMatch(left, right) {
+    return left === null || right === null ? left === right : roundBid(left) === roundBid(right);
+}
+/** "$0.20 → $0.25" with sub-cent precision (pops bids sit at $0.005). */
+export function describeBidChange(previous, next) {
+    return `${formatBid(previous)} → ${formatBid(next)}`;
+}
+export function isLargeIncrease(previous, next) {
+    return previous != null && previous > 0 && next > roundBid(previous * LARGE_INCREASE_FACTOR);
+}
+/** One-line rendering of a change row for tables and confirmations. */
+export function describeChangeRow(change) {
+    const when = new Date(change.created_at).toISOString().replace("T", " ").slice(0, 16);
+    const who = change.changed_by ? ` by ${mdCell(change.changed_by)}` : "";
+    const outcome = change.status === "applied"
+        ? "applied"
+        : change.status === "pending"
+            ? `outcome pending${change.error ? ` — ${mdCell(capUntrusted(change.error, 200))}` : ""}`
+            : `failed${change.error ? ` — ${mdCell(capUntrusted(change.error, 200))}` : ""}`;
+    return `${when} UTC · ${describeBidChange(change.previous_bid, change.bid)}${who} · ${outcome}`;
+}
+/** Markdown table of a source's network campaigns with their live bids. */
+export function formatBidsTable(campaigns) {
+    if (campaigns.length === 0)
+        return "_The network account has no campaigns._";
+    const lines = [
+        "| Campaign | Network id | Status | Model | Bid | Last change via affset |",
+        "|---|---|---|---|--:|---|",
+    ];
+    for (const campaign of campaigns) {
+        const name = campaign.name ? mdCell(capUntrusted(campaign.name, NETWORK_NAME_MAX)) : "—";
+        const status = campaign.status === "other" && campaign.status_label
+            ? mdCell(capUntrusted(campaign.status_label, NETWORK_TOKEN_MAX))
+            : campaign.status;
+        const extra = Object.entries(campaign.extra)
+            .map(([key, value]) => `${mdCell(capUntrusted(key, NETWORK_TOKEN_MAX))} ${formatBid(value)}`)
+            .join(", ");
+        const bid = campaign.bid === null ? "—" : `${formatBid(campaign.bid)}${extra ? ` (${extra})` : ""}`;
+        const last = campaign.last_change ? describeChangeRow(campaign.last_change) : "—";
+        lines.push(`| ${name} | \`${mdCell(campaign.network_campaign_id)}\` | ${status} | ${pricingModelLabel(campaign.pricing_model)} | ${bid} | ${last} |`);
+    }
+    return lines.join("\n");
+}
+//# sourceMappingURL=bids.js.map

package/dist/registerTools.js

@@ -16,6 +16,8 @@ import { updateZone, updateZoneInputSchema, UPDATE_ZONE_DESCRIPTION } from "./to
 import { listTrafficSources, listTrafficSourcesInputSchema, LIST_TRAFFIC_SOURCES_DESCRIPTION, } from "./tools/listTrafficSources.js";
 import { createTrafficSource, createTrafficSourceInputSchema, CREATE_TRAFFIC_SOURCE_DESCRIPTION, } from "./tools/createTrafficSource.js";
 import { updateTrafficSource, updateTrafficSourceInputSchema, UPDATE_TRAFFIC_SOURCE_DESCRIPTION, } from "./tools/updateTrafficSource.js";
+import { listSourceBids, listSourceBidsInputSchema, LIST_SOURCE_BIDS_DESCRIPTION, } from "./tools/listSourceBids.js";
+import { setSourceBid, setSourceBidInputSchema, SET_SOURCE_BID_DESCRIPTION, } from "./tools/setSourceBid.js";
 import { updateCampaign, updateCampaignInputSchema, UPDATE_CAMPAIGN_DESCRIPTION, } from "./tools/updateCampaign.js";
 import { setCampaignStatus, setCampaignStatusInputSchema, SET_CAMPAIGN_STATUS_DESCRIPTION, } from "./tools/setCampaignStatus.js";
 import { listPayoutRules, listPayoutRulesInputSchema, LIST_PAYOUT_RULES_DESCRIPTION, } from "./tools/listPayoutRules.js";
@@ -282,6 +284,28 @@ export function registerAffsetTools(toolServer, config, options = {}) {
             openWorldHint: true,
         },
     }, (args) => updateTrafficSource(client, args));
+    registerTool("list_source_bids", {
+        title: "List a traffic source's network campaign bids",
+        description: LIST_SOURCE_BIDS_DESCRIPTION,
+        inputSchema: listSourceBidsInputSchema,
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+    }, (args) => listSourceBids(client, args));
+    registerTool("set_source_bid", {
+        title: "Set a network campaign's bid",
+        description: SET_SOURCE_BID_DESCRIPTION,
+        inputSchema: setSourceBidInputSchema,
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+    }, (args) => setSourceBid(client, args));
     registerTool("cut_zones", {
         title: "Cut underperforming zones",
         description: CUT_ZONES_DESCRIPTION,

package/dist/tools/listSourceBids.d.ts

@@ -0,0 +1,12 @@
+import { z } from "zod";
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { type AffsetClient } from "../client.js";
+export declare const LIST_SOURCE_BIDS_DESCRIPTION: string;
+export declare const listSourceBidsInputSchema: {
+    traffic_source_id: z.ZodString;
+};
+type ListSourceBidsArgs = {
+    traffic_source_id: string;
+};
+export declare function listSourceBids(client: AffsetClient, args: ListSourceBidsArgs): Promise<CallToolResult>;
+export {};

package/dist/tools/listSourceBids.js

@@ -0,0 +1,51 @@
+import { z } from "zod";
+import { AffsetApiError } from "../client.js";
+import { formatBidsTable, LARGE_INCREASE_FACTOR, networkErrorText } from "../lib/bids.js";
+import { errorResult, textError, textResult } from "../lib/toolResult.js";
+export const LIST_SOURCE_BIDS_DESCRIPTION = "List the network campaigns of one traffic source with their CURRENT bids, read live " +
+    "from the network account (ExoClick, TrafficStars or RichAds preset with an API token). " +
+    "Shows status, pricing model (CPC/CPM/…), the bid in USD, and the last bid change that " +
+    "entered Affset's mutation stage. Use before set_source_bid to see what a campaign bids " +
+    "today. Read-only.";
+export const listSourceBidsInputSchema = {
+    traffic_source_id: z
+        .string()
+        .trim()
+        .min(1)
+        .describe("Traffic source id (from list_traffic_sources) — must have a network API token."),
+};
+export async function listSourceBids(client, args) {
+    try {
+        let res;
+        try {
+            res = await client.get(`/api/traffic-sources/${encodeURIComponent(args.traffic_source_id)}/bids`);
+        }
+        catch (err) {
+            if (err instanceof AffsetApiError && err.status === 404) {
+                return textError(`Traffic source \`${args.traffic_source_id}\` not found in this namespace.`);
+            }
+            if (err instanceof AffsetApiError && err.status === 422) {
+                return textError(`${err.message} Bids can be read for sources created from the exoclick, trafficstars ` +
+                    "or richads preset once an api_token is stored (update_traffic_source).");
+            }
+            if (err instanceof AffsetApiError && err.status === 502) {
+                return textError(`The network refused the request: ${networkErrorText(err.message)}`);
+            }
+            throw err;
+        }
+        return textResult([
+            `**Network campaigns and bids** (${res.campaigns.length}, read from the network at ` +
+                `${new Date(res.fetched_at).toISOString()}):`,
+            "",
+            formatBidsTable(res.campaigns),
+            "",
+            "_Bids are in USD: CPM per 1,000 impressions, CPC per click. Change one with " +
+                "`set_source_bid` (dry-run first). Increases above " +
+                `${LARGE_INCREASE_FACTOR}× the current bid need \`allow_large_increase: true\`._`,
+        ].join("\n"));
+    }
+    catch (err) {
+        return errorResult(err);
+    }
+}
+//# sourceMappingURL=listSourceBids.js.map

package/dist/tools/setSourceBid.d.ts

@@ -0,0 +1,22 @@
+import { z } from "zod";
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { type AffsetClient } from "../client.js";
+export declare const SET_SOURCE_BID_DESCRIPTION: string;
+export declare const setSourceBidInputSchema: {
+    traffic_source_id: z.ZodString;
+    network_campaign_id: z.ZodEffects<z.ZodString, string, string>;
+    bid: z.ZodEffects<z.ZodNumber, number, number>;
+    expected_current_bid: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    allow_large_increase: z.ZodDefault<z.ZodBoolean>;
+    confirm: z.ZodDefault<z.ZodBoolean>;
+};
+type SetSourceBidArgs = {
+    traffic_source_id: string;
+    network_campaign_id: string;
+    bid: number;
+    expected_current_bid?: number | null;
+    allow_large_increase: boolean;
+    confirm: boolean;
+};
+export declare function setSourceBid(client: AffsetClient, args: SetSourceBidArgs): Promise<CallToolResult>;
+export {};

package/dist/tools/setSourceBid.js

@@ -0,0 +1,195 @@
+import { z } from "zod";
+import { AffsetApiError } from "../client.js";
+import { BID_DECIMALS, bidsMatch, describeBidChange, formatBid, isLargeIncrease, LARGE_INCREASE_FACTOR, NETWORK_NAME_MAX, networkErrorText, pricingModelLabel, } from "../lib/bids.js";
+import { capUntrusted, mdCell } from "../lib/format.js";
+import { errorResult, textError, textResult } from "../lib/toolResult.js";
+/** Mirrors the API (docs/api.md § Set bid). */
+const MAX_BID = 1000;
+const MIN_BID = 10 ** -BID_DECIMALS;
+/** Error responses may include the reserved audit row, even if finalization failed. */
+const bidErrorDetailsSchema = z.object({
+    code: z.string().optional(),
+    change: z
+        .object({ id: z.string(), status: z.enum(["pending", "applied", "failed"]) })
+        .nullable()
+        .optional(),
+});
+export const SET_SOURCE_BID_DESCRIPTION = "Set one network campaign's bid at the traffic source's network account (ExoClick, " +
+    "TrafficStars or RichAds). The bid is in USD using the campaign's existing pricing model " +
+    "(for RichAds: CPM for pops, CPC for push/display), and the network applies its own minimum. " +
+    "The write is recorded in the source's bid " +
+    "history and reported as applied only when the network echoes the new value. Raising a " +
+    `bid above ${LARGE_INCREASE_FACTOR}× the current one is refused unless allow_large_increase ` +
+    "is true. The confirmed write includes the live bid just reviewed, so a concurrent network " +
+    "change is refused instead of overwritten. DRY-RUN by default; pass confirm=true to apply.";
+export const setSourceBidInputSchema = {
+    traffic_source_id: z
+        .string()
+        .trim()
+        .min(1)
+        .describe("Traffic source id (from list_traffic_sources)."),
+    network_campaign_id: z
+        .string()
+        .trim()
+        .regex(/^\d{1,19}$/, "network_campaign_id must be the network's numeric campaign id")
+        .refine((value) => Number.isSafeInteger(Number(value)) && Number(value) > 0, "network_campaign_id must be a positive numeric campaign id within the supported range")
+        .describe("The network's numeric campaign id — the value in sub4, or from list_source_bids."),
+    bid: z
+        .number()
+        .min(MIN_BID)
+        .max(MAX_BID)
+        .refine((value) => Math.abs(value * 10 ** BID_DECIMALS - Math.round(value * 10 ** BID_DECIMALS)) <= 1e-6, `bid must have at most ${BID_DECIMALS} decimal places`)
+        .describe(`New bid in USD (at most ${BID_DECIMALS} decimals, at most ${MAX_BID}).`),
+    expected_current_bid: z
+        .number()
+        .finite()
+        .nonnegative()
+        .nullable()
+        .optional()
+        .describe("The current bid shown by this tool's dry run (including null). Required with confirm=true " +
+        "so a bid that changed after review cannot be overwritten."),
+    allow_large_increase: z
+        .boolean()
+        .default(false)
+        .describe(`Required to raise a bid above ${LARGE_INCREASE_FACTOR}× its current value. ` +
+        "Only pass it after the operator has seen the current bid and asked for the increase."),
+    confirm: z
+        .boolean()
+        .default(false)
+        .describe("false = dry-run preview (default). true = send the bid to the network."),
+};
+function campaignLine(campaign) {
+    const name = campaign.name ? mdCell(capUntrusted(campaign.name, NETWORK_NAME_MAX)) : "(unnamed)";
+    return (`**${name}** (\`${mdCell(campaign.network_campaign_id)}\`, ${campaign.status}, ` +
+        `${pricingModelLabel(campaign.pricing_model)})`);
+}
+export async function setSourceBid(client, args) {
+    try {
+        const scaled = args.bid * 10 ** BID_DECIMALS;
+        if (!Number.isFinite(args.bid) || args.bid < MIN_BID || args.bid > MAX_BID) {
+            return textError(`bid must be between ${MIN_BID} and ${MAX_BID} USD.`);
+        }
+        if (Math.abs(scaled - Math.round(scaled)) > 1e-6) {
+            return textError(`bid must have at most ${BID_DECIMALS} decimal places.`);
+        }
+        if (args.confirm && args.expected_current_bid === undefined) {
+            return textError("Not applied: confirm=true requires expected_current_bid from this tool's dry run. " +
+                "Run the dry run again, review the current bid, then pass back the value it shows.");
+        }
+        const sourcePath = `/api/traffic-sources/${encodeURIComponent(args.traffic_source_id)}`;
+        const campaignId = String(Number(args.network_campaign_id));
+        // Read first, always: the operator confirms against the bid the network holds
+        // right now, not against a remembered number.
+        let current;
+        try {
+            const bids = await client.get(`${sourcePath}/bids`);
+            current = bids.campaigns.find((campaign) => campaign.network_campaign_id === campaignId);
+        }
+        catch (err) {
+            if (err instanceof AffsetApiError && err.status === 404) {
+                return textError(`Traffic source \`${args.traffic_source_id}\` not found in this namespace.`);
+            }
+            if (err instanceof AffsetApiError && (err.status === 422 || err.status === 502)) {
+                return textError(err.status === 422
+                    ? `${err.message} Bids need an exoclick, trafficstars or richads source with an api_token.`
+                    : `The network refused the request: ${networkErrorText(err.message)}`);
+            }
+            throw err;
+        }
+        if (current === undefined) {
+            return textError(`Campaign \`${campaignId}\` is not in this network account (list_source_bids shows the ` +
+                "campaigns it has). Check the sub4 value against the source's tracking template.");
+        }
+        const large = isLargeIncrease(current.bid, args.bid);
+        const lines = [`${campaignLine(current)}: ${describeBidChange(current.bid, args.bid)}`];
+        if (bidsMatch(current.bid, args.bid)) {
+            return textResult(`Nothing to change — ${campaignLine(current)} already bids ${formatBid(current.bid)}.`);
+        }
+        if (large) {
+            lines.push("", `⚠️ This raises the bid more than ${LARGE_INCREASE_FACTOR}× (${formatBid(current.bid)} → ` +
+                `${formatBid(args.bid)}). The API refuses it unless \`allow_large_increase: true\` ` +
+                `is passed${args.allow_large_increase ? " — it is." : "."}`);
+        }
+        if (!args.confirm) {
+            const reviewedBid = current.bid === null ? "null" : String(current.bid);
+            return textResult([
+                `**Dry run** — would set the bid at traffic source \`${args.traffic_source_id}\`.`,
+                "",
+                ...lines,
+                "",
+                large && !args.allow_large_increase
+                    ? "Call again with `confirm: true`, " +
+                        `\`expected_current_bid: ${reviewedBid}\`, **and** ` +
+                        "`allow_large_increase: true` to apply."
+                    : `Call again with \`confirm: true\` and \`expected_current_bid: ${reviewedBid}\` to apply.`,
+            ].join("\n"));
+        }
+        // The early confirmation check above narrows this to number|null here.
+        const reviewedBid = args.expected_current_bid;
+        if (!bidsMatch(reviewedBid, current.bid)) {
+            return textError(`Not applied: the campaign bid changed after review (${formatBid(reviewedBid)} → ` +
+                `${formatBid(current.bid)}). Run the dry run again and review the new current bid.`);
+        }
+        let applied;
+        try {
+            applied = await client.post(`${sourcePath}/bids`, {
+                network_campaign_id: campaignId,
+                bid: args.bid,
+                expected_current_bid: reviewedBid,
+                ...(args.allow_large_increase ? { allow_large_increase: true } : {}),
+            });
+        }
+        catch (err) {
+            // Once POST starts, a lost response or failed verification is not proof
+            // that the network kept the previous bid. Read live state before retrying.
+            if (!(err instanceof AffsetApiError) || err.status === 0 || err.status >= 500) {
+                const message = err instanceof Error ? err.message : String(err);
+                return textError(`Bid write outcome is unconfirmed: ${networkErrorText(message)} ` +
+                    "The network may have applied the bid. Check list_source_bids for the current bid " +
+                    "before retrying.");
+            }
+            const parsed = bidErrorDetailsSchema.safeParse(err.body);
+            const details = parsed.success ? parsed.data : undefined;
+            if (err.status === 404) {
+                return textError(`Not applied: campaign \`${mdCell(campaignId)}\` is no longer in this network account. ` +
+                    "Refresh with list_source_bids.");
+            }
+            if (err.status === 409) {
+                if (details?.code === "BID_CHANGED") {
+                    return textError(`Not applied: ${err.message} Run list_source_bids and review the new current bid ` +
+                        "before confirming again.");
+                }
+                if (details?.code === "CONFIRM_LARGE_INCREASE") {
+                    return textError(`Refused: ${err.message} Nothing was sent to the network. Repeat with ` +
+                        "`allow_large_increase: true` if the operator really wants this increase.");
+                }
+            }
+            if (err.status === 422) {
+                const change = details?.change;
+                const history = change?.status === "pending"
+                    ? ` Change \`${mdCell(change.id)}\` remains pending in history. ` +
+                        "Refresh with list_source_bids before retrying."
+                    : change?.status === "failed"
+                        ? " The attempt is recorded in the source's bid history as failed " +
+                            `(change \`${mdCell(change.id)}\`).`
+                        : "";
+                return textError(`Bid request refused: ${networkErrorText(err.message)}${history}`);
+            }
+            throw err;
+        }
+        return textResult([
+            `✅ Bid set at the network: ${campaignLine(current)} now bids ` +
+                `${formatBid(applied.campaign.bid)} (was ${formatBid(applied.change.previous_bid)}).`,
+            "",
+            applied.audit_finalized
+                ? `Recorded as change \`${mdCell(applied.change.id)}\`` +
+                    `${applied.change.changed_by ? ` by ${mdCell(applied.change.changed_by)}` : ""}.`
+                : `⚠️ The network applied the bid, but change \`${mdCell(applied.change.id)}\` remains ` +
+                    "pending in history. Refresh with list_source_bids before retrying.",
+        ].join("\n"));
+    }
+    catch (err) {
+        return errorResult(err);
+    }
+}
+//# sourceMappingURL=setSourceBid.js.map

package/dist/types.d.ts

@@ -177,6 +177,58 @@ export interface TrafficSourcePreset {
 export interface TrafficSourcePresetsResponse {
     presets: TrafficSourcePreset[];
 }
+/**
+ * One write that entered Affset's mutation stage
+ * (GET /api/traffic-sources/{id}/bid-changes and `last_change` on the bids list).
+ * `changed_by` is the caller's email.
+ */
+export interface SourceBidChange {
+    id: string;
+    source_id: string;
+    network_campaign_id: string;
+    previous_bid: number | null;
+    bid: number;
+    currency: string;
+    pricing_model: string;
+    status: "pending" | "applied" | "failed";
+    error: string | null;
+    changed_by: string;
+    created_at: number;
+}
+/**
+ * One network campaign from GET /api/traffic-sources/{id}/bids — read live from
+ * the network account. `name` and `status_label` are the network's own text.
+ */
+export interface SourceBidCampaign {
+    network_campaign_id: string;
+    name: string;
+    status: "active" | "paused" | "other";
+    status_label: string;
+    bid: number | null;
+    currency: string;
+    pricing_model: string;
+    extra: Record<string, number>;
+    last_change: SourceBidChange | null;
+}
+export interface SourceBidsResponse {
+    campaigns: SourceBidCampaign[];
+    fetched_at: number;
+}
+/** Response of POST /api/traffic-sources/{id}/bids. */
+export interface SetSourceBidResponse {
+    change: SourceBidChange;
+    campaign: {
+        network_campaign_id: string;
+        name: string;
+        status: string;
+        bid: number | null;
+        previous_bid: number | null;
+        currency: string;
+        pricing_model: string;
+    };
+    audit_finalized: boolean;
+    warning?: string;
+}
 /** Subset of GET /api/tenant this server reads. */
 export interface TenantSettingsResponse {
     company?: string;

package/dist/version.d.ts

@@ -4,4 +4,4 @@
  * package.json here would break bundlers; a sync test guards the duplicate
  * (see registerTools.test.ts).
  */
-export declare const VERSION = "0.3.0";
+export declare const VERSION = "0.4.0";

package/dist/version.js

@@ -4,5 +4,5 @@
  * package.json here would break bundlers; a sync test guards the duplicate
  * (see registerTools.test.ts).
  */
-export const VERSION = "0.3.0";
+export const VERSION = "0.4.0";
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@affset/mcp",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "mcpName": "io.github.affset/mcp",
   "description": "MCP server for the affset ad platform — stats, campaigns, zones, payouts, targeting, sub labels, and team from your chat client.",
   "type": "module",