broadcast_create
ChatGPTUse this when the user wants a new YouTube live broadcast, now or scheduled for later. Create a YouTube live broadcast on a connected channel, same as the broadcast dialog. mode "live_now" starts the moment video arrives; mode "scheduled" with scheduledStartTime (ISO 8601) creates an upcoming event YouTube will not publish before that time. Privacy defaults to public, because only a PUBLIC broadcast's archive banks Partner Program watch hours; pass "unlisted" or "private" only when the user asks for a soft launch. Auto-start is always on and the monitor stream off, so the broadcast publishes itself when the stream starts. Set containsSyntheticMedia true when the user says the stream shows realistic altered or AI-generated content (YouTube's "Altered content" disclosure). Attach it to a destination afterwards (destination_create or destination_set_broadcast); for a destination that rotates or recreates broadcasts, use destination_set_altered_content so every later broadcast discloses too. It does not start streaming; a stream goes live with playout_start.
broadcast_delete
ChatGPTUse this when the user wants to delete a YouTube broadcast and its video page. Delete a YouTube broadcast (and its video page) permanently. Refused while a destination still points at it. Any timed start that existed to feed it is removed with it. This cannot be undone; a completed broadcast's archive is deleted too.
broadcast_get_details
ChatGPTUse this when the user asks about one YouTube broadcast's settings, such as its privacy, start time or auto-start. Read one YouTube broadcast: lifecycle status, privacy status, scheduled start time, auto-start and monitor-stream settings. Use this before proposing broadcast_update, and to check whether a broadcast is Public (only public archives bank Partner Program watch hours). Live read from the YouTube API.
broadcast_list
ChatGPTUse this when the user asks about the live broadcasts on their YouTube channel: upcoming, live or finished. List the YouTube live broadcasts of one connected channel, newest first, with their lifecycle status, privacy, and scheduled start time. Pass the cursor from a previous page to continue. Live read from the YouTube API.
broadcast_transition
ChatGPTUse this when the user wants to move a YouTube broadcast to testing, live or complete by hand. Move a YouTube broadcast between lifecycle states: "testing", "live", or "complete". Going live publishes to the audience; complete ends the broadcast and finalizes its archive (a rotation is stop destination, complete broadcast, start destination). The bound stream must be receiving video for testing/live to succeed. Pass restreamTargetId when a destination of ours pushes into this broadcast so its status card updates. Do not use it to start or stop a stream; that is playout_start or playout_stop.
broadcast_update
ChatGPTUse this when the user wants to change a YouTube broadcast's title, description, privacy, thumbnail, start time or category. Update a YouTube broadcast: title, description, privacy (set "public" so the archive banks watch hours), scheduled start time and mode, category, thumbnail, DVR, embed, auto-start, auto-stop, and containsSyntheticMedia (YouTube's "Altered content" disclosure, changeable even while live). Only send the fields to change. Content settings lock once the broadcast is live. Moving or removing the scheduled time also moves or removes the destination's timed start, the same as saving from the broadcast dialog.
calendar_add_entry
ChatGPTUse this when the user wants to schedule a show or a block of videos at a set time on a calendar stream. Add one entry to a scheduled playout's calendar. When the playout has no calendar yet this creates it on timezone (an IANA name such as Europe/Madrid): pass the zone the user plans in. Without one it is the user's own zone. Entry items need id, fileId, name, durationMs and type from the library; timeSlot start/end are ISO 8601 instants. The calendar's timezone is its clock: work out the instant for the wall time the user means in that zone on that date, with the offset it has then (Europe/Madrid is +02:00 in summer time and +01:00 in winter). A recurring entry repeats at its start's wall time in that zone, on daysOfWeek as days there, through clock changes. fillBehavior "loop" repeats content across the slot; "play_once" requires the slot length to equal the total content duration (within 2 seconds). A composition item plays the composition's active version and takes that version's length: the save looks both up, ignores the versionId and durationMs you send for it, and refuses a play_once slot that does not match. Saving a new active version of a composition updates every slot that books it. Set versionPinned true only when the user asks to keep a specific version (with that versionId); a pinned slot ignores new versions until it is unpinned. An overlay template (overlayTemplateId on the entry's source or an item) shows the template's published version the same way: the save ignores overlayTemplateVersionId unless overlayTemplateVersionPinned is true, which is only for a user who asks to keep a version, and publishing a version updates every slot that follows it. A slot that is already over is refused: entries that have ended are a read-only record of what aired. Returns the entry as saved with the calendar's updateId, timezone and entry count, not the whole calendar; calendar_get reads that.
calendar_delete_entry
ChatGPTUse this when the user wants to remove one scheduled slot from a calendar stream. Delete one calendar entry by entryId. The slot it occupied falls back to the calendar's configured fallback (or black) until something else is programmed there. Refused for an entry that has ended. Returns the calendar's updateId and remaining entry count.
calendar_get
ChatGPTUse this when the user asks what is scheduled on a calendar stream, or before changing its calendar. Read a scheduled playout's calendar: entries with time slots and recurrence, the timezone, the gap fallback, and the lifecycle (AUTO start/stop) settings. timezone is the calendar's clock: a recurring entry plays at its timeSlot.start's wall time there, and daysOfWeek are days there, so read and state times in that zone. An item or slate with missing: true points at media that is no longer in the library; missing: false means the media is there. A composition item's versionId is the version its slots play and durationMs that version's length; versionPinned true means it keeps that version when a new one is saved. Likewise overlayTemplateVersionId is the overlay template version shown, and overlayTemplateVersionPinned true means it is kept when another is published. The updateId is what calendar_save takes as baseUpdateId. An entry that has ended (its last slot is over) is a record of what aired and is read only. Those that ended more than 14 days ago are left out: window.olderEntries counts them.
calendar_save
ChatGPTUse this when the user wants many changes to a calendar stream's schedule at once. Replace a scheduled playout's calendar: entries, timezone, fallback, and lifecycle. Entries that have ended stay as stored: leave them out or send them as calendar_get returned them; a change to one refuses the save. Prefer the single-entry tools (add_entry, update_entry, delete_entry) for one or a few changes; use this only for a bulk edit. Build it from your latest calendar_get result: copy every entry you are not changing exactly as returned, ids and fileIds included, pass that result's updateId as baseUpdateId, and list the ids of entries you add in newEntryIds. If that result is no longer in front of you, call calendar_get again; never write entries from memory. Items must be media in the library. timezone is the calendar's clock (an IANA name); leave it out to keep the current one, and change it only when the user asks, since recurring entries then repeat on the new zone's days and wall times. lifecycle mode "AUTO" starts and stops the playout around its entries (preRollSeconds before, postRollSeconds after, slots closer than gapToleranceSeconds merged); it needs the scheduling feature to take effect. calendar.updateId may be any string; the save assigns a new one. Returns the saved updateId, the entry count and what was added, removed and changed.
calendar_update_entry
ChatGPTUse this when the user wants to move or change one scheduled slot on a calendar stream. Replace one calendar entry by entryId with a new definition (full replace, not a patch). Refused for an entry that has ended: add a new one instead. Entry items need id, fileId, name, durationMs and type from the library; timeSlot start/end are ISO 8601 instants. The calendar's timezone is its clock: work out the instant for the wall time the user means in that zone on that date, with the offset it has then (Europe/Madrid is +02:00 in summer time and +01:00 in winter). A recurring entry repeats at its start's wall time in that zone, on daysOfWeek as days there, through clock changes. fillBehavior "loop" repeats content across the slot; "play_once" requires the slot length to equal the total content duration (within 2 seconds). A composition item plays the composition's active version and takes that version's length: the save looks both up, ignores the versionId and durationMs you send for it, and refuses a play_once slot that does not match. Saving a new active version of a composition updates every slot that books it. Set versionPinned true only when the user asks to keep a specific version (with that versionId); a pinned slot ignores new versions until it is unpinned. An overlay template (overlayTemplateId on the entry's source or an item) shows the template's published version the same way: the save ignores overlayTemplateVersionId unless overlayTemplateVersionPinned is true, which is only for a user who asks to keep a version, and publishing a version updates every slot that follows it. A slot that is already over is refused: entries that have ended are a read-only record of what aired. Returns the entry as saved with the calendar's updateId, timezone and entry count, not the whole calendar; calendar_get reads that.
channel_connect_link
ChatGPTUse this when the user wants to connect or reconnect a YouTube, Twitch, Facebook, LinkedIn or Kick account, or a task needs a channel that is not connected yet. Get a link to the Channels page in playout.video that opens one platform's sign-in (YouTube, Twitch, Facebook, LinkedIn or Kick). Connecting is a sign-in the user completes in their own browser; you never see their password or token. Give the user the link, wait until they say they are done, then check with channel_list before using the channel. Omit platform to open the platform picker. The result lists the channels already connected on that platform, so do not send a link for one the user already has. A reconnect uses the same link and never adds permissions, so never ask for a reconnect to gain analytics or any other access. Do not use this for Instagram, TikTok, X or a custom RTMP server: those have no sign-in, and channel_create_rtmp takes the stream URL and key directly.
channel_create_rtmp
ChatGPTUse this when the user gives a stream URL and stream key (for Instagram, TikTok, X or any custom RTMP server) and wants to stream there. Create a channel from RTMP credentials the user has given you: a Custom RTMP endpoint, or an RTMP-only platform (Instagram, TikTok, X and so on) that has no sign-in of its own. There is no OAuth on these, so a stream URL and a stream key are the whole connection: use this whenever the user has already supplied both, rather than asking them to retype them into a form. Platform defaults to CUSTOM_RTMP. YouTube, Twitch, Facebook, LinkedIn and Kick are refused here because the user has to sign in to them from the Channels page in Playout. Custom RTMP is plan-gated. The channelId this returns is what destination_create takes.
channel_get_insights
ChatGPTUse this when the user asks how one connected channel is growing (subscribers or followers, viewers, live minutes) or where its traffic comes from. Read the stored insights for one connected channel: channel metadata and analytics-consent state, the daily growth series (live minutes, viewers, subscribers/followers), the channel-level YouTube Analytics series (views, watch time; not available yet in this version, so it comes back empty, and reconnecting the channel does not change that) and the traffic-source breakdown, over a window of windowDays (default 28, max 365). Served from stored data only; makes no YouTube API calls.
channel_list
ChatGPTUse this when the user asks which accounts (YouTube, Twitch, Facebook, LinkedIn, Kick, RTMP) are connected, or you need a channel id. List the social channels connected to this workspace: platform, name, connection status and the OAuth scopes granted (informational only: a reconnect grants the same fixed set, so a missing scope is never a reason to ask the user to reconnect). Use this to find the channelId that channel_get_insights, channel_list_videos and video.get_analytics need. Makes no YouTube API calls.
channel_list_targets
ChatGPTUse this when the user wants to stream to a Facebook Page or a LinkedIn page rather than their personal profile. List where one connected Facebook or LinkedIn channel can stream: the account's own profile and the Pages it manages, each with the id a destination takes (facebook.type + facebook.id, or linkedin.type + linkedin.owner on destination_create / destination_update). Reads the platform live. An empty pages list means the connection was made with profile-only permissions or the account manages no Pages; reconnecting with the Page option of the Facebook sign-in adds Page access to this same channel and never creates a second one. When Page permission is already granted and pages is still empty, the note says how to change which Pages Facebook shares. Other platforms stream to the channel itself and are refused.
channel_list_videos
ChatGPTUse this when the user asks about the videos on their YouTube channel, or how much of it counts toward YouTube Partner Program watch hours. List the stored uploads inventory of one connected YouTube channel: video id, title, duration, privacy status, published date, an isShortHeuristic flag (duration under 180s; a heuristic, the API has no Shorts marker) and a qualifyingLongForm convenience flag (public and not short: what the YouTube Partner Program watch-hour rules count). The inventory holds the newest ~200 uploads, refreshed daily; served from stored data only, makes no YouTube API calls. Do not use it for videos in the Playout library; that is media_list.
composition_create
ChatGPTUse this when the user wants a new video put together from clips, images or audio already in their library. Create a composition in the media library from media the workspace already has. Pass selectedFileIds (video, image or audio fileIds from media_list) and the scenes are laid out automatically, or pass none for an empty composition to build in the editor. The composition is ready immediately and can go into a playlist. The overlay document itself is not written here; refine the result in the composition editor.
composition_get
ChatGPTUse this when the user asks about one composition's versions or length. Read one composition by compositionId (from composition_list): name, aspect ratio, run length, file status, and its versions (id, number, active flag, description, created date). The composition's overlay document itself is not included; it is edited in the composition editor, not through tools.
composition_list
ChatGPTUse this when the user asks about their compositions: videos built in Playout's editor from clips, images and text. List the compositions in this workspace: name, description, run length, aspect ratio, active version id, version count and the underlying file's processing status. Compositions are editor-built video documents; playlist items reference them by compositionVersionId. Use composition_get for one composition's version history.
destination_create
ChatGPTUse this when the user wants a stream to also go to YouTube, Twitch, Facebook, LinkedIn, Kick or an RTMP server. Add a destination to a playout. With channelId set, the platform and its credentials come from that connected channel; a YouTube destination can name an existing broadcast via youtube.liveBroadcastId, and without one a new PUBLIC broadcast is created automatically (change it with broadcast_update if the archive should not be visible). Channel-less custom RTMP (channelId null plus customRtmp) is plan-gated AND off unless the workspace has channel-less targets enabled, so a refusal saying a channel is required is not a reason to attach some other channel the user did not name: make one from their credentials with channel_create_rtmp and pass its channelId. A Facebook or LinkedIn channel also needs WHERE on the account the stream lands: facebook {type: 'profile'|'page', id} or linkedin {type, owner}, with the ids from channel_list_targets; a Facebook profile broadcast may add facebook.privacy (EVERYONE unless set). autoStart makes the destination start whenever the playout starts. Counts against the plan's per-stream destination limit.
destination_delete
ChatGPTUse this when the user wants a stream to stop going to one platform for good. Remove a destination from its playout. The stream stops going to that platform from the next start. The connected channel is untouched. If the destination is LIVE, deleting it stops it first, and stopping a YouTube destination ends its broadcast unless the destination is set to keep it (destination_set_end_broadcast_on_stop): YouTube saves the recording and the watch link is finished. Say so before deleting a live YouTube destination, because that part cannot be undone.
destination_list_archive_parts
ChatGPTUse this when the user asks for the YouTube watch links or recordings of a 24/7 stream, or whether each part was saved. List a YouTube destination's broadcasts, newest first, one per part of its stream: when each started and ended, its watch URL, and its status (live = streaming into it now; rotated = ended by the 11-hour archive rotation, so YouTube keeps its recording; ended = stopped some other way). Use the destination id from playout_get_state. Video links are cleared from parts older than 30 days, so those have a null broadcastId.
destination_set_altered_content
ChatGPTUse this when the user says their stream shows realistic AI-generated or altered content and YouTube's disclosure should be on, or wants it off. Turn YouTube's "Altered content" disclosure on or off for one YouTube destination: whether its broadcasts show realistic altered or synthetic content, such as AI-generated people, voices or scenes, that a viewer could mistake for real. Applies to the broadcast the destination is on now (even while live) and to every broadcast created for it afterwards, including each part of an 11-hour rotation, so the user does not have to tick it in YouTube Studio on every new part. Only set it to true when the user says their content is altered or synthetic; this app cannot judge that. Available on every plan. Only for YouTube destinations.
destination_set_archive_rotation
ChatGPTUse this when the user runs a 24/7 YouTube stream and wants every part saved as a recording, for example for Partner Program watch hours. Turn on or off starting a new YouTube broadcast every 11 hours for one YouTube destination. YouTube may not save a recording of a broadcast longer than 12 hours, and watch time on a live stream it did not save does not count toward Partner Program watch hours, so for a 24/7 stream this keeps every part's recording. Before turning it on, tell the user what it costs: each new broadcast has its own watch link, so live viewers and live chat start fresh with it. The stream itself keeps running, and title, description, privacy, category and a thumbnail set in this app carry over. Paid plans only: Free sessions stop at 2 hours, so Free cannot turn it on. Only for YouTube destinations.
destination_set_auto_start
ChatGPTUse this when the user wants a destination to go live automatically whenever its stream starts, or to stop doing so. Toggle whether one destination starts automatically whenever its playout starts. Off means the destination must be started by hand or by a schedule.
destination_set_broadcast
ChatGPTUse this when the user wants a YouTube destination to stream into a different YouTube broadcast. Point one YouTube destination at a different broadcast (by liveBroadcastId). Refused while the destination is running. The destination's timed start follows the new broadcast's scheduled time, or goes away if it has none.
destination_set_end_broadcast_on_stop
ChatGPTUse this when the user wants their YouTube broadcast (and its watch link) kept alive between stops, or ended on every stop. Choose whether stopping one YouTube destination also ends its broadcast. On (the default) means a deliberate stop ends the broadcast, so YouTube saves the recording and the next stream starts a new broadcast with a new watch link. Off means the broadcast stays live between streams and the user ends it themselves in YouTube Studio, which also risks the recording: YouTube stops saving broadcasts that run longer than about 12 hours. Paid plans only: on Free the broadcast always ends when the stream stops and this cannot be changed. Only meaningful for YouTube destinations.
destination_start
ChatGPTUse this when the user wants one platform to start receiving a stream that is already live. Start one destination on a playout that is ALREADY running, the same as the Start button on the destination card. This is how a destination added to a live playout goes live: autoStart only applies when the playout itself starts, and playout_start on a running playout does nothing. When the playout is stopped, use playout_start instead (with restreamTargetIds for a subset). Requires explicit user confirmation every time. Check the result with playout_get_state: the destination's liveState should move to running.
destination_stop
ChatGPTUse this when the user wants a live stream to stop going to one platform while the others keep running. Stop one destination while its playout keeps running, the same as the Stop button on the destination card. The other destinations stay live. Stopping a YouTube destination ends its broadcast unless the destination is set to keep it (destination_set_end_broadcast_on_stop): YouTube saves the recording and the next start makes a new watch link; the dry run says which applies. Use playout_stop to end the whole stream. Requires explicit user confirmation every time.
destination_update
ChatGPTUse this when the user wants to change where an existing destination sends the stream or how it is set up. Update a destination. This is a FULL update on the same shape as destination_create plus restreamTargetId: send every required field with its intended value. Repointing youtube.liveBroadcastId moves the destination to another broadcast and its timed start follows. Repointing facebook {type, id} or linkedin {type, owner} moves a Facebook or LinkedIn destination between the account's profile and its Pages (ids from channel_list_targets); the change applies from the next start.
docs_get
ChatGPTUse this when you have a help article's slug and need its full text to answer a how-to question. Read one product documentation article in full (markdown body) by the slug that docs_list or docs_search returned. Use this to answer how-to and concept questions from the actual docs rather than guessing UI details.
docs_list
ChatGPTUse this when the user asks how Playout works or how to do something in it, and you want the list of help articles to choose from. List Playout's product documentation: help-center articles and changelog entries, each with a slug, title and one-line summary. Consult the docs for how-to and concept questions (how a feature works, where a setting lives, what a plan includes) before answering from memory; fetch the full article with docs_get. The optional query filters by title, summary, category and tags.
docs_search
ChatGPTUse this when the user asks a how-to or concept question about Playout (features, settings, plans, YouTube streaming rules) and you need the matching help articles. Search the full text of Playout's product documentation and get back the best-matching articles, most relevant first, each with an excerpt around the match. Pass the keywords of the question ("playlist rotation live edits") rather than a sentence; articles are ranked by how many of the terms they cover, so an exact phrase is not required. Use it when docs_list titles do not obviously cover the question; then read the best match with docs_get.
graphic_attach
ChatGPTUse this when the user wants a graphic to appear on a live-studio scene. Put a READY graphic version on a live-studio scene as a full-frame overlay. Takes the graphicVersionId from graphic_write or graphic_list, and the scene as sceneId, or as the stream's playoutId (plus sceneName when it has several scenes; the refusal lists them). Optional config (brand colours, timeZone (left out: the workspace's zone), labels the graphic reads with useConfig), surface (16:9 default, 9:16, 1:1) and runId to feed it from a live show run. This writes the scene only: the studio puts it on air when that scene is live, so attaching never changes what viewers see by itself. It adds to what the scene already shows (listed as existingGraphics in the approval and the result): if the scene already shows a graphic, ask the user whether to replace it (graphic_detach with its overlayId) or add the new one alongside. otherOverlays names the scene's own countdown, texts, chat and the like, and where they sit: a graphic's box over one of them hides it, so say so and ask before attaching there. media sets the graphic's images, by its meta.media slot keys: { logo: "<fileId>" } with ready images from media_list (type image). To change a graphic already on the scene (a newer version, its images), use graphic_update instead: attaching a second copy and detaching the first loses its content.
graphic_detach
ChatGPTUse this when the user wants a graphic taken off a live-studio scene. Remove a graphic overlay from a live-studio scene (sceneId, or playoutId plus sceneName): by the overlayId graphic_attach returned or listed in existingGraphics, or every overlay of a graphicVersionId on that scene. Writes the scene only, like attach.
graphic_get_source
ChatGPTUse this when the user wants to change an existing graphic, before writing its next version. Read one graphic version: its TSX source, meta, schema, the build report (checks with ok and detail, failing names) and its still references. Pass graphicVersionId, or graphicId for the graphic's newest version. Read the source before changing an existing graphic so the next version keeps what the user already liked.
graphic_get_still
ChatGPTUse this when you need to see how a built graphic renders, for example when the user says text is cut off. Fetch one test still of a READY graphic version: the schema field at its max length (kind "max") or at its smallest value (kind "min"). The still comes back as an image. Use it to look closely at the field a user or a check complained about before changing the source.
graphic_guide
ChatGPTUse this when you are about to write or fix a live-studio graphic, such as a lower third, scoreboard or news ticker the user asks for. Read the guide to writing a Playout graphic: the one-file TSX contract (meta, schema, default export), the allowed imports and banned APIs, the graphics-kit and remotion API with examples, what live programs feed a graphic (sheet rotations, trivia quizzes with a join QR, price feeds, AI-host captions) and the hooks that read them, image slots for logos and photos from the library (useMedia), the safe area, what each build check means and how to fix it, how to read the test stills, how to recreate a layout from a screenshot the user attaches (video hole, background, pages of items), and five reference graphics that build first time. Read it once per conversation before the first graphic_write; come back to the section a failing check names.
graphic_list
ChatGPTUse this when the user asks about their on-air graphics for the live studio. List this workspace's graphics (on-air overlays written as TSX): graphicId, name, version count, the newest version's status, and the newest READY version (graphicVersionId) a scene can attach. Use graphic_get_source to read one version's source and report, graphic_write with basedOnVersionId to build its next version.
graphic_update
ChatGPTUse this when the user wants a graphic already on a scene switched to a newer version or given different images. Change a graphic that is already on a live-studio scene, in place: switch it to another READY version of the same graphic (toVersionId, e.g. the one graphic_write just built) and/or set its images (media: { slotKey: "<fileId>" } with ready images from media_list, type image; null removes a slot's image; keys left out keep theirs). Name the scene (sceneId, or playoutId plus sceneName) and the graphic (overlayId from graphic_attach or existingGraphics, or graphicVersionId when one overlay shows it). Only its version (bundle and label) and images change: its content (sheet, quiz, show run), text fields, config, position and size stay, like the studio's "Update to vN". Use it instead of attaching a second graphic and detaching the first, which drops the graphic's content. Writes the scene only, like attach.
graphic_write
ChatGPTUse this when the user wants a new on-air graphic for the live studio, or a change to one (lower third, scoreboard, ticker, logo and the like). Build a graphic from TSX written to the graphic contract (read graphic_guide first). Creates a new graphic named name, or with basedOnVersionId the next version of that graphic (rename when name differs). Returns the build report: checks[] with name, ok and detail, the failing check names, test stills of every schema field at its max and min length (shown to you as images), and the graphicVersionId to attach or to build on. A failed build is a normal result: fix only what the failing checks name and call again with basedOnVersionId. Nothing goes on air until graphic_attach. Take colours and font from useBrand() and lay out for 16:9, 9:16 and 1:1 with useStage() (graphic_guide, "Brand and shape"). For overlays drawn over a playlist stream's videos use template_create instead.
insights_get_heatmap
ChatGPTUse this when the user asks when their viewers watch, or which day and hour is best to go live or schedule content. Read the viewer heatmap over the last windowDays (default 28, max 365): average concurrent viewers per day-of-week and hour, with the sample count behind each cell. dow is 0-6 with 0 = Sunday and hour is 0-23, both in UTC. Cells with no samples are absent rather than zero. Narrow with playoutId or channelId.
insights_get_overview
ChatGPTUse this when the user asks how their streams are doing: live hours, viewer hours, views or subscriber growth over a period. Read this workspace's streaming performance over the last windowDays (default 28, max 365): total live minutes, viewer hours, views and subscriber growth, broken down by playout and by platform. Served from stored rollups; makes no YouTube API calls. Pass channelId to narrow to one channel. Live minutes are what the sessions recorded: a total below the wall-clock time is not proof the stream was down, so check insights_list_sessions (and destination_list_archive_parts for YouTube) before saying live time was lost.
insights_list_sessions
ChatGPTUse this when the user asks when a stream went live, how long it ran, how many people watched, or whether it went down. List past and current stream sessions, newest first: start and end time, duration, why the session ended, peak and average concurrent viewers, and views/likes/comments gained. A session with no endedAt is still live. An "error" end is often the push reconnecting by itself: the next session of the same destination starting minutes later means the stream carried on, not that it was down. Pass playoutId to narrow to one playout, and cursor (from a previous nextCursor) for the next page.
insights_list_suggestions
ChatGPTUse this when the user asks how to grow or improve their streams, before proposing ideas of your own. List the improvement suggestions currently recorded for this workspace, from both the insights rules and the agent's own suggest-mode runs: type, severity and the parameters behind each one. Defaults to the open ones (status "new"); pass status to read the dismissed, acted or expired ones instead. Check this before proposing something new: a dismissed suggestion was a deliberate decision by the user.
media_create_folder
ChatGPTUse this when the user wants a new folder in their media library. Create a folder in the media library. Pass parentFileId (a folder id from media_list or media_folder_tree) to nest it; omit it for the library root. Returns the new folder's id, which move and import calls can target.
media_delete
ChatGPTUse this when the user wants to delete videos, folders or playlists from the library. Delete media library entries by fileId, the fileId field of a media_list or playlist_list row (never its videoId, playlistId or audioId, which address different rows and are refused). The library rows are soft-deleted and the stored media bytes are queued for removal, so the content is not recoverable from the app. Refused outright for non-empty folders, for a stream's own playlist file (delete the stream instead) and for anything a running stream holds (stop it first). A file a stopped stream's playlist or calendar holds is refused unless removeFromPlayouts is true, which first takes it out of those streams: playlist rows pruned, calendar slots trimmed, a slate or fallback that named it set to black. A playlist that a Schedule-tab schedule switches to or inlines, and any file in that playlist, is refused the same way; removeFromPlayouts deletes those schedules or prunes the file from the scheduled playlist (deleting a schedule left with an empty playlist), even on a running stream. Deleting a video that a saved playlist still references is allowed, but that playlist entry is left pointing at a deleted file; the dry run lists such references.
media_discover
ChatGPTUse this when the user gives a YouTube (or other) channel, playlist or video link and wants to see what is there before importing. Look up what is at a media URL without importing anything: one video, a playlist's videos, or a channel and its uploads, each with title, duration and its own URL. Use it before media_import when the URL is a channel or a playlist, or when the user asks what is there, then import the videos they choose one URL per media_import call. Listed in the source's own order, which is newest first for a channel, and total is how many this lookup found. channel names the channel the URL belongs to, so a single video URL is enough to find its channel: call this again on the channel's own url to list its uploads. Slow for a large channel (the source is read live), and it costs no YouTube API quota.
media_folder_tree
ChatGPTUse this when the user wants to organize the library into folders, or you need a folder id to file something into. Read the media library's folder structure as a flat list of {id, name, parentId} (null parentId = library root). Use it to pick a parentFileId for media_create_folder, media_move or an import, without paging through media_list.
media_import
ChatGPTUse this when the user wants to add a video to their library from a link (YouTube, Vimeo, a direct file URL and similar). Import a video from a URL into the media library through the standard import pipeline. The URL is all that is required: title, duration and thumbnail are resolved from the source. Pass one video URL per call, not a playlist or channel URL. Counts against the organization's storage capacity and hourly import quota, and the resolved duration must fit the plan's upload cap. The import downloads and stores only; playback transcoding happens lazily on first play.
media_list
ChatGPTUse this when the user asks what videos or files are in their Playout library, or names a video and you need its id. List entries in the media library: name, type, processing status, duration and size. Pass parentFolderId to look inside one folder; omit it to search the whole library, folders included, which is what makes query a workspace-wide name search. type filters to videos or folders. Each entry carries parentId, so a file's folder is in the answer. Two ids come back per entry and they are not interchangeable: fileId (same value as id) is what media_delete, media_move and media_rename take, and videoId is what a playlist_set_items item takes. Sending a videoId to media_delete is refused. A file is only usable in a playlist once its status is "ready"; an "error" status carries the reason. Do not use it for the videos on the user's YouTube channel; that is channel_list_videos.
media_move
ChatGPTUse this when the user wants to move videos or folders into another folder. Move one or more library entries by fileId (the fileId field of a media_list row, not its videoId) into a folder (parentFileId from media_folder_tree), or to the library root when parentFileId is null. A move only changes where an entry sits; playlists and playouts reference files by id, so nothing that uses these files breaks. Refused when an entry is already in the destination or a folder would be moved into itself.
media_rename
ChatGPTUse this when the user wants to rename a video, folder, playlist or template in the library. Rename one media library entry (file, folder, playlist or template file) by the fileId field of a media_list row, not its videoId. Only the display name changes; ids and references stay as they are.
org_get_capabilities
ChatGPTUse this when the user asks what their plan includes or allows (quality, number of streams, storage, scheduling), or before an action that might hit a plan limit. Read the organization's effective plan capabilities: plan tier, feature flags and caps, storage usage against capacity, running playout usage against the concurrency limit, and account status. Plan every action within what this returns.
playlist_create
ChatGPTUse this when the user wants a new playlist, for example to build a new 24/7 stream from some of their videos. Create a playlist in the media library, optionally with initial items. Each item names a fileId from media_list, its type ("video" or "composition") and its order; only ready video and composition files are playable. A playout needs a playlist with at least one item, so add items here (or pick an existing playlist) before playout_create.
playlist_get
ChatGPTUse this when the user wants to see what is in a playlist and in what order, and always right before editing it. Read one saved playlist and its items in order: each item's id, videoId or compositionId, name and duration. Use it right before playlist_set_items to get current item ids, since they change whenever the playlist is saved elsewhere. Takes the playlistId from playlist_list or playout_get_state. overlayTemplate is the playlist's default overlay template: pinned false means it shows the template's published version, whichever that is; pinned true means it keeps versionId when a new version is published.
playlist_list
ChatGPTUse this when the user asks which playlists they have, or names a playlist and you need its id. List the saved playlists in this workspace's library: name, item count and total run length. These are the source playlists that playlist_set_items edits, not the copy a running playout is playing. Use playout_get_state for what is on air. Each row carries both ids: playlistId addresses the playlist itself (playlist_set_items, playout_create), fileId addresses its library entry and is the one media_delete takes.
playlist_set_items
ChatGPTUse this when the user wants to add, remove or reorder the videos in a saved playlist. Replace a playlist's item list (content and order) in one call. Existing item ids are kept in place, omitted items are removed, and new items use ids prefixed with "temp-". Item ids change whenever the playlist is saved elsewhere (the user editing in the app), so re-read them with playlist_get (or playout_get_state) immediately before this call; never reuse ids from earlier in the conversation. An id that is no longer in the playlist fails the whole call with nothing changed: re-read and retry, do not swap in temp- ids to get past it, since that re-adds items the user may have just removed. Each item names its content by videoId or compositionId, as returned by media_list and playout_get_state, never by the library file id. This edits the source playlist: a running stream that plays it takes the new items and order within seconds, the item on air playing on. Reversible: the previous item list is snapshotted and can be restored. Do not use it to change what a live stream is playing right now; that is playout_edit_running_playlist.
playout_cancel_inline
ChatGPTUse this when the user wants a one-off playlist to stop and the stream to go back to its usual loop. Cancel an inline playlist started by playout_switch_playlist and return the playout to its loop immediately. Refused on a scheduled stream while a calendar block is on air: change that block with calendar_update_entry instead, which takes effect on air straight away.
playout_create
ChatGPTUse this when the user wants a new 24/7 stream that loops a playlist of their videos. Create a playout (a stream) from an existing playlist. streamType defaults to "continuous" (a 24/7 loop of the playlist). The playlist must exist and have at least one item (playlist_create builds one from library files). Quality values must fit the plan; org_get_capabilities says what is allowed. The playout is created stopped, with no destinations; attach destinations with destination_create, then playout_start goes live.
playout_create_scheduled
ChatGPTUse this when the user wants a stream that follows a schedule (shows at set times and days) rather than one looping playlist. Create a calendar (scheduled) playout: content is programmed by wall-clock calendar entries instead of one looping playlist. An empty calendar and playlist are created with it; program it with the calendar.* tools. Calendar AUTO start/stop needs the scheduling feature (org_get_capabilities).
playout_delete
ChatGPTUse this when the user wants to remove a stream for good. Delete a playout permanently, with its destinations and schedules. The source playlist and the media library are untouched. This cannot be undone; stop the playout first if it is running.
playout_edit_running_playlist
ChatGPTUse this when the user wants to change what a live stream is playing right now (skip, reorder, add or remove videos). Replace the running playlist's item list directly on a playout. On a continuous stream the items and their order are saved to its source playlist too, since the stream follows that playlist: to change what is on air without changing the playlist, create a new playlist (playlist_create) and switch the stream to it (playout_switch_playlist) instead. Send the full list in play order: fileId and type per item, plus compositionVersionId for compositions, all read from playout_get_state running.playlist.items (NOT the source items, whose ids belong to the library copy). To keep an item where it is, copy its row through unchanged. Optionally jump: currentPlayingItemIndex picks the item to play now, startFromTime a position within it in nanoseconds, which running.playlist.currentPlayingItemNanos reports for the item already playing. Takes effect on air immediately. Refused on a scheduled stream while a calendar block is on air: change that block with calendar_update_entry instead, which takes effect on air straight away.
playout_get_state
ChatGPTUse this when the user asks whether a stream is live, what is playing right now, or why a stream or one of its destinations is not working. Read one playout by id: how it is configured, what is on air, and its destinations. Returns TWO item lists and they are not interchangeable. items is the source playlist in the library, which playlist_set_items edits. running.playlist.items is what the engine is actually playing: a playout starts as a copy of its source and then drifts, and playout_edit_running_playlist can set the on-air list to anything, so a running playout may be playing items that are in no saved playlist. Answer "what is playing" from running, never from items. running.onAir says whether the loop or a temporary inline playlist is up, isPlaying marks the current item, and each running item carries the fileId and compositionVersionId that playout_edit_running_playlist takes back. isRunning and running.status are the truth about whether it is on air: a stopped or failed playout keeps its last state, so running can be present with a status of "stopped" or "error" (carrying the error that stopped it), and it then holds NO item list at all. Each destination carries liveState: what the target card on the page shows, including the error a failed destination is displaying and its status ("running", "stopped", "error", or "initial" for one that has never run). A playout that is running while a destination reads error is reaching nobody on that platform. Use playout_list to find the id. Stream keys and other destination credentials are never returned.
playout_list
ChatGPTUse this when the user asks about their streams, 24/7 streams or playouts (what they have, which are live), or names a stream and you need its id. List the playouts (streams) in this workspace, newest first: name, stream type, quality, playlist size and configured destinations. Use this to find a playout's id, then playout_get_state for what it is doing right now. Supports a name search and paging.
playout_start
ChatGPTUse this when the user wants to start a stream or go live. Start a playout: go live to its configured destinations. Requires explicit user confirmation every time and is never applied automatically. Pass restreamTargetIds to go live to a subset of the playout's destinations, or omit it for all of them. Refused when the playout is already running: a destination added to a live playout (autoStart included) is started on its own with destination_start.
playout_stop
ChatGPTUse this when the user wants to stop a stream or end the live stream. Stop a running playout: end the stream to all its destinations and finalize any recording. Requires explicit user confirmation every time and is never applied automatically. This cannot be undone by starting again: a restart is a new session, and for a YouTube destination it ends the broadcast too, so YouTube saves the recording and the next start makes a new broadcast at a new watch link. A destination set to keep its broadcast across stops (destination_set_end_broadcast_on_stop) is the exception; the dry run says which of the two applies.
playout_switch_playlist
ChatGPTUse this when the user wants a stream to play a different playlist, for good or just once. Load a different playlist into a playout. switchType "loop" makes it the new loop (the previous playlist stops being played); "inline" plays it once and then returns to the current loop (undo early with playout_cancel_inline). Takes effect on air immediately on a running playout. On a stopped one nothing airs now: a loop applies from the next start, and an inline is queued to play once at the next start, before the loop. Refused on a scheduled stream while a calendar block is on air: change that block with calendar_update_entry instead, which takes effect on air straight away.
playout_toggle_shuffle
ChatGPTUse this when the user wants a stream to play its videos in random order, or in order again. Turn shuffle on or off for a playout's running loop. Takes effect on air from the next item onward. Refused on a scheduled stream while a calendar block is on air: change that block with calendar_update_entry instead, which takes effect on air straight away.
playout_update
ChatGPTUse this when the user wants to rename a stream or change its quality or other settings. Update a playout's configuration: name, description, quality, encoding profile, and the sync/record/feed flags. This is a FULL update: send every required field with its intended value (read playout_get_state first and copy what should not change). Quality changes apply from the next start, not to a running session.
rotation_set_policy
ChatGPTUse this when the user wants a 24/7 YouTube stream to restart on a fresh broadcast about once a day to help discovery. Enable, disable or tune the discovery refresh on one YouTube destination: every 24 hours or more, at a quiet hour, it ends the broadcast and restarts the stream on a fresh one to reset YouTube discovery. It does NOT keep recordings: YouTube may not save a broadcast longer than 12 hours, so for that use destination_set_archive_rotation, which starts a new broadcast every 11 hours. Reversible: the previous policy is snapshotted and can be restored.
scene_place_video
ChatGPTUse this when a live-studio layout needs the video in a specific box, for example inside the hole a graphic leaves for it. Put a live-studio scene's video into a box on the canvas: the hole a graphic leaves for the video when it recreates a broadcast layout (graphic_guide, "Recreate a layout from a reference image"). Takes the scene as sceneId, or the stream's playoutId (plus sceneName when it has several), the slot ("camera" by default, "screen", "media" or a slot id) and the box as fractions of the canvas: x, y (top-left), width, height, all 0..1, the same numbers the graphic uses for its hole. Switches the scene to the custom layout and moves only that slot; an empty scene gets an empty camera slot there. Writes the scene only: the studio shows it when that scene is live, so nothing changes on air by itself.
schedule_create
ChatGPTUse this when the user wants a stream to start, stop or change playlist at a set time, once or on a repeating schedule. Create a timed automation on a playout: startPlayout/stopPlayout act on the whole stream, startRestreamTarget/stopRestreamTarget on one destination (restreamTargetId required), playlist swaps the loop to another playlist (playlistId required), "inline" plays one playlist once and returns. For type "every", cron is a standard 5 or 6 field expression evaluated in tz (an IANA zone like "Europe/Istanbul"); a year field is not supported. For type "once", applyAt is the absolute ISO 8601 moment (with timezone offset or Z). Do not use it to program shows on a calendar stream; that is calendar_add_entry.
schedule_delete
ChatGPTUse this when the user wants to remove a stream timer. Delete one timed automation. The playout keeps running as it is; only the timer goes away. Deleting a start that feeds a scheduled YouTube broadcast means nothing will start the stream at that broadcast's time.
schedule_list
ChatGPTUse this when the user asks what timers are set on a stream (timed start or stop, playlist swaps). List the timed automations of one playout (timed start/stop, playlist swaps) together with their run states (next run, last outcome). Rows carrying a youtubeLiveBroadcastId were created automatically to feed a scheduled broadcast and follow that broadcast.
schedule_update
ChatGPTUse this when the user wants to change the time or action of an existing stream timer. Update a timed automation by scheduleId: its action, one-shot time or cron, timezone, and run limit. Send the full new definition (this is a full update, not a patch). For type "every", cron is a standard 5 or 6 field expression evaluated in tz (an IANA zone like "Europe/Istanbul"); a year field is not supported. For type "once", applyAt is the absolute ISO 8601 moment (with timezone offset or Z).
template_create
ChatGPTUse this when the user wants a new overlay design (lower third, ticker, logo and the like) drawn over a playlist stream's videos. Create a new overlay template in the media library. Its first version is created published and active, so the template is immediately usable. Send overlaysData to author the design up front (the overlaysData field spells the document format out); omit it for a starter template the user lays out in the editor. Counts against the plan's overlay template limit. Creating a template changes nothing on air until a playlist, playlist item or calendar entry is pointed at it (playlist_set_items, calendar_update_entry); a running stream that plays that playlist then shows it within seconds. For graphics on a live-studio scene use graphic_write instead.
template_create_version
ChatGPTUse this when the user wants to change an existing overlay template's design. Add a new version to an overlay template from a full overlay document. Start from the active version's overlaysData (template_get), modify it, and send the whole document back. The new version is a draft by default: nothing renders it until template_publish_version (or makeActive true) makes it active, and then every playlist and calendar entry that follows the template shows it (running playouts within seconds); assignments pinned to a version keep theirs. The document is validated; a validation failure lists the broken fields.
template_delete_version
ChatGPTUse this when the user wants to remove an overlay template version they no longer need. Permanently delete an overlay template version and its cached renders. Refused for the active version and for any version a playlist or playlist item is pinned to.
template_get
ChatGPTUse this when the user wants to see or change an overlay template's design. Read one overlay template by templateId (from template_list): its version history and the active version's full overlay document (overlaysData), which is what an edit would modify. Also lists the {{variables}} the document references, which per-video metadata fills in at render time.
template_list
ChatGPTUse this when the user asks about their overlay templates: lower thirds, tickers and other designs drawn over a playlist stream's videos. List the overlay templates in this workspace: name, description, aspect ratio, the active (published) version and how many versions exist. Templates are overlay designs that playlists and calendar entries show at their published version (unless an assignment is pinned to one); template_get returns one template's version history and its active document. No overlay documents are included here.
template_publish_version
ChatGPTUse this when the user is happy with an overlay template version and wants it to become the active one. Publish an overlay template version: it becomes the template's active version, which every playlist, playlist item and calendar entry that follows the template shows from now on. Running playouts take it within seconds, calendars at their next slot. Assignments pinned to a version keep it. Publishing the previous version undoes it.
template_update_playlist_to_latest
ChatGPTUse this when a playlist's overlay template is pinned to an older version and the user wants it to show the latest one. Make a playlist's overlay template assignment follow the template's published (active) version again, which unpins it. Only for a playlist whose assignment is pinned (overlayTemplate.pinned true in playlist_get): one that follows already shows each version as it is published, and the call is refused as a no-op. A running stream that plays the playlist takes the new version within seconds. Fails when the playlist has no template assigned or the template has no active version.
template_update_version
ChatGPTUse this when iterating on an overlay template version that has not been published yet. Edit an UNPUBLISHED draft version of an overlay template in place: replace its overlay document and/or description while iterating. Refused for the active version, whose document is what every assignment following the template renders: change published designs through template_create_version instead.
video_get_transcript
ChatGPTUse this when the user wants the words spoken in a library video, for example to write a title, description or summary. Read the stored caption transcripts of a video in the media library. Returns one row per caption track: language code, kind (manual = uploader-provided, auto = speech-to-text) and the plain transcript text. Manual tracks come first. text is null while extraction is still pending, and the list is empty when the import carried no captions.
