@okostream/mcp 0.21.0 → 0.22.1

package/dist/server.js

@@ -119137,7 +119137,7 @@ function sanitizeScopes(scopes) {
 }
 
 // build/version.js
-var OKO_MCP_VERSION = "0.21.0";
+var OKO_MCP_VERSION = "0.22.1";
 
 // build/auth.js
 var state = null;
@@ -119484,175 +119484,245 @@ function pinnedLookup(address, family) {
 // build/videoUrl.js
 var TWITCH_PARENT = "okostream.app";
 function extractIframeSrc(input) {
-  const trimmed = input.trim();
-  if (!trimmed.startsWith("<iframe"))
+  const tag = /<iframe\b[^>]*>/i.exec(input);
+  if (!tag)
     return null;
-  const match = trimmed.match(/\bsrc=["']([^"']+)["']/i);
-  return match?.[1] ?? null;
-}
-var YT_ID_RE = /^[\w-]{11}$/;
-function extractYouTubeId(url) {
-  let parsed;
-  try {
-    parsed = new URL(url);
-  } catch {
+  const match = /\bsrc\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'>]+))/i.exec(tag[0]);
+  const src = (match?.[1] ?? match?.[2] ?? match?.[3] ?? "").trim().replace(/&amp;/gi, "&");
+  if (!src)
     return null;
-  }
-  const host = parsed.hostname.replace(/^www\./, "");
-  if (host === "youtu.be") {
-    const id = parsed.pathname.slice(1).split("/")[0] ?? "";
-    return YT_ID_RE.test(id) ? id : null;
-  }
-  if (host !== "youtube.com" && host !== "m.youtube.com")
-    return null;
-  const path = parsed.pathname;
-  if (path.startsWith("/embed/")) {
-    const id = path.slice(7).split("/")[0] ?? "";
-    return YT_ID_RE.test(id) ? id : null;
-  }
-  if (path.startsWith("/shorts/")) {
-    const id = path.slice(8).split("/")[0] ?? "";
-    return YT_ID_RE.test(id) ? id : null;
-  }
-  if (path.startsWith("/live/")) {
-    const id = path.slice(6).split("/")[0] ?? "";
-    return YT_ID_RE.test(id) ? id : null;
-  }
-  if (path === "/watch") {
-    const id = parsed.searchParams.get("v") ?? "";
-    return YT_ID_RE.test(id) ? id : null;
-  }
-  return null;
+  return src.startsWith("//") ? `https:${src}` : src;
 }
-function hostOf(url) {
+function parseUrl(url) {
   try {
-    return new URL(url).hostname.replace(/^www\./, "").replace(/^m\./, "");
+    return new URL(url);
   } catch {
     return null;
   }
 }
-function extractVkVideoIds(url) {
-  let parsed;
-  try {
-    parsed = new URL(url);
-  } catch {
+var WRAP_START_RE = /^[<(\[{«„“"'`]+/;
+var WRAP_END_RE = /[>)\]}»“”"'`.,;:!?]+$/;
+var BARE_HOST_RE = /^(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z]{2,}(?::\d+)?(?:[/?#]|$)/i;
+function wordAsAddress(word, bare) {
+  let link = word.replace(WRAP_START_RE, "").replace(WRAP_END_RE, "").replace(/&amp;/gi, "&");
+  if (/^https?:\/\//i.test(link))
+    link = link.replace(/^http:/i, "https:");
+  else if (link.startsWith("//"))
+    link = `https:${link}`;
+  else if (bare && BARE_HOST_RE.test(link))
+    link = `https://${link}`;
+  else
     return null;
-  }
-  if (parsed.pathname.includes("video_ext.php")) {
-    const oid = parsed.searchParams.get("oid");
-    const id = parsed.searchParams.get("id");
-    return oid && id ? { oid, id } : null;
-  }
-  const match = parsed.pathname.match(/\/video(-?\d+)_(\d+)/);
-  return match ? { oid: match[1] ?? "", id: match[2] ?? "" } : null;
+  const parsed = parseUrl(link);
+  return parsed && parsed.hostname.includes(".") ? link : null;
 }
-function extractPathId(url, host, patterns) {
-  let parsed;
-  try {
-    parsed = new URL(url);
-  } catch {
-    return null;
-  }
-  if (parsed.hostname.replace(/^www\./, "") !== host && !parsed.hostname.endsWith(`.${host}`))
-    return null;
-  for (const pattern of patterns) {
-    const match = parsed.pathname.match(pattern);
-    if (match?.[1])
-      return match[1];
+function readVideoAddress(input) {
+  const fromCode = extractIframeSrc(input);
+  const words = fromCode !== null ? [fromCode] : input.split(/\s+/).filter(Boolean);
+  for (const bare of [false, true]) {
+    for (const word of words) {
+      const address = wordAsAddress(word, bare);
+      if (address !== null)
+        return address;
+    }
   }
   return null;
 }
-var VIMEO_EVENT_PATH_RE = /^\/event\/(\d+)(?:\/embed(?:\/([A-Za-z0-9]+))?)?\/?$/;
-function extractVimeoEventEmbed(url) {
-  let parsed;
-  try {
-    parsed = new URL(url);
-  } catch {
-    return null;
-  }
-  if (parsed.hostname.replace(/^www\./, "") !== "vimeo.com")
-    return null;
-  const event = parsed.pathname.match(VIMEO_EVENT_PATH_RE);
-  return event ? `https://vimeo.com/event/${event[1]}/embed${event[2] ? `/${event[2]}` : ""}` : null;
+function withTwitchParent(parsed) {
+  const params = new URLSearchParams(parsed.search);
+  params.delete("parent");
+  params.append("parent", TWITCH_PARENT);
+  return `${parsed.origin}${parsed.pathname}?${params.toString()}`;
 }
-function extractTwitchEmbed(url) {
-  let parsed;
-  try {
-    parsed = new URL(url);
-  } catch {
-    return null;
-  }
-  const host = parsed.hostname.replace(/^www\./, "");
-  if (host === "player.twitch.tv") {
-    const channel = parsed.searchParams.get("channel");
-    const video = parsed.searchParams.get("video");
-    if (channel)
-      return `https://player.twitch.tv/?channel=${channel}&parent=${TWITCH_PARENT}`;
-    if (video)
-      return `https://player.twitch.tv/?video=${video}&parent=${TWITCH_PARENT}`;
-  }
-  if (host === "twitch.tv") {
-    const vodMatch = parsed.pathname.match(/\/videos\/(\d+)/);
-    if (vodMatch?.[1])
-      return `https://player.twitch.tv/?video=v${vodMatch[1]}&parent=${TWITCH_PARENT}`;
-    const channelMatch = parsed.pathname.match(/^\/([a-zA-Z0-9_]+)$/);
-    if (channelMatch?.[1])
-      return `https://player.twitch.tv/?channel=${channelMatch[1]}&parent=${TWITCH_PARENT}`;
+var YT_ID_RE = /^[\w-]{11}$/;
+var VK_HOSTS = /* @__PURE__ */ new Set(["vk.com", "vk.ru", "vkvideo.ru"]);
+var VK_VIDEO_RE = /(?:video|clip)(-?\d+)_(\d+)/;
+var VIMEO_EVENT_PATH_RE = /^\/event\/(\d+)(?:\/embed(?:\/([A-Za-z0-9]+))?)?\/?$/;
+var VIMEO_VIDEO_PATH_RE = /^\/(?:(?:channels\/[^/]+|groups\/[^/]+\/videos|showcase\/[^/]+\/video|album\/[^/]+\/video)\/)?(\d+)(?:\/([0-9a-z]+))?\/?$/i;
+var KINESCOPE_NOT_A_VIDEO = /* @__PURE__ */ new Set(["embed", "pl", "playlist", "chat"]);
+var bareHost = (host) => host.replace(/^(?:www|m)\./, "");
+var SERVICES = [
+  {
+    provider: "youtube",
+    owns: (host) => ["youtube.com", "music.youtube.com", "youtu.be", "youtube-nocookie.com"].includes(bareHost(host)),
+    player: (parsed, address, host) => {
+      const site = bareHost(host);
+      if (site !== "youtube.com" && site !== "youtube-nocookie.com")
+        return null;
+      const match = /^\/embed(?:\/([^/]*))?\/?$/.exec(parsed.pathname);
+      if (!match)
+        return null;
+      const part = match[1] ?? "";
+      if (part === "" || part === "videoseries")
+        return parsed.searchParams.get("list") ? address : null;
+      if (part === "live_stream")
+        return parsed.searchParams.get("channel") ? address : null;
+      return YT_ID_RE.test(part) ? address : null;
+    },
+    page: (parsed, host) => {
+      const site = bareHost(host);
+      const path = parsed.pathname;
+      let id = null;
+      if (site === "youtu.be")
+        id = path.slice(1).split("/")[0] ?? null;
+      else if (site === "youtube.com" || site === "music.youtube.com") {
+        if (path === "/watch")
+          id = parsed.searchParams.get("v");
+        else if (path === "/playlist") {
+          const list = parsed.searchParams.get("list");
+          return list ? `https://www.youtube.com/embed?listType=playlist&list=${encodeURIComponent(list)}` : null;
+        } else {
+          const match = /^\/(?:shorts|live|v)\/([^/]+)/.exec(path);
+          id = match?.[1] ?? null;
+        }
+      }
+      return id && YT_ID_RE.test(id) ? `https://www.youtube.com/embed/${id}` : null;
+    }
+  },
+  {
+    provider: "vk",
+    owns: (host) => VK_HOSTS.has(bareHost(host)),
+    // The player's own address (`video_ext.php?oid=…&id=…`, the `src` of VK's embed code) — its host, its `hash` and the rest: `hash` is
+    // the access key of a video shared by link (met live 2026-11-11: only the pasted embed code played, because nothing rewrote it).
+    player: (parsed, address) => parsed.pathname.endsWith("/video_ext.php") && parsed.searchParams.get("oid") && parsed.searchParams.get("id") ? address : null,
+    // A page names the video in its path (`/video-OWNER_ID`, `/clip-OWNER_ID`, also behind `/playlist/…/` or `/@club/…`) or in the `z`
+    // parameter VK adds when a video is opened over a wall, a community or a catalogue; `z` wins — it is the video the person looks at.
+    page: (parsed) => {
+      if (parsed.pathname.endsWith("/video_ext.php"))
+        return null;
+      const match = VK_VIDEO_RE.exec(parsed.searchParams.get("z") ?? "") ?? VK_VIDEO_RE.exec(parsed.pathname);
+      return match ? `https://vk.com/video_ext.php?oid=${match[1]}&id=${match[2]}&hd=2` : null;
+    }
+  },
+  {
+    provider: "rutube",
+    owns: (host) => bareHost(host) === "rutube.ru",
+    player: (parsed, address) => /^\/play\/embed\/[a-f0-9]+\/?$/i.test(parsed.pathname) ? address : null,
+    // `/video/<id>/`, a private video (`/video/private/<id>/?p=<key>` — the key rides along: without it the player shows a stub),
+    // `/shorts/<id>/` and `/live/video/<id>/` (Rutube's own FAQ: a short is embedded as a video).
+    page: (parsed) => {
+      const match = /^\/(?:video(?:\/private)?|shorts|live\/video)\/([a-f0-9]+)(?:\/|$)/i.exec(parsed.pathname);
+      if (!match)
+        return null;
+      const key = parsed.searchParams.get("p");
+      return `https://rutube.ru/play/embed/${match[1]}${key ? `/?p=${encodeURIComponent(key)}` : ""}`;
+    }
+  },
+  {
+    provider: "vimeo",
+    owns: (host) => ["vimeo.com", "player.vimeo.com"].includes(bareHost(host)),
+    player: (parsed, address, host) => bareHost(host) === "player.vimeo.com" && /^\/video\/\d+\/?$/.test(parsed.pathname) ? address : null,
+    page: (parsed, host) => {
+      if (bareHost(host) !== "vimeo.com")
+        return null;
+      const event = VIMEO_EVENT_PATH_RE.exec(parsed.pathname);
+      if (event)
+        return `https://vimeo.com/event/${event[1]}/embed${event[2] ? `/${event[2]}` : ""}`;
+      const video = VIMEO_VIDEO_PATH_RE.exec(parsed.pathname);
+      if (!video)
+        return null;
+      const key = video[2] ?? parsed.searchParams.get("h");
+      return `https://player.vimeo.com/video/${video[1]}${key ? `?h=${encodeURIComponent(key)}` : ""}`;
+    }
+  },
+  {
+    provider: "kinescope",
+    owns: (host) => bareHost(host) === "kinescope.io",
+    player: (parsed, address) => /^\/embed\/[A-Za-z0-9-]+\/?$/.test(parsed.pathname) ? address : null,
+    // `/<id>`: digits in Kinescope's own examples, also letters and digits or a dashed id.
+    page: (parsed) => {
+      const id = /^\/([A-Za-z0-9-]+)\/?$/.exec(parsed.pathname)?.[1];
+      return id && !KINESCOPE_NOT_A_VIDEO.has(id.toLowerCase()) ? `https://kinescope.io/embed/${id}` : null;
+    }
+  },
+  {
+    provider: "dzen",
+    owns: (host) => bareHost(host) === "dzen.ru",
+    player: (parsed, address) => /^\/embed\/[A-Za-z0-9_-]+\/?$/.test(parsed.pathname) ? address : null,
+    page: (parsed) => {
+      const match = /^\/video\/watch\/([A-Za-z0-9_-]+)/.exec(parsed.pathname);
+      return match ? `https://dzen.ru/embed/${match[1]}` : null;
+    }
+  },
+  {
+    provider: "twitch",
+    owns: (host) => ["twitch.tv", "player.twitch.tv", "clips.twitch.tv"].includes(bareHost(host)),
+    player: (parsed, _address, host) => {
+      const site = bareHost(host);
+      const has = (name7) => Boolean(parsed.searchParams.get(name7));
+      if (site === "player.twitch.tv")
+        return has("channel") || has("video") || has("collection") ? withTwitchParent(parsed) : null;
+      if (site === "clips.twitch.tv" && /^\/embed\/?$/.test(parsed.pathname))
+        return has("clip") ? withTwitchParent(parsed) : null;
+      return null;
+    },
+    page: (parsed, host) => {
+      const site = bareHost(host);
+      const path = parsed.pathname;
+      const clip = site === "clips.twitch.tv" ? /^\/([A-Za-z0-9_-]+)\/?$/.exec(path) : /^\/[A-Za-z0-9_]+\/clip\/([A-Za-z0-9_-]+)/.exec(path);
+      if (clip && clip[1] !== "embed")
+        return `https://clips.twitch.tv/embed?clip=${clip[1]}&parent=${TWITCH_PARENT}`;
+      if (site !== "twitch.tv")
+        return null;
+      const recording = /^\/videos\/(\d+)/.exec(path);
+      if (recording)
+        return `https://player.twitch.tv/?video=v${recording[1]}&parent=${TWITCH_PARENT}`;
+      const channel = /^\/([A-Za-z0-9_]+)\/?$/.exec(path);
+      return channel ? `https://player.twitch.tv/?channel=${channel[1]}&parent=${TWITCH_PARENT}` : null;
+    }
+  },
+  {
+    provider: "dailymotion",
+    owns: (host) => ["dailymotion.com", "geo.dailymotion.com", "dai.ly"].includes(bareHost(host)),
+    // Today's player (`geo.dailymotion.com/player/<player>.html?video=<id>`, and `…/player.html?video=<id>` from its oEmbed) and the
+    // older one (`www.dailymotion.com/embed/video/<id>`).
+    player: (parsed, address, host) => {
+      const site = bareHost(host);
+      if (site === "geo.dailymotion.com" && /^\/player(?:\/[A-Za-z0-9]+)?\.html$/.test(parsed.pathname)) {
+        return parsed.searchParams.get("video") || parsed.searchParams.get("playlist") ? address : null;
+      }
+      return site === "dailymotion.com" && /^\/embed\/video\/[A-Za-z0-9]+\/?$/.test(parsed.pathname) ? address : null;
+    },
+    page: (parsed, host) => {
+      const site = bareHost(host);
+      const match = site === "dai.ly" ? /^\/([A-Za-z0-9]+)\/?$/.exec(parsed.pathname) : site === "dailymotion.com" ? /^\/video\/([A-Za-z0-9]+)/.exec(parsed.pathname) : null;
+      return match ? `https://www.dailymotion.com/embed/video/${match[1]}` : null;
+    }
+  },
+  {
+    provider: "wistia",
+    owns: (host) => host === "wistia.com" || host.endsWith(".wistia.com") || host === "fast.wistia.net",
+    player: (parsed, address, host) => (host === "fast.wistia.net" || host === "fast.wistia.com") && /^\/embed\/iframe\/[A-Za-z0-9]+\/?$/.test(parsed.pathname) ? address : null,
+    page: (parsed, host) => {
+      if (host === "fast.wistia.net")
+        return null;
+      const match = /\/medias\/([A-Za-z0-9]+)/.exec(parsed.pathname);
+      return match ? `https://fast.wistia.net/embed/iframe/${match[1]}` : null;
+    }
   }
-  return null;
-}
+];
 function detectAndNormalize(url) {
-  const trimmed = url.trim();
-  if (!trimmed)
+  const address = url.trim();
+  const parsed = address ? parseUrl(address) : null;
+  if (!parsed)
     return { provider: "unknown", normalizedUrl: null };
-  const host = hostOf(trimmed);
-  if (host === "youtube.com" || host === "youtu.be") {
-    const id = extractYouTubeId(trimmed);
-    return { provider: "youtube", normalizedUrl: id ? `https://www.youtube.com/embed/${id}` : null };
-  }
-  if (host === "vk.com" || host === "vkvideo.ru") {
-    const ids = extractVkVideoIds(trimmed);
-    return { provider: "vk", normalizedUrl: ids ? `https://vk.com/video_ext.php?oid=${ids.oid}&id=${ids.id}&hd=2` : null };
-  }
-  const rutubeId = extractPathId(trimmed, "rutube.ru", [/\/play\/embed\/([a-f0-9]+)/i, /\/video\/([a-f0-9]+)/i]);
-  if (rutubeId)
-    return { provider: "rutube", normalizedUrl: `https://rutube.ru/play/embed/${rutubeId}` };
-  if (trimmed.includes("rutube.ru"))
-    return { provider: "rutube", normalizedUrl: null };
-  const vimeoEvent = extractVimeoEventEmbed(trimmed);
-  if (vimeoEvent)
-    return { provider: "vimeo", normalizedUrl: vimeoEvent };
-  const vimeoId = extractPathId(trimmed, "vimeo.com", [/\/video\/(\d+)/, /^\/(\d+)/]);
-  if (vimeoId)
-    return { provider: "vimeo", normalizedUrl: `https://player.vimeo.com/video/${vimeoId}` };
-  if (trimmed.includes("vimeo.com"))
-    return { provider: "vimeo", normalizedUrl: null };
-  const kinescopeId = extractPathId(trimmed, "kinescope.io", [/\/embed\/([a-zA-Z0-9]+)/, /^\/([a-zA-Z0-9]+)$/]);
-  if (kinescopeId)
-    return { provider: "kinescope", normalizedUrl: `https://kinescope.io/embed/${kinescopeId}` };
-  if (trimmed.includes("kinescope.io"))
-    return { provider: "kinescope", normalizedUrl: null };
-  const dzenId = extractPathId(trimmed, "dzen.ru", [/\/embed\/([a-zA-Z0-9_-]+)/, /\/video\/watch\/([a-zA-Z0-9_-]+)/]);
-  if (dzenId)
-    return { provider: "dzen", normalizedUrl: `https://dzen.ru/embed/${dzenId}` };
-  if (trimmed.includes("dzen.ru"))
-    return { provider: "dzen", normalizedUrl: null };
-  const twitchEmbed = extractTwitchEmbed(trimmed);
-  if (twitchEmbed)
-    return { provider: "twitch", normalizedUrl: twitchEmbed };
-  if (trimmed.includes("twitch.tv"))
-    return { provider: "twitch", normalizedUrl: null };
-  const dailymotionId = extractPathId(trimmed, "dailymotion.com", [/\/embed\/video\/([a-zA-Z0-9]+)/, /\/video\/([a-zA-Z0-9]+)/]) ?? extractPathId(trimmed, "dai.ly", [/^\/([a-zA-Z0-9]+)/]);
-  if (dailymotionId)
-    return { provider: "dailymotion", normalizedUrl: `https://www.dailymotion.com/embed/video/${dailymotionId}` };
-  if (trimmed.includes("dailymotion.com") || trimmed.includes("dai.ly"))
-    return { provider: "dailymotion", normalizedUrl: null };
-  const wistiaId = extractPathId(trimmed, "wistia.com", [/\/medias\/([a-zA-Z0-9]+)/]) ?? extractPathId(trimmed, "fast.wistia.net", [/\/embed\/iframe\/([a-zA-Z0-9]+)/]);
-  if (wistiaId)
-    return { provider: "wistia", normalizedUrl: `https://fast.wistia.net/embed/iframe/${wistiaId}` };
-  if (trimmed.includes("wistia.com") || trimmed.includes("wistia.net"))
-    return { provider: "wistia", normalizedUrl: null };
-  return { provider: "unknown", normalizedUrl: null };
+  const host = parsed.hostname.toLowerCase();
+  const service = SERVICES.find((candidate) => candidate.owns(host));
+  if (!service)
+    return { provider: "unknown", normalizedUrl: null };
+  return { provider: service.provider, normalizedUrl: service.player(parsed, address, host) ?? service.page(parsed, host) };
+}
+function readVideoInput(input) {
+  const address = readVideoAddress(input);
+  if (address === null)
+    return { address: null, provider: "unknown", embedUrl: null, how: "none" };
+  const detected = detectAndNormalize(address);
+  if (detected.provider === "unknown")
+    return { address, provider: "unknown", embedUrl: address, how: "unknown" };
+  if (detected.normalizedUrl === null) {
+    return { address, provider: detected.provider, embedUrl: address, how: extractIframeSrc(input) !== null ? "player" : "unread" };
+  }
+  return { address, provider: detected.provider, embedUrl: detected.normalizedUrl, how: detected.normalizedUrl === address ? "player" : "page" };
 }
 
 // build/tools/pollModel.js
@@ -119895,12 +119965,20 @@ function normalizeVideo(videoUrl) {
   const raw = videoUrl?.trim();
   if (!raw)
     return { originalUrl: null, embedUrl: null };
-  const effective = extractIframeSrc(raw) ?? raw;
-  const detected = detectAndNormalize(effective);
-  if (detected.provider !== "unknown" && !detected.normalizedUrl) {
-    throw new Error(`Could not extract a valid ${detected.provider} video id from videoUrl.`);
-  }
-  return { originalUrl: raw, embedUrl: assertEmbeddableUrl(detected.normalizedUrl ?? effective) };
+  const reading = readVideoInput(raw);
+  return { originalUrl: raw, embedUrl: assertEmbeddableUrl(reading.embedUrl ?? raw) };
+}
+function videoLinkWarning(videoUrl) {
+  const raw = videoUrl?.trim();
+  if (!raw)
+    return null;
+  const reading = readVideoInput(raw);
+  if (reading.how !== "unread")
+    return null;
+  return {
+    code: "video_link_unread",
+    message: `The link was recognized as ${reading.provider}, but no video was found in it. It is stored as it stands and the player may stay empty: open the page to check, or pass the embed code (<iframe \u2026>) from the service's "Share \u2192 Embed".`
+  };
 }
 function csvRows(headers, rows) {
   return [headers, ...rows].map((row) => row.map(csvCell).join(",")).join("\n");
@@ -123005,6 +123083,9 @@ function resolve3(enabled, setupVisibility, override, scheduledForFuture = false
     return { enabled: true, visibleNow: false, decidedBy: "setup schedule" };
   return { enabled: true, visibleNow: setupVisibility !== "hidden", decidedBy: "setup default" };
 }
+function placeholderLive(enabled, override) {
+  return resolve3(enabled, "hidden", override);
+}
 async function readLiveLayer(eventId, data, nowMs) {
   const blocks = record2(data.blocks);
   let ctrl;
@@ -123033,7 +123114,7 @@ async function readLiveLayer(eventId, data, nowMs) {
     banner: resolve3(banner.enabled === true, banner.visibility, ctrl.bannerVisible, showAt !== null && showAt > nowMs),
     cta: resolve3(cta.enabled === true, cta.visibility, ctrl.ctaVisible),
     cards: resolve3(cards.enabled === true, cards.visibility, ctrl.cardsVisible),
-    placeholder: resolve3(placeholder.enabled === true, "always", ctrl.placeholderVisible),
+    placeholder: placeholderLive(placeholder.enabled === true, ctrl.placeholderVisible),
     chat: { panel: chat.enabled === true, accepting }
   };
   const hints = [LIVE_FIELDS_HINT];
@@ -123699,7 +123780,7 @@ function registerEventTools(server2) {
       args: [
         "title: webinar title.",
         "workspaceId: optional workspace id; omitted means personal workspace.",
-        "videoUrl: optional iframe/source/player URL; normalized by OKO.",
+        "videoUrl: optional link to the video or the service's embed code (<iframe \u2026>); OKO reads the player address out of it \u2014 an embed code or a player address is stored as it stands, a link it cannot read is stored too and named in warnings (video_link_unread).",
         "eventDate: optional ISO datetime.",
         "chatEnabled: whether the chat block is on the page at creation (default true \u2014 the chat exists practically always). It does NOT open message sending: a new event starts closed, so the chat is visible and silent until the organizer opens it (oko_set_chat_mode, or the analytics switch), sets blocks.chat.intake to open, or enables the session triggers in oko_configure_blocks."
       ],
@@ -123746,7 +123827,7 @@ function registerEventTools(server2) {
       ...eventLinks(docRef.id),
       workspaceId,
       runtime: created.runtime,
-      warnings: sessionWarnings,
+      warnings: [...videoLinkWarning(args.videoUrl) ? [videoLinkWarning(args.videoUrl)] : [], ...sessionWarnings],
       hints: [
         "Analytics sessions: the page starts and ends its session by itself at the event time (sessionMode schedule; a session costs 1 lumen per minute, taken when it ends). Change the time of the session or turn the auto start off with oko_update_event (sessionMode, sessionStartAt, sessionEndAt).",
         ...eventRuntimeHint(created.runtime),
@@ -123763,7 +123844,7 @@ function registerEventTools(server2) {
       exampleCall: { "eventId": "Kx9pQ2mR7tL4vB8nW3cY", "title": "Autumn product webinar (rescheduled)", "eventDate": "2026-09-12T07:00:00.000Z", "speakerName": "Jane Doe", "description": "", "durationMinutes": 60 },
       args: ["eventId plus any subset of title, videoUrl, eventDate, speakerName, description, pinned, sessionMode, durationMinutes, sessionStartAt, sessionEndAt, pageTheme, pageAccent."],
       returns: "event id, the list of Firestore fields updated, and session warnings (plan versus event time, lumens versus plan, a plan with no sessions).",
-      examples: ["Use for title/date/speaker/video edits; use oko_configure_blocks for blocks and forms."],
+      examples: ["Use for title/date/speaker/video edits; use oko_configure_blocks for blocks and forms.", "videoUrl takes a link to the video or the service's embed code (<iframe \u2026>); a link OKO cannot read is stored as it stands and named in warnings (video_link_unread)."],
       notes: [
         "An ANALYTICS SESSION measures the show and costs 1 lumen per minute, taken when it ends (no debt; it stops by itself when the lumens run out). It always has a start and an end: the page's session plan \u2014 sessionStartAt and sessionEndAt, both or neither \u2014 and without them the plan is the event time (eventDate to eventDate + durationMinutes).",
         "sessionMode now means ONLY the automatic start: 'schedule' (the default of every new page) starts the session by itself at the plan's start; 'manual' turns that off \u2014 the organizer starts it with oko_start_session and a Telegram reminder comes 10 minutes before eventDate. Either way the session ends at the end of its plan, and oko_extend_session moves that end while it runs. This is still an analytics session, not an event status.",
@@ -123846,7 +123927,9 @@ function registerEventTools(server2) {
     await writeEventPatchWithCards(args.eventId, patch, null, validate);
     const touchesSession = ["meta.eventDate", "meta.durationMinutes", "meta.sessionStartAt", "meta.sessionEndAt", "analyticsSessionMode"].some((key) => key in patch);
     const sessionWarnings = touchesSession ? await collectSessionWarnings(args.eventId, await readEvent(args.eventId, uid, "read")) : [];
+    const videoWarning = videoLinkWarning(args.videoUrl);
     const warnings = [
+      ...videoWarning ? [videoWarning] : [],
       ...dateAdvice.map((message) => ({ code: "event_date_advice", message })),
       ...sessionWarnings
     ];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@okostream/mcp",
-  "version": "0.21.0",
+  "version": "0.22.1",
   "description": "Control OKO Stream webinars from Claude, Codex, and other MCP clients.",
   "license": "UNLICENSED",
   "author": {