@socialseal/mcp-server 0.1.0 → 0.1.1

package/dist/translation.js

@@ -0,0 +1,703 @@
+import { SocialSealMcpError } from "./errors.js";
+const TRANSLATED_TOOLS = new Set([
+    "tracking",
+    "group-management",
+    "brand-group-management",
+    "export_tracking_data",
+]);
+export function isTranslatedTool(toolName) {
+    return TRANSLATED_TOOLS.has(toolName);
+}
+function invalidArgument(message, details) {
+    return new SocialSealMcpError(message, { code: "INVALID_ARGUMENT", details });
+}
+function missingArgument(message) {
+    return new SocialSealMcpError(message, { code: "MISSING_ARGUMENT" });
+}
+export function isJsonObject(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function hasOwn(value, key) {
+    return Boolean(value) && Object.prototype.hasOwnProperty.call(value, key);
+}
+function firstDefined(source, keys) {
+    if (!isJsonObject(source))
+        return undefined;
+    for (const key of keys) {
+        if (hasOwn(source, key) && source[key] !== undefined && source[key] !== null) {
+            return source[key];
+        }
+    }
+    return undefined;
+}
+function trimString(value) {
+    return typeof value === "string" ? value.trim() : "";
+}
+function stripUndefinedEntries(value) {
+    return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== undefined));
+}
+function resolvePayloadWorkspaceId(payload, fallbackWorkspaceId) {
+    const workspaceId = firstDefined(payload, ["workspace_id", "workspaceId"]);
+    if (typeof workspaceId === "string" && workspaceId.trim().length > 0) {
+        return workspaceId.trim();
+    }
+    return fallbackWorkspaceId || null;
+}
+function coercePositiveInteger(value, label) {
+    if (value === undefined || value === null || value === "")
+        return undefined;
+    const parsed = Number(value);
+    if (Number.isInteger(parsed) && parsed > 0) {
+        return parsed;
+    }
+    throw invalidArgument(`Invalid ${label}: expected a positive integer.`, value);
+}
+function buildPathWithQuery(basePath, query) {
+    const params = new URLSearchParams();
+    for (const [key, rawValue] of Object.entries(query)) {
+        if (rawValue === undefined || rawValue === null || rawValue === "")
+            continue;
+        if (Array.isArray(rawValue)) {
+            for (const entry of rawValue) {
+                if (entry !== undefined && entry !== null && entry !== "") {
+                    params.append(key, String(entry));
+                }
+            }
+            continue;
+        }
+        params.set(key, String(rawValue));
+    }
+    const queryString = params.toString();
+    return queryString ? `${basePath}?${queryString}` : basePath;
+}
+function normalizeTrackingType(value) {
+    const normalized = trimString(value).toLowerCase();
+    if (!normalized)
+        return undefined;
+    if (normalized === "keyword" || normalized === "search")
+        return "search";
+    if (normalized === "account" || normalized === "creator")
+        return "creator";
+    if (normalized === "hashtag")
+        return "hashtag";
+    throw invalidArgument(`Invalid tracking type: ${String(value)}. Use keyword/search, hashtag, or account/creator.`);
+}
+function normalizeTrackingPayload(payload, fallbackWorkspaceId) {
+    const trackValue = firstDefined(payload, ["track_value", "trackValue", "value"]);
+    const refreshFrequency = firstDefined(payload, ["refresh_frequency", "refreshFrequency"]);
+    const nextRefreshAt = firstDefined(payload, ["next_refresh_at", "nextRefreshAt"]);
+    const region = firstDefined(payload, ["region"]);
+    const platform = firstDefined(payload, ["platform"]);
+    const brandIds = firstDefined(payload, ["brand_ids", "brandIds"]);
+    const includeInactive = firstDefined(payload, ["includeInactive", "include_inactive"]);
+    const isActive = firstDefined(payload, ["is_active", "isActive"]);
+    const limit = firstDefined(payload, ["limit"]);
+    const page = firstDefined(payload, ["page"]);
+    const offset = firstDefined(payload, ["offset"]);
+    const itemId = firstDefined(payload, ["item_id", "itemId", "id"]);
+    return stripUndefinedEntries({
+        action: trimString(firstDefined(payload, ["action"])) || undefined,
+        workspaceId: resolvePayloadWorkspaceId(payload, fallbackWorkspaceId),
+        item_id: coercePositiveInteger(itemId, "item_id"),
+        name: trimString(firstDefined(payload, ["name"])) || (trimString(trackValue) || undefined),
+        track_type: normalizeTrackingType(firstDefined(payload, ["track_type", "trackType", "type"])),
+        track_value: trimString(trackValue) || undefined,
+        refresh_frequency: trimString(refreshFrequency) || undefined,
+        next_refresh_at: nextRefreshAt ?? undefined,
+        region: typeof region === "string" ? region.trim() || undefined : region,
+        platform: trimString(platform) || undefined,
+        brand_ids: Array.isArray(brandIds) ? brandIds : undefined,
+        limit: limit !== undefined ? Number(limit) : undefined,
+        page: page !== undefined ? Number(page) : undefined,
+        offset: offset !== undefined ? Number(offset) : undefined,
+        is_active: typeof isActive === "boolean" ? isActive : undefined,
+        include_inactive: typeof includeInactive === "boolean" ? includeInactive : undefined,
+    });
+}
+function normalizeGroupManagementPayload(payload, fallbackWorkspaceId) {
+    const groupId = firstDefined(payload, ["group_id", "groupId", "id"]);
+    const itemId = firstDefined(payload, ["item_id", "itemId"]);
+    const itemIds = firstDefined(payload, ["item_ids", "itemIds"]);
+    const items = firstDefined(payload, ["items"]);
+    const expectedItems = firstDefined(payload, ["expected_items", "expectedItems"]);
+    const limit = firstDefined(payload, ["limit"]);
+    const page = firstDefined(payload, ["page"]);
+    const force = firstDefined(payload, ["force"]);
+    return stripUndefinedEntries({
+        action: trimString(firstDefined(payload, ["action"])) || undefined,
+        workspaceId: resolvePayloadWorkspaceId(payload, fallbackWorkspaceId),
+        group_id: coercePositiveInteger(groupId, "group_id"),
+        item_id: coercePositiveInteger(itemId, "item_id"),
+        item_ids: Array.isArray(itemIds)
+            ? itemIds.map((value, index) => {
+                const parsed = coercePositiveInteger(value, `item_ids[${index}]`);
+                if (!parsed) {
+                    throw invalidArgument(`Invalid item_ids[${index}]: expected a positive integer.`);
+                }
+                return parsed;
+            })
+            : undefined,
+        items: Array.isArray(items) ? items : undefined,
+        expected_items: Array.isArray(expectedItems) ? expectedItems : undefined,
+        name: trimString(firstDefined(payload, ["name"])) || undefined,
+        description: firstDefined(payload, ["description"]),
+        platform: trimString(firstDefined(payload, ["platform", "groupPlatform"])) || undefined,
+        refresh_frequency: trimString(firstDefined(payload, ["refresh_frequency", "refreshFrequency"])) || undefined,
+        next_refresh_at: firstDefined(payload, ["next_refresh_at", "nextRefreshAt"]) ?? undefined,
+        brand_id: trimString(firstDefined(payload, ["brand_id", "brandId"])) || undefined,
+        track_type: normalizeTrackingType(firstDefined(payload, ["track_type", "trackType", "type"])),
+        track_value: trimString(firstDefined(payload, ["track_value", "trackValue", "value"])) || undefined,
+        region: typeof firstDefined(payload, ["region"]) === "string"
+            ? trimString(firstDefined(payload, ["region"])) || undefined
+            : firstDefined(payload, ["region"]),
+        limit: limit !== undefined ? Number(limit) : undefined,
+        page: page !== undefined ? Number(page) : undefined,
+        force: force === true || trimString(force).toLowerCase() === "true" ? true : undefined,
+    });
+}
+function normalizeBrandGroupPayload(payload, fallbackWorkspaceId) {
+    return stripUndefinedEntries({
+        action: trimString(firstDefined(payload, ["action"])) || undefined,
+        workspaceId: resolvePayloadWorkspaceId(payload, fallbackWorkspaceId),
+        workspace_id: resolvePayloadWorkspaceId(payload, fallbackWorkspaceId) || undefined,
+        brand_group_id: trimString(firstDefined(payload, ["brand_group_id", "brandGroupId", "group_id", "groupId", "id"])) || undefined,
+        brand_id: trimString(firstDefined(payload, ["brand_id", "brandId"])) || undefined,
+        name: trimString(firstDefined(payload, ["name"])) || undefined,
+        description: firstDefined(payload, ["description"]),
+    });
+}
+function normalizeTrackingExportPayload(payload, fallbackWorkspaceId) {
+    const groupId = firstDefined(payload, ["group_id", "groupId", "tracking_group_id", "trackingGroupId"]);
+    const itemId = firstDefined(payload, ["tracking_item_id", "trackingItemId", "item_id", "itemId"]);
+    return stripUndefinedEntries({
+        workspace_id: resolvePayloadWorkspaceId(payload, fallbackWorkspaceId) || undefined,
+        group_id: coercePositiveInteger(groupId, "group_id"),
+        tracking_item_id: coercePositiveInteger(itemId, "tracking_item_id"),
+        time_period: trimString(firstDefined(payload, ["time_period", "timePeriod"])) || undefined,
+    });
+}
+function buildGroupAddPayloadFromValue(rawValue, payload, label) {
+    const value = trimString(rawValue);
+    if (!value) {
+        throw invalidArgument(`Invalid ${label}: expected a non-empty tracking value.`);
+    }
+    if (!payload.track_type) {
+        throw missingArgument(`${label} requires track_type/type when using raw values. Use type=keyword/search, hashtag, or account/creator.`);
+    }
+    return stripUndefinedEntries({
+        name: value,
+        track_type: payload.track_type,
+        track_value: value,
+        refresh_frequency: payload.refresh_frequency,
+        next_refresh_at: payload.next_refresh_at,
+        region: payload.region,
+        platform: payload.platform,
+    });
+}
+function buildGroupAddPayloadFromItem(rawItem, payload, label) {
+    if (typeof rawItem === "number") {
+        return { item_id: coercePositiveInteger(rawItem, label) };
+    }
+    if (typeof rawItem === "string") {
+        const trimmed = rawItem.trim();
+        if (/^\d+$/.test(trimmed)) {
+            return { item_id: coercePositiveInteger(trimmed, label) };
+        }
+        return buildGroupAddPayloadFromValue(rawItem, payload, label);
+    }
+    if (!isJsonObject(rawItem)) {
+        throw invalidArgument(`Invalid ${label}: expected an item id, string value, or object payload.`);
+    }
+    const itemId = coercePositiveInteger(firstDefined(rawItem, ["item_id", "itemId", "id"]), `${label}.item_id`);
+    if (itemId) {
+        return { item_id: itemId };
+    }
+    const trackValue = trimString(firstDefined(rawItem, ["track_value", "trackValue", "value"])) || undefined;
+    const name = trimString(firstDefined(rawItem, ["name"])) || trackValue;
+    const trackType = normalizeTrackingType(firstDefined(rawItem, ["track_type", "trackType", "type"])) ||
+        payload.track_type;
+    const region = firstDefined(rawItem, ["region"]) ?? payload.region;
+    const platform = trimString(firstDefined(rawItem, ["platform"])) || payload.platform;
+    const refreshFrequency = trimString(firstDefined(rawItem, ["refresh_frequency", "refreshFrequency"])) ||
+        payload.refresh_frequency;
+    const nextRefreshAt = firstDefined(rawItem, ["next_refresh_at", "nextRefreshAt"]) ?? payload.next_refresh_at;
+    if (!name || !trackValue || !trackType) {
+        throw missingArgument(`${label} requires item_id or name/track_value + track_type.`);
+    }
+    return stripUndefinedEntries({
+        name,
+        track_type: trackType,
+        track_value: trackValue,
+        refresh_frequency: refreshFrequency,
+        next_refresh_at: nextRefreshAt,
+        region,
+        platform,
+    });
+}
+function buildSingleGroupAddBody(payload) {
+    if (payload.item_id) {
+        return { item_id: payload.item_id };
+    }
+    if (payload.track_value || payload.name) {
+        return buildGroupAddPayloadFromItem({
+            name: payload.name,
+            track_type: payload.track_type,
+            track_value: payload.track_value,
+            refresh_frequency: payload.refresh_frequency,
+            next_refresh_at: payload.next_refresh_at,
+            region: payload.region,
+            platform: payload.platform,
+        }, payload, "group add item payload");
+    }
+    throw missingArgument("group add_item requires item_id or a tracking payload. Provide item_id to attach an existing tracking item, or provide track_type + track_value to create/link by value.");
+}
+function buildBulkGroupAddBody(payload) {
+    if (Array.isArray(payload.item_ids) && payload.item_ids.length > 0) {
+        return payload.item_ids.map((item_id) => ({ item_id }));
+    }
+    if (Array.isArray(payload.items) && payload.items.length > 0) {
+        return payload.items.map((item, index) => buildGroupAddPayloadFromItem(item, payload, `items[${index}]`));
+    }
+    if (payload.item_id || payload.track_value || payload.name) {
+        return [buildSingleGroupAddBody(payload)];
+    }
+    throw missingArgument("group add_items requires item_ids, items, or a single item payload. Use item_ids to bulk attach existing tracking items, or use items with track_type/type for value-based adds.");
+}
+function translateTrackingAction(payload, workspaceId) {
+    const action = payload.action ? String(payload.action).toLowerCase() : null;
+    if (!action || action === "create" || action === "item_create") {
+        return {
+            method: "POST",
+            pathSuffix: buildPathWithQuery("", { workspace_id: workspaceId || undefined }),
+            body: stripUndefinedEntries({
+                name: payload.name,
+                track_type: payload.track_type,
+                track_value: payload.track_value,
+                refresh_frequency: payload.refresh_frequency,
+                next_refresh_at: payload.next_refresh_at,
+                region: payload.region,
+                platform: payload.platform,
+                brand_ids: payload.brand_ids,
+            }),
+            workspaceId,
+        };
+    }
+    if (action === "list" || action === "item_list") {
+        const limit = Number.isFinite(payload.limit) ? payload.limit : 20;
+        const page = Number.isFinite(payload.page) ? Math.max(1, payload.page) : 1;
+        const offset = Number.isFinite(payload.offset)
+            ? Math.max(0, payload.offset)
+            : (page - 1) * limit;
+        const isActive = typeof payload.is_active === "boolean"
+            ? payload.is_active
+            : (payload.include_inactive ? undefined : true);
+        return {
+            method: "GET",
+            pathSuffix: buildPathWithQuery("", {
+                workspace_id: workspaceId || undefined,
+                limit,
+                offset,
+                track_type: payload.track_type,
+                track_value: payload.track_value,
+                platform: payload.platform,
+                region: payload.region,
+                is_active: isActive,
+            }),
+            body: undefined,
+            workspaceId,
+        };
+    }
+    if (action === "get" || action === "item_get") {
+        const itemId = coercePositiveInteger(payload.item_id, "item_id");
+        if (!itemId) {
+            throw missingArgument("item_id is required for tracking get.");
+        }
+        return {
+            method: "GET",
+            pathSuffix: buildPathWithQuery(`/${itemId}`, { workspace_id: workspaceId || undefined }),
+            body: undefined,
+            workspaceId,
+        };
+    }
+    if (action === "resolve" ||
+        action === "item_resolve" ||
+        action === "get_by_value" ||
+        action === "item_get_by_value") {
+        if (!payload.track_type || !payload.track_value) {
+            throw missingArgument("track_type and track_value are required for tracking resolve.");
+        }
+        return {
+            method: "GET",
+            pathSuffix: buildPathWithQuery("", {
+                workspace_id: workspaceId || undefined,
+                resolve: "true",
+                track_type: payload.track_type,
+                track_value: payload.track_value,
+                platform: payload.platform,
+                region: payload.region,
+            }),
+            body: undefined,
+            workspaceId,
+        };
+    }
+    if (action === "update" || action === "item_update") {
+        const itemId = coercePositiveInteger(payload.item_id, "item_id");
+        if (!itemId) {
+            throw missingArgument("item_id is required for tracking update.");
+        }
+        return {
+            method: "PATCH",
+            pathSuffix: buildPathWithQuery(`/${itemId}`, { workspace_id: workspaceId || undefined }),
+            body: stripUndefinedEntries({
+                refresh_frequency: payload.refresh_frequency,
+                next_refresh_at: payload.next_refresh_at,
+            }),
+            workspaceId,
+        };
+    }
+    if (action === "delete" || action === "item_delete") {
+        const itemId = coercePositiveInteger(payload.item_id, "item_id");
+        if (!itemId) {
+            throw missingArgument("item_id is required for tracking delete.");
+        }
+        return {
+            method: "DELETE",
+            pathSuffix: buildPathWithQuery(`/${itemId}`, { workspace_id: workspaceId || undefined }),
+            body: undefined,
+            workspaceId,
+        };
+    }
+    if (action === "refresh" || action === "item_refresh") {
+        const itemId = coercePositiveInteger(payload.item_id, "item_id");
+        if (!itemId) {
+            throw missingArgument("item_id is required for tracking refresh.");
+        }
+        return {
+            method: "POST",
+            pathSuffix: buildPathWithQuery(`/${itemId}/refresh`, { workspace_id: workspaceId || undefined }),
+            body: {},
+            workspaceId,
+        };
+    }
+    throw invalidArgument(`Unsupported tracking action: ${String(payload.action)}. Supported tracking actions: list, get, resolve, create, update, delete, refresh.`);
+}
+function translateGroupManagementAction(payload, workspaceId) {
+    const action = payload.action ? String(payload.action).toLowerCase() : null;
+    if (!action || action === "create" || action === "group_create") {
+        return {
+            method: "POST",
+            pathSuffix: buildPathWithQuery("/groups", { workspace_id: workspaceId || undefined }),
+            body: stripUndefinedEntries({
+                name: payload.name,
+                description: payload.description,
+                platform: payload.platform,
+                refresh_frequency: payload.refresh_frequency,
+                next_refresh_at: payload.next_refresh_at,
+                brand_id: payload.brand_id,
+            }),
+            workspaceId,
+        };
+    }
+    if (action === "list" || action === "group_list") {
+        return {
+            method: "GET",
+            pathSuffix: buildPathWithQuery("/groups", { workspace_id: workspaceId || undefined }),
+            body: undefined,
+            workspaceId,
+        };
+    }
+    if (action === "get" || action === "group_get") {
+        const groupId = coercePositiveInteger(payload.group_id, "group_id");
+        if (!groupId) {
+            throw missingArgument("group_id is required for group get.");
+        }
+        return {
+            method: "GET",
+            pathSuffix: buildPathWithQuery(`/groups/${groupId}`, { workspace_id: workspaceId || undefined }),
+            body: undefined,
+            workspaceId,
+        };
+    }
+    if (action === "update" || action === "group_update") {
+        const groupId = coercePositiveInteger(payload.group_id, "group_id");
+        if (!groupId) {
+            throw missingArgument("group_id is required for group update.");
+        }
+        return {
+            method: "PATCH",
+            pathSuffix: buildPathWithQuery(`/groups/${groupId}`, { workspace_id: workspaceId || undefined }),
+            body: stripUndefinedEntries({
+                name: payload.name,
+                description: payload.description,
+                refresh_frequency: payload.refresh_frequency,
+                next_refresh_at: payload.next_refresh_at,
+                brand_id: payload.brand_id,
+            }),
+            workspaceId,
+        };
+    }
+    if (action === "delete" || action === "group_delete") {
+        const groupId = coercePositiveInteger(payload.group_id, "group_id");
+        if (!groupId) {
+            throw missingArgument("group_id is required for group delete.");
+        }
+        return {
+            method: "DELETE",
+            pathSuffix: buildPathWithQuery(`/groups/${groupId}`, { workspace_id: workspaceId || undefined }),
+            body: undefined,
+            workspaceId,
+        };
+    }
+    if (action === "refresh" || action === "group_refresh") {
+        const groupId = coercePositiveInteger(payload.group_id, "group_id");
+        if (!groupId) {
+            throw missingArgument("group_id is required for group refresh.");
+        }
+        return {
+            method: "POST",
+            pathSuffix: buildPathWithQuery(`/groups/${groupId}/refresh`, { workspace_id: workspaceId || undefined }),
+            body: {},
+            workspaceId,
+        };
+    }
+    if (action === "list_items" || action === "group_list_items") {
+        const groupId = coercePositiveInteger(payload.group_id, "group_id");
+        if (!groupId) {
+            throw missingArgument("group_id is required for group list_items.");
+        }
+        return {
+            method: "GET",
+            pathSuffix: buildPathWithQuery(`/groups/${groupId}/items`, {
+                workspace_id: workspaceId || undefined,
+                page: Number.isFinite(payload.page) ? payload.page : undefined,
+                limit: Number.isFinite(payload.limit) ? payload.limit : undefined,
+            }),
+            body: undefined,
+            workspaceId,
+        };
+    }
+    if (action === "add_item" || action === "group_add_item") {
+        const groupId = coercePositiveInteger(payload.group_id, "group_id");
+        if (!groupId) {
+            throw missingArgument("group_id is required for group add_item.");
+        }
+        return {
+            method: "POST",
+            pathSuffix: buildPathWithQuery(`/groups/${groupId}/items`, { workspace_id: workspaceId || undefined }),
+            body: buildSingleGroupAddBody(payload),
+            workspaceId,
+        };
+    }
+    if (action === "add_items" || action === "group_add_items") {
+        const groupId = coercePositiveInteger(payload.group_id, "group_id");
+        if (!groupId) {
+            throw missingArgument("group_id is required for group add_items.");
+        }
+        return {
+            method: "POST",
+            pathSuffix: buildPathWithQuery(`/groups/${groupId}/items/bulk`, { workspace_id: workspaceId || undefined }),
+            body: buildBulkGroupAddBody(payload),
+            workspaceId,
+        };
+    }
+    if (action === "completeness" || action === "group_completeness") {
+        const groupId = coercePositiveInteger(payload.group_id, "group_id");
+        if (!groupId) {
+            throw missingArgument("group_id is required for group completeness.");
+        }
+        const expectedItems = Array.isArray(payload.expected_items)
+            ? payload.expected_items
+            : (Array.isArray(payload.items) ? payload.items : undefined);
+        return {
+            method: "POST",
+            pathSuffix: buildPathWithQuery(`/groups/${groupId}/completeness`, {
+                workspace_id: workspaceId || undefined,
+            }),
+            body: stripUndefinedEntries({
+                expected_items: expectedItems,
+                include_refresh_status: firstDefined(payload, ["include_refresh_status", "includeRefreshStatus"]),
+            }),
+            workspaceId,
+        };
+    }
+    if (action === "remove_item" || action === "group_remove_item") {
+        const groupId = coercePositiveInteger(payload.group_id, "group_id");
+        const itemId = coercePositiveInteger(payload.item_id, "item_id");
+        if (!groupId || !itemId) {
+            throw missingArgument("group_id and item_id are required for group remove_item.");
+        }
+        return {
+            method: "DELETE",
+            pathSuffix: buildPathWithQuery(`/groups/${groupId}/items/${itemId}`, {
+                workspace_id: workspaceId || undefined,
+            }),
+            body: undefined,
+            workspaceId,
+        };
+    }
+    throw invalidArgument(`Unsupported group-management action: ${String(payload.action)}. Supported group-management actions: list, get, create, update, delete, refresh, list_items, add_item, add_items, completeness, remove_item.`);
+}
+function translateBrandGroupAction(payload, workspaceId) {
+    const action = payload.action ? String(payload.action).toLowerCase() : null;
+    const brandGroupId = payload.brand_group_id || undefined;
+    const effectiveWorkspaceId = payload.workspace_id || workspaceId || undefined;
+    if (!action || action === "create") {
+        return {
+            method: "POST",
+            pathSuffix: "",
+            body: stripUndefinedEntries({
+                name: payload.name,
+                description: payload.description,
+                workspace_id: effectiveWorkspaceId,
+            }),
+            workspaceId: workspaceId || null,
+        };
+    }
+    if (action === "list") {
+        return {
+            method: "GET",
+            pathSuffix: buildPathWithQuery("", { workspace_id: effectiveWorkspaceId }),
+            body: undefined,
+            workspaceId: workspaceId || null,
+        };
+    }
+    if (action === "update") {
+        if (!brandGroupId) {
+            throw missingArgument("brand_group_id is required for brand-group update.");
+        }
+        return {
+            method: "PATCH",
+            pathSuffix: `/${brandGroupId}`,
+            body: stripUndefinedEntries({
+                name: payload.name,
+                description: payload.description,
+            }),
+            workspaceId: workspaceId || null,
+        };
+    }
+    if (action === "delete") {
+        if (!brandGroupId) {
+            throw missingArgument("brand_group_id is required for brand-group delete.");
+        }
+        return {
+            method: "DELETE",
+            pathSuffix: `/${brandGroupId}`,
+            body: undefined,
+            workspaceId: workspaceId || null,
+        };
+    }
+    if (action === "add_member") {
+        if (!brandGroupId || !payload.brand_id) {
+            throw missingArgument("brand_group_id and brand_id are required for brand-group add_member.");
+        }
+        return {
+            method: "POST",
+            pathSuffix: `/${brandGroupId}/members`,
+            body: { brand_id: payload.brand_id },
+            workspaceId: workspaceId || null,
+        };
+    }
+    if (action === "remove_member") {
+        if (!brandGroupId || !payload.brand_id) {
+            throw missingArgument("brand_group_id and brand_id are required for brand-group remove_member.");
+        }
+        return {
+            method: "DELETE",
+            pathSuffix: `/${brandGroupId}/members/${payload.brand_id}`,
+            body: undefined,
+            workspaceId: workspaceId || null,
+        };
+    }
+    throw invalidArgument(`Unsupported brand-group-management action: ${String(payload.action)}. Supported brand-group-management actions: list, create, update, delete, add_member, remove_member.`);
+}
+export function translateToolInvocation(options) {
+    const { toolName, payload, workspaceId } = options;
+    if (toolName === "tracking") {
+        const normalizedPayload = normalizeTrackingPayload(payload, workspaceId);
+        const effectiveWorkspaceId = normalizedPayload.workspaceId || workspaceId || null;
+        const translated = translateTrackingAction(normalizedPayload, effectiveWorkspaceId);
+        return { ...translated, normalizedPayload };
+    }
+    if (toolName === "group-management") {
+        const normalizedPayload = normalizeGroupManagementPayload(payload, workspaceId);
+        const effectiveWorkspaceId = normalizedPayload.workspaceId || workspaceId || null;
+        const translated = translateGroupManagementAction(normalizedPayload, effectiveWorkspaceId);
+        return { ...translated, normalizedPayload };
+    }
+    if (toolName === "brand-group-management") {
+        const normalizedPayload = normalizeBrandGroupPayload(payload, workspaceId);
+        const effectiveWorkspaceId = normalizedPayload.workspaceId || workspaceId || null;
+        const translated = translateBrandGroupAction(normalizedPayload, effectiveWorkspaceId);
+        return { ...translated, normalizedPayload };
+    }
+    if (toolName === "export_tracking_data") {
+        const normalizedPayload = normalizeTrackingExportPayload(payload, workspaceId);
+        return {
+            method: "POST",
+            pathSuffix: "",
+            body: normalizedPayload,
+            workspaceId: normalizedPayload.workspace_id || workspaceId || null,
+            normalizedPayload,
+        };
+    }
+    return null;
+}
+// --- search_results_enriched report shim (CLI: data export-report/export-search-results) ---
+export const SEARCH_RESULTS_ENRICHED_REPORT_TYPE = "search_results_enriched";
+export const EXPORT_DATA_TEMPLATE_TRACKING_RANKED_VIDEOS_RAW = "tracking_ranked_videos_raw";
+function normalizePositiveIntegerList(value, label, { max } = {}) {
+    if (value === undefined || value === null || value === "")
+        return [];
+    const entries = Array.isArray(value)
+        ? value
+        : String(value)
+            .split(",")
+            .map((entry) => entry.trim())
+            .filter(Boolean);
+    const parsed = entries.map((entry, index) => {
+        const normalized = coercePositiveInteger(entry, `${label}[${index}]`);
+        if (!normalized) {
+            throw invalidArgument(`Invalid ${label}[${index}] value.`);
+        }
+        return normalized;
+    });
+    const deduped = Array.from(new Set(parsed));
+    if (max && deduped.length > max) {
+        throw invalidArgument(`Too many ${label} values: received ${deduped.length}, max is ${max}.`);
+    }
+    return deduped;
+}
+function normalizeIsoDateTime(value, label) {
+    if (value === undefined || value === null || value === "")
+        return undefined;
+    if (typeof value !== "string") {
+        throw invalidArgument(`Invalid ${label}: expected an ISO datetime string.`);
+    }
+    const epoch = Date.parse(value.trim());
+    if (Number.isNaN(epoch)) {
+        throw invalidArgument(`Invalid ${label}: expected an ISO datetime string.`, value);
+    }
+    return new Date(epoch).toISOString();
+}
+export function buildSearchResultsEnrichedExportPayload(rawPayload, workspaceId) {
+    const payload = isJsonObject(rawPayload) ? rawPayload : {};
+    const groupIds = normalizePositiveIntegerList(firstDefined(payload, ["groupIds", "group_ids"]), "groupIds", { max: 100 });
+    if (groupIds.length === 0) {
+        throw missingArgument("search_results_enriched export requires at least one group id. Include groupIds in payload.");
+    }
+    const trackingItemIds = normalizePositiveIntegerList(firstDefined(payload, ["trackingItemIds", "tracking_item_ids"]), "trackingItemIds", { max: 1000 });
+    const dateFrom = normalizeIsoDateTime(firstDefined(payload, ["dateFrom", "date_from"]), "dateFrom");
+    const dateTo = normalizeIsoDateTime(firstDefined(payload, ["dateTo", "date_to"]), "dateTo");
+    const filename = trimString(firstDefined(payload, ["filename"])) || undefined;
+    return {
+        payload: stripUndefinedEntries({
+            workspaceId,
+            groupIds,
+            trackingItemIds: trackingItemIds.length > 0 ? trackingItemIds : undefined,
+            dateFrom,
+            dateTo,
+        }),
+        filename,
+    };
+}
+//# sourceMappingURL=translation.js.map