@okostream/mcp 0.12.1 → 0.12.3

package/dist/tools/live.js

@@ -1,190 +0,0 @@
-// Управление тем, что зритель видит прямо сейчас.
-//
-// Это не управление видео: поток идёт из плеера организатора. Отсюда
-// меняются видимость блоков, режим чата, плашка эфира и обновление страниц.
-// У события нет статуса — только живое состояние в RTDB.
-import { z } from "zod";
-import { requireConfirm, textResult } from "../utils.js";
-import { authed } from "./context.js";
-import { basicEventOutputSchema, boolOrNull, eventIdField, idempotentWriteTool, liveStateOutputSchema, readOnlyTool, toolDescription, writeTool } from "./schemas.js";
-import { chatRtdb, functions, rtdb } from "../firebase.js";
-import { get, ref, remove, set } from "firebase/database";
-import { httpsCallable } from "firebase/functions";
-import { readEvent } from "./eventAccess.js";
-export function registerLiveTools(server) {
-    server.registerTool("oko_get_live_state", {
-        title: "Get live state",
-        description: toolDescription({
-            summary: "Read main RTDB live controls, aggregate analytics, and chat settings for an event.",
-            args: ["eventId: event to inspect."],
-            returns: "eventId, agg metrics, ctrl live overrides, and chat settings.",
-            examples: ["Use during a webinar before changing live block visibility or starting/ending sessions."],
-        }),
-        inputSchema: { eventId: eventIdField },
-        outputSchema: liveStateOutputSchema,
-        annotations: readOnlyTool,
-    }, async ({ eventId }) => {
-        const { uid } = await authed(["analytics:read"]);
-        await readEvent(eventId, uid, "analytics");
-        const [aggSnap, ctrlSnap, chatSettingsSnap] = await Promise.all([
-            get(ref(rtdb, `events/${eventId}/agg`)),
-            get(ref(rtdb, `events/${eventId}/ctrl`)),
-            get(ref(chatRtdb, `settings/${eventId}`)),
-        ]);
-        return textResult({ eventId, agg: aggSnap.val() ?? {}, ctrl: ctrlSnap.val() ?? {}, chat: chatSettingsSnap.val() ?? {} });
-    });
-    server.registerTool("oko_set_block_visibility", {
-        title: "Set live block visibility",
-        description: toolDescription({
-            summary: "Set or reset a live RTDB visibility override for a public event block.",
-            args: ["eventId: event to control.", "block: chat, banner, cta, cards, or placeholder.", "visible: true/false, or null to reset override.", "confirm: must be true."],
-            returns: "eventId, block, and effective override value.",
-            examples: ["Use visible=false to hide the CTA live; use visible=null to return to setup defaults."],
-            notes: [
-                "block=chat with visible=false PAUSES message input: viewers keep seeing the chat history but cannot send. It does not hide the chat panel.",
-            ],
-        }),
-        inputSchema: {
-            eventId: eventIdField,
-            block: z.enum(["chat", "banner", "cta", "cards", "placeholder"]).describe("Public block whose live override should change."),
-            visible: boolOrNull.describe("true/false to force visibility, null to reset override."),
-            confirm: z.boolean().optional().describe("Required true for live visibility change."),
-        },
-        outputSchema: basicEventOutputSchema,
-        annotations: idempotentWriteTool,
-    }, async ({ eventId, block, visible, confirm }) => {
-        const { uid } = await authed(["live:control"]);
-        await readEvent(eventId, uid, "live");
-        requireConfirm(confirm, "oko_set_block_visibility", { eventId, block, visible });
-        const paths = {
-            chat: "chatVisible",
-            banner: "bannerVisible",
-            cta: "ctaVisible",
-            cards: "cardsVisible",
-            placeholder: "placeholderVisible",
-        };
-        const target = ref(rtdb, `events/${eventId}/ctrl/${paths[block]}`);
-        if (visible === null)
-            await remove(target);
-        else
-            await set(target, visible);
-        return textResult({ eventId, block, visible });
-    });
-    server.registerTool("oko_refresh_viewers", {
-        title: "Refresh viewers",
-        description: toolDescription({
-            summary: "Trigger a live viewer refresh tick for an event.",
-            args: ["eventId: event whose viewers should refresh.", "confirm: must be true."],
-            returns: "eventId and refreshed=true.",
-            examples: ["Use after a setup/live change if viewers should reload state immediately."],
-        }),
-        inputSchema: { eventId: eventIdField, confirm: z.boolean().optional().describe("Required true to refresh connected viewers.") },
-        outputSchema: basicEventOutputSchema,
-        annotations: writeTool,
-    }, async ({ eventId, confirm }) => {
-        const { uid } = await authed(["live:control"]);
-        await readEvent(eventId, uid, "live");
-        requireConfirm(confirm, "oko_refresh_viewers", { eventId });
-        await set(ref(rtdb, `events/${eventId}/ctrl/refreshTick`), Date.now());
-        return textResult({ eventId, refreshed: true });
-    });
-    server.registerTool("oko_set_live_badge", {
-        title: "Set live badge",
-        description: toolDescription({
-            summary: "Control the public 'Live' badge on the event page.",
-            args: [
-                "eventId: event to control.",
-                "mode: session (follows the analytics session, product default), manual (badge shown now for durationMinutes), schedule (shown around meta.eventDate), hidden (never shown).",
-                "durationMinutes: badge window for manual/schedule, 15-1440 minutes, default 120.",
-                "confirm: must be true.",
-            ],
-            returns: "eventId, mode, durationMinutes.",
-            examples: ['Use mode="manual" during an unscheduled stream; return to mode="session" afterwards.'],
-            notes: ["The badge is a page indicator only; it never starts or stops video or analytics."],
-        }),
-        inputSchema: {
-            eventId: eventIdField,
-            mode: z.enum(["session", "manual", "schedule", "hidden"]).describe("Live badge mode."),
-            durationMinutes: z.number().int().min(15).max(1440).optional().describe("Badge window in minutes for manual/schedule modes; default 120."),
-            confirm: z.boolean().optional().describe("Required true to change the public live badge."),
-        },
-        outputSchema: basicEventOutputSchema,
-        annotations: idempotentWriteTool,
-    }, async ({ eventId, mode, durationMinutes, confirm }) => {
-        const { uid } = await authed(["live:control"]);
-        await readEvent(eventId, uid, "live");
-        requireConfirm(confirm, "oko_set_live_badge", { eventId, mode, durationMinutes: durationMinutes ?? null });
-        const value = { mode, durationMinutes: durationMinutes ?? 120 };
-        await set(ref(rtdb, `events/${eventId}/ctrl/liveBadge`), value);
-        return textResult({ eventId, ...value });
-    });
-    server.registerTool("oko_set_chat_mode", {
-        title: "Set chat mode",
-        description: toolDescription({
-            summary: "Set who can send chat messages on the public event page.",
-            args: [
-                "eventId: event to control.",
-                "mode: public (anyone), auth (signed-in viewers only), owner (organizers only), off (input closed, history stays visible), or null to reset to the product default (public).",
-                "confirm: must be true.",
-            ],
-            returns: "eventId and the effective chat mode.",
-            examples: ['Use mode="off" to pause a chat storm; use mode=null or "public" to reopen.'],
-            notes: [
-                'This is the full replacement for the legacy pause via oko_set_block_visibility(block="chat"): prefer oko_set_chat_mode.',
-                "History always stays visible to viewers; mode only gates sending.",
-            ],
-        }),
-        inputSchema: {
-            eventId: eventIdField,
-            mode: z.enum(["public", "auth", "owner", "off"]).nullable().describe("Chat mode; null resets the override to the default."),
-            confirm: z.boolean().optional().describe("Required true to change the live chat mode."),
-        },
-        outputSchema: basicEventOutputSchema,
-        annotations: idempotentWriteTool,
-    }, async ({ eventId, mode, confirm }) => {
-        const { uid } = await authed(["live:control"]);
-        await readEvent(eventId, uid, "live");
-        requireConfirm(confirm, "oko_set_chat_mode", { eventId, mode });
-        const target = ref(rtdb, `events/${eventId}/ctrl/chatMode`);
-        if (mode === null)
-            await remove(target);
-        else
-            await set(target, mode);
-        return textResult({ eventId, mode });
-    });
-    server.registerTool("oko_force_viewer_reload", {
-        title: "Force viewer reload",
-        description: toolDescription({
-            summary: "Force a hard page reload for every connected viewer (emergency recovery).",
-            args: ["eventId: event whose viewer pages must reload.", "confirm: must be true."],
-            returns: "eventId and reloaded=true.",
-            examples: ["Use only when viewer pages are stuck (broken bundle or state) and oko_refresh_viewers did not help."],
-            notes: [
-                "Server enforces a 120-second cooldown per event; a repeated call returns the seconds left.",
-                "Viewers reload with up to 4 seconds of jitter. Prefer oko_refresh_viewers for ordinary content updates.",
-            ],
-        }),
-        inputSchema: {
-            eventId: eventIdField,
-            confirm: z.boolean().optional().describe("Required true to hard-reload all viewer pages."),
-        },
-        outputSchema: basicEventOutputSchema,
-        annotations: writeTool,
-    }, async ({ eventId, confirm }) => {
-        const { uid } = await authed(["live:control"]);
-        await readEvent(eventId, uid, "live");
-        requireConfirm(confirm, "oko_force_viewer_reload", { eventId });
-        const forceReload = httpsCallable(functions, "forceViewerReload");
-        try {
-            await forceReload({ eventId });
-        }
-        catch (error) {
-            const details = error.details;
-            if (typeof details?.retryInSec === "number") {
-                throw new Error(`Force reload is cooling down: retry in ${details.retryInSec} seconds.`);
-            }
-            throw error;
-        }
-        return textResult({ eventId, reloaded: true });
-    });
-}

package/dist/tools/notifications.js

@@ -1,105 +0,0 @@
-// Внутренние уведомления организатора: чтение ленты и отметка прочитанным.
-//
-// Документы создают только Cloud Functions; отсюда доступны чтение, отметка
-// и удаление своих. Текст уведомления не хранится — клиент собирает его из
-// типа и meta, поэтому наружу уходит структура, а не готовая строка.
-import { collection, doc, getDocs, limit, orderBy, query, startAfter, updateDoc } from "firebase/firestore";
-import { z } from "zod";
-import { firestore } from "../firebase.js";
-import { serialize, textResult } from "../utils.js";
-import { authed } from "./context.js";
-import { cursorMeta, parseTimestampCursor, pickPage, timestampCursorFrom } from "./formatting.js";
-import { cursorField, idempotentWriteTool, limitField, notificationsMarkOutputSchema, notificationsOutputSchema, readOnlyTool, toolDescription } from "./schemas.js";
-export function registerNotificationTools(server) {
-    server.registerTool("oko_list_notifications", {
-        title: "List notifications",
-        description: toolDescription({
-            summary: "List in-app notifications for the authenticated organizer.",
-            args: [
-                "unreadOnly: only unread notifications, default false.",
-                "limit: max notifications, default 20, max 100.",
-                "cursor: createdAt cursor returned as nextCursor by the previous page.",
-            ],
-            returns: "notifications plus unreadCountOnPage and cursor pagination metadata.",
-            examples: ["Use when the organizer asks what changed in OKO or what notifications are waiting."],
-        }),
-        inputSchema: {
-            unreadOnly: z.boolean().default(false).describe("Return only unread notifications."),
-            limit: limitField(100, 20),
-            cursor: cursorField,
-        },
-        outputSchema: notificationsOutputSchema,
-        annotations: readOnlyTool,
-    }, async ({ unreadOnly, limit: max, cursor }) => {
-        const { uid } = await authed(["workspace:read"]);
-        const fetchLimit = unreadOnly ? Math.min(max * 5 + 1, 501) : max + 1;
-        const constraints = [
-            orderBy("createdAt", "desc"),
-            limit(fetchLimit),
-        ];
-        if (cursor)
-            constraints.splice(1, 0, startAfter(parseTimestampCursor(cursor)));
-        const snap = await getDocs(query(collection(firestore, "userNotifications", uid, "items"), ...constraints));
-        const matchingDocs = unreadOnly ? snap.docs.filter((item) => item.data().read !== true) : snap.docs;
-        const { page, hasMore: hasMoreInMatches } = pickPage(matchingDocs, max);
-        const hasMore = hasMoreInMatches || snap.docs.length >= fetchLimit;
-        const cursorSource = hasMoreInMatches ? page.at(-1) : snap.docs.at(-1);
-        const notifications = page.map((item) => ({ id: item.id, ...serialize(item.data()) }));
-        const nextCursor = hasMore ? timestampCursorFrom(cursorSource?.data().createdAt) : null;
-        return textResult({
-            notifications,
-            unreadCountOnPage: notifications.filter((item) => item.read !== true).length,
-            ...cursorMeta(notifications.length, max, hasMore, nextCursor),
-        });
-    });
-    server.registerTool("oko_mark_notifications_read", {
-        title: "Mark notifications read",
-        description: toolDescription({
-            summary: "Mark own OKO in-app notifications as read.",
-            args: [
-                "notificationIds: optional explicit notification ids, max 100.",
-                "allUnread: true to mark unread notifications on the first page, max controlled by limit.",
-                "limit: when allUnread=true, max unread notifications to mark, default 100, max 200.",
-            ],
-            returns: "markedRead count and notification ids updated.",
-            examples: ["Use after oko_list_notifications when the user asks to clear the bell/unread state."],
-            notes: ["Provide either notificationIds or allUnread=true. This can update only the current organizer's own notifications."],
-        }),
-        inputSchema: {
-            notificationIds: z.array(z.string().min(1).max(160)).max(100).optional().describe("Specific notification document ids."),
-            allUnread: z.boolean().default(false).describe("Mark unread notifications as read."),
-            limit: limitField(200, 100),
-        },
-        outputSchema: notificationsMarkOutputSchema,
-        annotations: idempotentWriteTool,
-    }, async ({ notificationIds, allUnread, limit: max }) => {
-        // 🔴 Гейт намеренно на запись, хотя инструмент читается как «пометить
-        // прочитанным». Он делает `updateDoc` и сам помечен `idempotentWriteTool`;
-        // пока гейтом стоял `workspace:read`, ключ пресета `readOnly`
-        // (`events:read · analytics:read · workspace:read · leads:read`) мог
-        // погасить до 200 уведомлений организатора. Единственный смысл пресета
-        // «только чтение» — что он не пишет. Ущерб здесь не в чужих данных
-        // (пишем только в свои), а в нарушенном обещании: организатор не увидит
-        // уведомлений о выданных правах и созданных событиях.
-        const { uid } = await authed(["workspace:write"]);
-        if (Boolean(notificationIds?.length) === allUnread) {
-            throw new Error("Provide either notificationIds or allUnread=true.");
-        }
-        let ids = [...new Set(notificationIds ?? [])];
-        if (allUnread) {
-            // 🔴 Отбор обязан совпадать с тем, что список ПОКАЗЫВАЕТ как
-            // непрочитанное, иначе получается неустранимая петля: список считает
-            // непрочитанным всё, где `read !== true` (в том числе документ без
-            // поля), а `where("read", "==", false)` документ без поля не находит —
-            // и не находит его же `where("read", "!=", true)`, потому что запросы
-            // с неравенством в Firestore пропускают документы без поля вовсе.
-            // Такое уведомление висело бы вечно, а модель не могла бы его погасить.
-            // Поэтому фильтруем клиентом тем же предикатом, что и список, набирая
-            // с запасом — приём уже применён в `oko_list_notifications` выше.
-            const snap = await getDocs(query(collection(firestore, "userNotifications", uid, "items"), limit(Math.min(max * 5 + 1, 501))));
-            ids = snap.docs.filter((item) => item.data().read !== true).slice(0, max).map((item) => item.id);
-        }
-        await Promise.all(ids.map((id) => updateDoc(doc(firestore, "userNotifications", uid, "items", id), { read: true })));
-        return textResult({ markedRead: ids.length, notificationIds: ids });
-    });
-}

package/dist/tools/schemas.js

@@ -1,296 +0,0 @@
-// Схемы ввода и вывода инструментов MCP плюс их аннотации.
-//
-// Схема вывода — часть публичного контракта: клиент проверяет по ней
-// structuredContent, и запись, прошедшая в базу при непрошедшей схеме, даёт
-// худший из исходов — побочный эффект с последующим отказом. Поэтому схемы
-// пропускают дополнительные поля (`passthrough`), а не ломаются на них.
-//
-// Аннотации (readOnly / write / idempotent / destructive) читает клиент,
-// решая, спрашивать ли подтверждение. Инвентарь и области доступа —
-// в `public-contract.json`, он же эталон для protocol-теста.
-import { z } from "zod";
-import { OKO_CONNECTION_STATUSES } from "../onboarding.js";
-import { canonicalTelegramChannelSchema } from "../telegramChannelSchema.js";
-import { CARD_IMAGE_RATIOS, IMAGE_KINDS } from "./imagePipeline.js";
-export const boolOrNull = z.boolean().nullable();
-export const DEFAULT_LIST_LIMIT = 30;
-export const MAX_LIST_LIMIT = 100;
-export const MAX_EXPORT_LIMIT = 200;
-export const ANALYTICS_DEFAULT_LIMIT = 10;
-export const ANALYTICS_TIMELINE_DEFAULT_LIMIT = 120;
-export const MAX_WORKSPACE_NAME_LENGTH = 120;
-export const MAX_WORKSPACE_INVITE_CODE_LENGTH = 64;
-export const TELEGRAM_POST_STATUSES = ["draft", "scheduled", "sent", "failed", "delivery_unknown"];
-export const readOnlyTool = {
-    readOnlyHint: true,
-    destructiveHint: false,
-    idempotentHint: true,
-    openWorldHint: true,
-};
-export const writeTool = {
-    readOnlyHint: false,
-    destructiveHint: false,
-    idempotentHint: false,
-    openWorldHint: true,
-};
-export const idempotentWriteTool = {
-    readOnlyHint: false,
-    destructiveHint: false,
-    idempotentHint: true,
-    openWorldHint: true,
-};
-export const destructiveTool = {
-    readOnlyHint: false,
-    destructiveHint: true,
-    idempotentHint: false,
-    openWorldHint: true,
-};
-export const unknownRecordSchema = z.record(z.unknown());
-export const basicEventOutputSchema = z.object({
-    eventId: z.string(),
-}).passthrough();
-export const updateOutputSchema = z.object({
-    id: z.string().optional(),
-    eventId: z.string().optional(),
-    updated: z.array(z.string()).optional(),
-}).passthrough();
-export const eventLinksOutputShape = {
-    url: z.string().url(),
-    setupUrl: z.string().url(),
-    analyticsUrl: z.string().url(),
-};
-export const createWebinarOutputSchema = z.object({
-    id: z.string(),
-    workspaceId: z.string(),
-    sourceEventId: z.string().optional(),
-    ...eventLinksOutputShape,
-}).passthrough();
-export const connectionStatusOutputSchema = z.object({
-    connected: z.boolean(),
-    status: z.enum(OKO_CONNECTION_STATUSES),
-    errorCode: z.string().nullable(),
-    message: z.string(),
-    product: z.object({
-        name: z.string(),
-        summary: z.string(),
-        videoBoundary: z.string(),
-        accountRequirement: z.string(),
-        accessModel: z.string(),
-    }),
-    organizerAccountRequired: z.boolean(),
-    credentialConfigured: z.boolean(),
-    links: z.object({
-        website: z.string().url(),
-        signIn: z.string().url(),
-        installCenter: z.string().url(),
-    }),
-    nextSteps: z.array(z.object({
-        id: z.string(),
-        label: z.string(),
-        url: z.string().url().optional(),
-        command: z.string().optional(),
-    })),
-    minimumVersion: z.string().optional(),
-    uid: z.string().optional(),
-    scopes: z.array(z.string()).optional(),
-});
-export const cursorMetaSchema = {
-    count: z.number().int().nonnegative(),
-    limit: z.number().int().positive(),
-    hasMore: z.boolean(),
-    nextCursor: z.string().nullable(),
-    has_more: z.boolean(),
-    next_cursor: z.string().nullable(),
-};
-export const workspacesOutputSchema = z.object({
-    workspaces: z.array(unknownRecordSchema),
-    count: z.number().int().nonnegative(),
-}).passthrough();
-export const eventsOutputSchema = z.object({
-    events: z.array(unknownRecordSchema),
-    ...cursorMetaSchema,
-}).passthrough();
-export const eventOutputSchema = z.object({
-    id: z.string(),
-    ...eventLinksOutputShape,
-}).passthrough();
-export const liveStateOutputSchema = z.object({
-    eventId: z.string(),
-    agg: unknownRecordSchema,
-    ctrl: unknownRecordSchema,
-    chat: unknownRecordSchema,
-}).passthrough();
-export const analyticsOutputSchema = z.object({
-    sessions: z.array(unknownRecordSchema),
-    ...cursorMetaSchema,
-}).passthrough();
-export const chatOutputSchema = z.object({
-    messages: z.array(unknownRecordSchema),
-    ...cursorMetaSchema,
-}).passthrough();
-export const leadsOutputSchema = z.object({
-    leads: z.array(unknownRecordSchema).optional(),
-    csv: z.string().optional(),
-    ...cursorMetaSchema,
-}).passthrough();
-export const imageOutputSchema = z.object({
-    eventId: z.string(),
-    kind: z.enum(IMAGE_KINDS),
-    imageId: z.string(),
-    storagePath: z.string(),
-    masterUrl: z.string().url(),
-    variantsPending: z.boolean(),
-    sourceBytes: z.number().int().nonnegative(),
-    masterBytes: z.number().int().nonnegative(),
-    imageWidth: z.number().int().positive(),
-    imageHeight: z.number().int().positive(),
-    note: z.string(),
-}).passthrough();
-export const deleteImageOutputSchema = z.object({
-    eventId: z.string(),
-    kind: z.enum(IMAGE_KINDS),
-    imageId: z.string().nullable(),
-    deleted: z.boolean(),
-    storageDeletesAttempted: z.number().int().nonnegative(),
-    storageDeleteWarnings: z.array(z.string()),
-}).passthrough();
-export const imageVariantsOutputSchema = z.object({
-    eventId: z.string(),
-    kind: z.enum(IMAGE_KINDS),
-    cardId: z.string().nullable(),
-    imageId: z.string().nullable(),
-    imageUrl: z.string().url().nullable(),
-    imageMasterUrl: z.string().url().nullable(),
-    imageVariants: unknownRecordSchema.nullable(),
-    ready: z.boolean(),
-    reason: z.string().nullable(),
-    elapsedMs: z.number().int().nonnegative(),
-}).passthrough();
-export const cardImagesBatchOutputSchema = z.object({
-    eventId: z.string(),
-    uploads: z.array(unknownRecordSchema),
-    variants: z.array(unknownRecordSchema),
-    ready: z.boolean(),
-    warnings: z.array(z.string()),
-}).passthrough();
-export const setupValidationOutputSchema = z.object({
-    eventId: z.string(),
-    ok: z.boolean(),
-    score: z.number().int().min(0).max(100),
-    errors: z.array(unknownRecordSchema),
-    warnings: z.array(unknownRecordSchema),
-    suggestions: z.array(unknownRecordSchema),
-    nextActions: z.array(z.string()),
-    links: unknownRecordSchema,
-}).passthrough();
-export const workspaceAccessOutputSchema = z.object({
-    workspaceId: z.string(),
-    workspace: unknownRecordSchema,
-    members: z.array(unknownRecordSchema),
-    invites: z.array(unknownRecordSchema),
-}).passthrough();
-export const telegramChannelsOutputSchema = z.object({
-    channels: z.array(canonicalTelegramChannelSchema),
-    count: z.number().int().nonnegative(),
-}).passthrough();
-export const telegramPostsOutputSchema = z.object({
-    posts: z.array(unknownRecordSchema),
-    ...cursorMetaSchema,
-}).passthrough();
-export const sessionReportOutputSchema = z.object({
-    eventId: z.string(),
-    sessionId: z.string(),
-    reportUrl: z.string().url(),
-    markdown: z.string(),
-    session: unknownRecordSchema,
-}).passthrough();
-export const profileOutputSchema = z.object({
-    uid: z.string(),
-    profile: unknownRecordSchema,
-    updated: z.array(z.string()),
-}).passthrough();
-export const deleteLeadOutputSchema = z.object({
-    eventId: z.string(),
-    leadId: z.string(),
-    deleted: z.boolean(),
-}).passthrough();
-export const notificationsOutputSchema = z.object({
-    notifications: z.array(unknownRecordSchema),
-    unreadCountOnPage: z.number().int().nonnegative(),
-    ...cursorMetaSchema,
-}).passthrough();
-export const notificationsMarkOutputSchema = z.object({
-    markedRead: z.number().int().nonnegative(),
-    notificationIds: z.array(z.string()),
-}).passthrough();
-export const formFieldSchema = z.object({
-    id: z.string().min(1).optional(),
-    label: z.string().max(120),
-    type: z.enum(["text", "tel", "email", "textarea"]).default("text"),
-    required: z.boolean().default(false),
-    placeholder: z.string().max(160).nullable().optional(),
-}).strict();
-export const formSchema = z.object({
-    id: z.string().min(1).optional(),
-    title: z.string().max(160).nullable().optional(),
-    description: z.string().max(1000).nullable().optional(),
-    submitLabel: z.string().max(80).nullable().optional(),
-    successText: z.string().max(500).nullable().optional(),
-    consentText: z.string().max(500).nullable().optional(),
-    consentRequired: z.boolean().default(true),
-    fields: z.array(formFieldSchema).max(30),
-}).strict();
-export const profileDisplayNameSchema = z.string().max(40).nullable();
-export const timezoneSchema = z.string()
-    .min(1)
-    .max(100)
-    .regex(/^[A-Za-z0-9_+./-]+$/, "Use an IANA timezone such as Europe/Moscow or UTC.");
-export const cardsConfigOutputSchema = z.object({
-    eventId: z.string(),
-    updated: z.array(z.string()),
-    cards: z.object({
-        enabled: z.boolean(),
-        visibility: z.enum(["always", "hidden"]),
-        cardImageRatio: z.enum(CARD_IMAGE_RATIOS),
-        items: z.array(unknownRecordSchema),
-    }).passthrough(),
-    generatedCardIds: z.array(z.string()),
-    removedCardIds: z.array(z.string()),
-    removedCardsWithImages: z.array(z.string()),
-    preservedImageCardIds: z.array(z.string()),
-    warnings: z.array(z.string()),
-}).passthrough();
-export const workspacePermissionsSchema = z.object({
-    createEvents: z.boolean().optional(),
-    editSetup: z.boolean().optional(),
-    deleteEvents: z.boolean().optional(),
-    controlLive: z.boolean().optional(),
-    moderateChat: z.boolean().optional(),
-    startSession: z.boolean().optional(),
-    viewAnalytics: z.boolean().optional(),
-    downloadReports: z.boolean().optional(),
-    sendNotifications: z.boolean().optional(),
-}).strict().default({});
-export const WORKSPACE_PERMISSION_KEYS = [
-    "createEvents",
-    "editSetup",
-    "deleteEvents",
-    "controlLive",
-    "moderateChat",
-    "startSession",
-    "viewAnalytics",
-    "downloadReports",
-    "sendNotifications",
-];
-export const eventIdField = z.string().min(1).describe("OKO event document id, for example KJsAku48821hB4PXTW0S.");
-export const limitField = (max = MAX_LIST_LIMIT, defaultValue = DEFAULT_LIST_LIMIT) => z.number().int().min(1).max(max).default(defaultValue).describe(`Maximum items to return, 1-${max}.`);
-export const cursorField = z.string().min(1).optional().describe("Cursor returned as nextCursor by the previous page.");
-export function toolDescription({ summary, args = [], returns, examples = [], notes = [], }) {
-    return [
-        summary,
-        args.length ? `Args:\n${args.map((item) => `- ${item}`).join("\n")}` : "",
-        `Returns:\n- ${returns}`,
-        examples.length ? `Examples:\n${examples.map((item) => `- ${item}`).join("\n")}` : "",
-        notes.length ? `Notes:\n${notes.map((item) => `- ${item}`).join("\n")}` : "",
-    ].filter(Boolean).join("\n\n");
-}