Server definition

Hash: sha256:df0e141a8766123dd09223e78ec1d67ad05b2823c1d18f4e5e65def5be5b8eb0
What it is: What a remote MCP server returned when asked what it offers: 17 tools

The blob, as servednamed by its sha256

{
  "instructions": "You are connected to Flask — a video collaboration platform where creative teams give feedback on videos with voice, camera, and screen recordings instead of typing. AI extracts summaries and transcripts from recordings.\n\nAll tools operate on the user's active team. No team switching needed.\n\n## Data Model\n- **Folder** = a project container (itself an asset of type \"folder\", nestable). Folders organize work but are OPTIONAL — there is no required \"root folder\". Root simply means an asset with no parent; assets can live directly at the team's top level. You do NOT need a folder to upload.\n- **Asset** = the unit of work, inside a folder OR at the team root. An asset is a CONTAINER that owns the title, folder placement and sharing/permissions; the media itself is its VERSIONS (v1, v2, ...): each version is a media row (video, youtube, image, blank, link). The asset's url (https://flask.do/a/<asset_id>) always opens the newest version; a version's own url with ?pin=1 opens that exact version.\n- **Which id to pass**: contents, search and feedback_stats hand out the asset id (asset_id = the container) plus version_id (its current version). feedback_list, wait_for_feedback, feedback_post, asset_status and tags accept EITHER: an asset id resolves to its current version, a version id targets that exact version. Feedback lives on versions; every feedback item's url deep-links to the version it was left on.\n- **Versioning** = when uploading a new iteration of something that already exists in Flask, pass version_of (the asset id, or any of its version ids) on the upload tools instead of creating a separate asset. Upload tools return asset_id = the NEW VERSION id (poll asset_status / wait_for_feedback with it), container_id = the asset, url = the asset link (always newest) and version_url = the pinned version link.\n- **Feedback** = annotation on an asset. type \"text\" has a written `content` body. type \"recording\" has a voice/camera/screen recording — ONE recording is ONE comment — exposed in the `recording` object: `transcript` (the recording's full verbatim transcript; the comment's `content` is the AI-organized version of the same feedback), `visual_references` (the deictic phrases the reviewer spoke — \"this\", \"over here\", \"that gradient\" — each with the `recording_time` it was said), `recording_url`, `recording_duration`. The transcript is the primary feedback; get_annotated_frames(element_id) returns curated supplementary visuals (the media under review with the reviewer's drawing, plus shared SCREEN frames - never webcam). When a pointing word is unresolved, take its phrase from `visual_references` and call get_frame(element_id, word) — or get_frame(element_id, at) for a raw time — to see exactly what was being pointed at. Any feedback item (including type \"text\") can also carry visual attachments: `images` (attached image files) and `has_drawing: true` (a drawing made directly on the asset, no recording involved). When either is present, call get_annotated_frames(element_id) to see them - the drawing is rendered onto the exact frame it was drawn over.\n- **Tag** = label for organizing feedback, scoped to a team. Each feedback item carries a `tags` array of `{ id, name }` derived from the comment's inline tag mentions — use the names directly, no lookup needed. tags() reports team-wide distribution. Tags (including statuses like \"Done\") are team-scoped and collaborative: feedback_post applies them at creation and feedback_update can add/remove them on ANY feedback item you can comment on - but only tags that already exist in the team (create new tags in the Flask app).\n\n## Navigation\n1. contents() → team root: folders AND assets that live at the top level (each asset item carries asset_id, version_id, version_count, url, version_url)\n2. contents(folder_id) → child folders + assets\n3. feedback_list(asset_id or version_id) → feedback on an asset (its current version) or on one exact version\n4. feedback_get(element_id) → feedback item + full reply thread\n5. get_annotated_frames(element_id) → curated supplementary visuals (drawings + shared screen; never webcam) with the transcript marked [FRAME N]. get_frame(element_id, at|word) drills deeper to a specific moment or spoken word.\n\nMost tools are read-only. The tools that write are: the three upload tools (upload_video imports from a URL; upload_file_start + upload_file_complete upload a local file), and the two feedback write tools (feedback_post creates a comment, feedback_update edits one). All writes act AS the connected user under the exact permission rules the app enforces. The MCP cannot delete anything, and cannot create recordings, drawings, or image attachments.\n\nA key write use case: importing feedback that lives outside Flask (an email, a Slack thread, meeting notes) into the asset it refers to. Convert any timestamps in the source (like \"at 1:32\") to seconds and pass them as timestamp so each comment is anchored to the right moment; feedback without a usable timestamp becomes a general comment.\n\n## Tools\n- Browse: contents\n- Feedback: feedback_list, feedback_get\n- Feedback: wait_for_feedback — long-poll that blocks up to ~45s and returns new feedback the moment it is left. Loop it (pass next_since each time) to listen continuously. Prefer this over repeatedly calling feedback_list.\n- Feedback (WRITE): feedback_post — create a comment on an asset as the connected user. Pass timestamp (seconds) whenever the source material has one; omit it for a general note. tags applies existing team tags by name; reply_to threads under an existing item.\n- Feedback (WRITE): feedback_update — edit a feedback item. Text/timestamp changes are allowed only on the user's own comments; add_tags/remove_tags (team tags and statuses, by name) work on any item with comment access — e.g. add \"Done\" to mark feedback resolved.\n- Visual: get_annotated_frames — for a recording item, returns curated supplementary frames + the transcript marked [FRAME N]. The transcript is the primary feedback; these frames show the media under review with the reviewer's drawing rendered in, plus their shared SCREEN when they demonstrated something (never webcam). Also works on text comments with visual attachments: a standalone drawing (has_drawing: true) is rendered onto the frame it was drawn over, and attached images (images array) come back as frames. Use it whenever feedback references something visually (\"this\", \"here\", \"look at this\", \"let me show you\") or carries images / has_drawing. Up to 12 images returned inline.\n- Visual drill-down: get_frame — get the exact frame at a recording time (at) or when a word/phrase was spoken (word); use when get_annotated_frames did not resolve a 'this/here/that' reference, or to see a moment the transcript mentions. Returns the asset frame at that moment plus any active shared screen, and a transcript snippet around it.\n- Tags: tags — lists the team's tags and reports the share of each tag (plus \"untagged\") across the chosen scope (team, folder_id, or asset_id)\n- Search: search — unified search across folders, assets, and feedback in one call\n- Activity: recent_activity — latest feedback (text + recording) newest-first. Scope with folder_id to read one client's/project's feedback across all its assets in one call; narrow with since/until; page with offset. Items carry the asset and its version number.\n- Insights: feedback_stats — aggregate feedback counts across many assets in ONE call: per asset and per version (v1, v2, ...), split by type, tag, and author, with first/last feedback timestamps. Scope by folder_id, asset_id, or whole team; window with from/to. Use for trend questions (\"are v1 notes trending down for this client?\", \"what tags dominate?\") instead of calling feedback_list per asset.\n- Media: asset_status — check processing status/progress of a video; pass a version id (from an upload) or an asset id (resolves to its current version; \"no_versions\" when the asset has no media yet)\n- Sharing: permission_get\n- Upload (WRITE): upload_video — import a video from a public URL (direct file link or Google Drive). folder_id is OPTIONAL — omit it to upload to the team's top level (root). Returns asset_id (the new version), container_id (the asset), url and version_url; then poll asset_status(asset_id) until \"ready\".\n- Upload (WRITE): upload_file_start — start uploading a LOCAL video file (max 5GB). folder_id is OPTIONAL — omit it to upload to the team root. Returns the shareable link immediately plus a presigned URL and the exact curl command to upload the bytes.\n- Upload (WRITE): upload_file_complete — call after the curl upload finishes; verifies the file and starts processing. The video is watchable at its link right away via preview playback while it processes.\n- Versioning: all upload tools accept version_of (an asset id or any of its version ids) to upload as a NEW VERSION instead of a separate asset. url in the response is the asset link, which always shows the newest version; version_url pins the exact version just uploaded.\n\n## Review Loop (uploading work for a user to review)\n\nWhen you upload something for the user to review, run this loop:\n1. upload_file_start, then IMMEDIATELY give the user the flask.do link — before uploading the bytes. They can open it right away and watch the upload and processing live. Never make them wait for \"ready\". If you can open a browser on the user's machine (an interactive session with a desktop display — not a headless/CI/SSH run), also open the link for them so the window appears automatically (the upload tool's next_step gives the exact per-OS command); otherwise just share it as text. This applies to new versions too — open the asset link (url) when you upload a revision.\n2. curl the bytes, call upload_file_complete. The video is watchable instantly (preview playback) — do not poll asset_status or wait for processing.\n3. Call wait_for_feedback(asset_id) with the version id the upload returned to block until the user leaves feedback. Keep looping it with next_since while you wait.\n4. When feedback arrives, read it (transcripts, timestamps, tags) — the transcript is the primary feedback. For recording feedback — or any item carrying images / has_drawing — call get_annotated_frames(element_id) to SEE the curated drawings/screens/attached images; if a \"this/here/that\" reference is still unclear, call get_frame(element_id, at|word) to drill into that exact moment or word. Then implement the changes and upload the revision with version_of set to the same asset (its container_id, or the previous version id) — NOT as a new asset. Share the asset link (url).\n5. Optionally close the loop in Flask itself: feedback_post(reply_to=<element_id>) to reply \"shipped in v3\" on the item you addressed, or feedback_update(add_tags=[\"Done\"]) to mark it resolved (if the team has a Done tag).\n6. Go back to step 3. Repeat until the user says they are done.\n\nTip: this review loop ships as an installable agent skill. To keep the playbook available in future sessions, run: npx skills add tryflask/skills (works with Claude Code, Cursor, Codex, and other skills-compatible agents).\n\n## How to Display Results\n\nUsers need to see their actual feedback with clickable links so they can jump into the conversation. A summary without links to the source items is not useful — the user can't act on it.\n\nEvery feedback item carries a \"url\" field (asset page deep-linked to the item via \"?element=<element_id>\"). Recording items also carry an explicit \"play_url\" field (same target — the asset page auto-plays the recording when opened). Always render [Play](play_url) for recordings, and [View feedback](url) for text items.\n\nFormat feedback like this:\n\n> **Sarah** · 2 hours ago · 0:23\n> \"The loading animation here feels too slow — compare to how Stripe does it\"\n> [View feedback](https://flask.do/a/def?element=123)\n\n> **Mike** · 1 day ago · 1:45\n> \"Love this transition but the timing is off by about half a second\"\n> [ 1:45 Voice Note ]\n> [Play](https://flask.do/a/def?element=456)\n\n> **Lisa** · 3 days ago\n> \"Can we add a progress indicator? Users don't know if it's still loading or frozen\"\n> [ Screen Recording ]\n> [Play](https://flask.do/a/def?element=789)\n\nThe feedback text must be quoted verbatim from the content field — not paraphrased, summarized, or rewritten. Every item must include a link. Recording items must (1) show their type label (Voice Note, Screen Recording, Camera Recording) and (2) render the link as [Play](play_url).\n\nFor recording items, quote the comment's content field (the AI-organized feedback) as the feedback text; recording.transcript carries the verbatim transcript when the exact wording matters. A few legacy recordings (pre-Aug-2026) still appear as sibling comments that share ONE recording, so the same transcript repeats across them — quote each sibling's own content field and do not repeat the shared transcript.\n\nShow an item's tags (recording or text) using the names in its `tags` array, e.g. a trailing \"#Pacing #Done\". When reviewing feedback on an asset, start with a 2-3 sentence summary of themes, then show every item in the format above grouped by those tag names or by topic.\n\nFormat folders as: {icon} {name} · [Open in Flask]({url})\nFormat assets as: {title} · {type} ({duration}) · v{version_count} · [Open in Flask]({url})\nFormat search results grouped by type: Projects → Media → Feedback.",
  "tools": [
    {
      "description": "Check the processing status of a video. Pass the version id an upload returned (asset_id), or an asset id (resolves to its current version). Returns progress percentage for videos being processed, confirms it is ready, or reports no_versions for an asset that has no media yet.",
      "inputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "properties": {
          "asset_id": {
            "description": "Version id (from an upload) or asset id to check",
            "type": "string"
          }
        },
        "required": [
          "asset_id"
        ],
        "type": "object"
      },
      "name": "asset_status",
      "outputSchema": null
    },
    {
      "description": "Browse contents. Without folder_id: lists what's at the team's top level (root) — both folders and assets that live directly at root. With folder_id: opens that folder and returns its child folders and assets. Each asset item carries asset_id (the asset), version_id (its current version), version_count, its media fields, url (always the newest version) and version_url.",
      "inputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "properties": {
          "folder_id": {
            "description": "Folder to open — omit to see team root",
            "type": "string"
          },
          "limit": {
            "description": "Page size (default 20, max 100)",
            "type": "number"
          },
          "offset": {
            "description": "Items to skip for pagination",
            "type": "number"
          }
        },
        "type": "object"
      },
      "name": "contents",
      "outputSchema": null
    },
    {
      "description": "Get a single feedback item with its full reply thread. Returns the item's text body (for recordings: the AI-organized feedback), tags (by name), author, video timestamp, the recording's full verbatim transcript, visual_references (the pointing phrases - \"this\", \"over here\" - with the recording time each was spoken; feed them to get_frame to see what was being pointed at), visual attachments (images / has_drawing - render them with get_annotated_frames), and all nested replies.",
      "inputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "properties": {
          "element_id": {
            "description": "Feedback item ID to retrieve",
            "type": "string"
          }
        },
        "required": [
          "element_id"
        ],
        "type": "object"
      },
      "name": "feedback_get",
      "outputSchema": null
    },
    {
      "description": "List top-level feedback on an asset (pass the asset id for its current version, or a version id for that exact version). Returns each item's text body, tags (by name), author, timestamp, and reply_count. Recording items are ONE comment per recording: the text body is the AI-organized feedback, and the recording object adds the full verbatim transcript plus visual_references (the pointing phrases with the recording time each was spoken). Items with visual attachments carry images (attached image files) and/or has_drawing: true (a drawing made on the asset) - call get_annotated_frames to see them. Use feedback_get to read full reply threads.",
      "inputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "properties": {
          "asset_id": {
            "description": "Asset id (its current version) or version id to list feedback for",
            "type": "string"
          },
          "limit": {
            "description": "Page size (default 20, max 100)",
            "type": "number"
          },
          "offset": {
            "description": "Items to skip for pagination",
            "type": "number"
          }
        },
        "required": [
          "asset_id"
        ],
        "type": "object"
      },
      "name": "feedback_list",
      "outputSchema": null
    },
    {
      "description": "Create a feedback comment on an asset, as the connected user. Pass an asset id (the comment lands on its current version) or a version id (that exact version). PREFER passing timestamp (seconds into the video) whenever the source material has one - e.g. when importing feedback from an email like 'at 0:42 the logo is wrong', convert 0:42 to 42. Without timestamp the comment is a general (non-anchored) note. tags applies the team's EXISTING tags by name (see the tags tool); statuses are tags too. Use reply_to to reply in an existing thread. Cannot attach recordings, drawings, or images.",
      "inputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "properties": {
          "asset_id": {
            "description": "Asset id (current version) or version id to comment on",
            "minLength": 1,
            "type": "string"
          },
          "content": {
            "description": "The comment text (plain text)",
            "maxLength": 10000,
            "minLength": 1,
            "type": "string"
          },
          "reply_to": {
            "description": "Feedback item id to reply to (threads the comment under it)",
            "type": "string"
          },
          "tags": {
            "description": "Tag NAMES to apply (must already exist in the team - see the tags tool)",
            "items": {
              "minLength": 1,
              "type": "string"
            },
            "maxItems": 20,
            "type": "array"
          },
          "timestamp": {
            "description": "Video time in SECONDS the comment refers to (e.g. 72.5 for 1:12.5). Strongly preferred when known; omit for a general comment.",
            "type": "number"
          }
        },
        "required": [
          "asset_id",
          "content"
        ],
        "type": "object"
      },
      "name": "feedback_post",
      "outputSchema": null
    },
    {
      "description": "Aggregate feedback statistics across many assets in ONE call - counts per asset and per version (v1, v2, ...), split by type (text/recording), tag, and author, with first/last feedback timestamps. Scope to a folder (folder_id), one asset (asset_id - an asset id or any of its version ids; the whole asset is reported, version by version), or the whole team; narrow the time window with from/to. Each item carries container_id (the asset) and its versions. Use this for trend questions like 'are v1 notes going down across this client's recent videos' or 'what tags dominate this folder' instead of calling feedback_list per asset. For reading the feedback text itself across assets, use recent_activity.",
      "inputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "properties": {
          "asset_id": {
            "description": "Scope to one asset or version stack (mutually exclusive with folder_id)",
            "type": "string"
          },
          "folder_id": {
            "description": "Scope to this folder's subtree (mutually exclusive with asset_id)",
            "type": "string"
          },
          "from": {
            "description": "Only count feedback created at/after this ISO timestamp",
            "type": "string"
          },
          "to": {
            "description": "Only count feedback created at/before this ISO timestamp",
            "type": "string"
          }
        },
        "type": "object"
      },
      "name": "feedback_stats",
      "outputSchema": null
    },
    {
      "description": "Edit an existing feedback item. content (replaces the text) and timestamp (video time in seconds) can only be changed on the connected user's OWN comments. add_tags / remove_tags apply the team's existing tags by NAME and work on ANY feedback item you can comment on (labels and statuses are collaborative - e.g. add the 'Done' tag to mark feedback resolved). Provide at least one of content, timestamp, add_tags, remove_tags.",
      "inputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "properties": {
          "add_tags": {
            "description": "Tag NAMES to add (must already exist in the team)",
            "items": {
              "minLength": 1,
              "type": "string"
            },
            "maxItems": 20,
            "type": "array"
          },
          "content": {
            "description": "New comment text (fully replaces the existing text; own comments only)",
            "maxLength": 10000,
            "minLength": 1,
            "type": "string"
          },
          "element_id": {
            "description": "Feedback item to edit",
            "minLength": 1,
            "type": "string"
          },
          "remove_tags": {
            "description": "Tag NAMES to remove",
            "items": {
              "minLength": 1,
              "type": "string"
            },
            "maxItems": 20,
            "type": "array"
          },
          "timestamp": {
            "description": "New video time in SECONDS the comment refers to (own comments only)",
            "type": "number"
          }
        },
        "required": [
          "element_id"
        ],
        "type": "object"
      },
      "name": "feedback_update",
      "outputSchema": null
    },
    {
      "description": "Supplementary visuals for a feedback item. For recording items: the media under review with the reviewer's drawing rendered in, plus their shared SCREEN when they demonstrated something (e.g. a Photoshop/Figma mockup); webcam frames are NOT included, and the transcript is returned marked [FRAME N]. Also works for text comments that carry visuals: a standalone drawing (has_drawing: true) is rendered onto the frame it was drawn over, and attached images (images array) are returned as frames. If a visual reference is still unclear, call get_frame to drill into a specific moment (at) or spoken word/phrase (word). Returns up to 12 images.",
      "inputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "properties": {
          "element_id": {
            "description": "The feedback item (element) to get annotated frames for",
            "type": "string"
          }
        },
        "required": [
          "element_id"
        ],
        "type": "object"
      },
      "name": "get_annotated_frames",
      "outputSchema": null
    },
    {
      "description": "Drill into a recording for MORE visual detail: get the exact frame at a specific time (at) or when a specific word/phrase was spoken (word). Use when get_annotated_frames did not show what a reference ('this','here','that') means, or to see a moment the transcript mentions. Returns the asset frame at that moment (plus the active shared screen, if any) and a transcript snippet around it.",
      "inputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "properties": {
          "at": {
            "description": "recording time in seconds",
            "type": "number"
          },
          "element_id": {
            "description": "The recording feedback item (element) to drill into",
            "type": "string"
          },
          "source": {
            "description": "limit to the asset frame or the shared-screen frame",
            "enum": [
              "asset",
              "screen"
            ],
            "type": "string"
          },
          "word": {
            "description": "a word or short phrase the reviewer spoke",
            "type": "string"
          }
        },
        "required": [
          "element_id"
        ],
        "type": "object"
      },
      "name": "get_frame",
      "outputSchema": null
    },
    {
      "description": "See who has access to a folder or an asset and their permission levels (full_access, comment, view, none). Returns the connected user's effective access, the creator, plus link and team-member default access levels. Pass folder_id for a folder, or asset_id for an asset (an asset id or any of its version ids - permissions live on the asset, versions inherit them).",
      "inputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "properties": {
          "asset_id": {
            "description": "Asset (or version) to check permissions for",
            "type": "string"
          },
          "folder_id": {
            "description": "Folder to check permissions for (or pass asset_id)",
            "type": "string"
          },
          "limit": {
            "description": "Page size for members (default 20, max 100)",
            "type": "number"
          },
          "offset": {
            "description": "Members to skip for pagination",
            "type": "number"
          }
        },
        "type": "object"
      },
      "name": "permission_get",
      "outputSchema": null
    },
    {
      "description": "Get the latest comments across your team, newest first. Returns a mix of text and recording comments with author, timestamp, and a link to jump into the conversation. Each item has a `type` field (\"text\" or \"recording\") plus the asset it belongs to (container_id / container_title), the version it was left on (asset_id = version id, version number), so you can read feedback across many videos in one call. Scope with folder_id to read one client's/project's feedback, narrow the window with since/until, and page with offset. For counts and trends use feedback_stats instead.",
      "inputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "properties": {
          "folder_id": {
            "description": "Only feedback on assets inside this folder's subtree",
            "type": "string"
          },
          "limit": {
            "description": "Number of comments to return (default 20, max 100)",
            "type": "number"
          },
          "offset": {
            "description": "Items to skip for pagination (use next_offset from the previous response)",
            "type": "number"
          },
          "since": {
            "description": "Only feedback created at/after this ISO timestamp",
            "type": "string"
          },
          "until": {
            "description": "Only feedback created at/before this ISO timestamp",
            "type": "string"
          }
        },
        "type": "object"
      },
      "name": "recent_activity",
      "outputSchema": null
    },
    {
      "description": "Search across your team's folders, assets, and feedback by text. Always returns all three categories together.",
      "inputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "properties": {
          "limit": {
            "description": "Max results per category (default 10, max 50)",
            "type": "number"
          },
          "query": {
            "description": "Text to search for",
            "type": "string"
          }
        },
        "required": [
          "query"
        ],
        "type": "object"
      },
      "name": "search",
      "outputSchema": null
    },
    {
      "description": "List the team's tags and show the share of each tag (plus an 'untagged' bucket) across a scope. Scope defaults to the whole team; pass folder_id to narrow to one folder (its whole subtree), or asset_id to narrow to one asset (an asset id counts feedback across ALL its versions; a version id widens to its asset). Shares are count_with_tag / total_elements and do NOT sum to 100% because elements can carry multiple tags.",
      "inputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "properties": {
          "asset_id": {
            "description": "Narrow to this asset (mutually exclusive with folder_id)",
            "type": "string"
          },
          "folder_id": {
            "description": "Narrow to this folder (mutually exclusive with asset_id)",
            "type": "string"
          }
        },
        "type": "object"
      },
      "name": "tags",
      "outputSchema": null
    },
    {
      "description": "Finalize a local file upload started with upload_file_start. Call this only AFTER the curl PUT has finished successfully. Verifies the file landed in storage and starts video processing. Safe to retry.",
      "inputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "properties": {
          "asset_id": {
            "description": "The asset_id (version id) returned by upload_file_start",
            "type": "string"
          },
          "version_of": {
            "description": "Ignored (kept for older clients): the version is attached at upload_file_start.",
            "type": "string"
          }
        },
        "required": [
          "asset_id"
        ],
        "type": "object"
      },
      "name": "upload_file_complete",
      "outputSchema": null
    },
    {
      "description": "Start uploading a LOCAL video file from the user's machine into Flask. Creates the asset immediately (container_id + shareable url, live before any bytes move) with the file as its version (asset_id / version_id), or a new version of an existing asset with version_of, and returns a presigned upload URL. After calling this, upload the file bytes with the curl command from next_step, then call upload_file_complete. folder_id is OPTIONAL: omit it to upload to the team's top level (root). Max file size 5GB. Free to use for up to 100 MCP uploads; beyond that the user needs a plan at https://flask.do/plan. You still need edit access on the folder if one is given.",
      "inputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "properties": {
          "content_type": {
            "description": "MIME type of the file (defaults to video/mp4)",
            "type": "string"
          },
          "file_size": {
            "description": "Exact size of the local file in bytes (e.g. from `stat -f%z <file>` on macOS or `stat -c%s <file>` on Linux)",
            "exclusiveMinimum": 0,
            "maximum": 9007199254740991,
            "type": "integer"
          },
          "folder_id": {
            "description": "Optional folder to upload into (you must have edit access - check with permission_get if unsure). Omit to upload to the team's top level (root).",
            "type": "string"
          },
          "title": {
            "description": "Title for the new asset (defaults to \"Untitled Video\")",
            "type": "string"
          },
          "version_of": {
            "description": "Upload as a NEW VERSION of an existing asset instead of creating a separate asset. Accepts the id of the asset (its container id, what contents/search return), or of any of its versions. The new upload becomes the current version; the asset's url then shows it. folder_id is ignored when version_of is given.",
            "type": "string"
          }
        },
        "required": [
          "file_size"
        ],
        "type": "object"
      },
      "name": "upload_file_start",
      "outputSchema": null
    },
    {
      "description": "Upload a video from a public URL (a direct video file link or a Google Drive share link) into Flask. Flask downloads it, stores it, and starts processing. Creates a new asset (container_id + url) with the file as its first version (asset_id / version_id), or a new version of an existing asset with version_of. Share the returned asset URL while processing; poll asset_status(version_id) until status is \"ready\" before reporting processing complete. folder_id is OPTIONAL: omit it to upload to the team's top level (root). Free to use for up to 100 MCP uploads; beyond that the user needs a plan at https://flask.do/plan. You still need edit access on the folder if one is given. For a LOCAL file on disk, use upload_file_start instead.",
      "inputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "properties": {
          "folder_id": {
            "description": "Optional folder to upload into (you must have edit access - check with permission_get if unsure). Omit to upload to the team's top level (root).",
            "type": "string"
          },
          "title": {
            "description": "Title for the new asset (defaults to \"Video from URL\")",
            "type": "string"
          },
          "version_of": {
            "description": "Upload as a NEW VERSION of an existing asset instead of creating a separate asset. Accepts the id of the asset (its container id, what contents/search return), or of any of its versions. The new upload becomes the current version; the asset's url then shows it. folder_id is ignored when version_of is given.",
            "type": "string"
          },
          "video_url": {
            "description": "Public URL of the video to import - a direct video file URL or a Google Drive share link",
            "type": "string"
          }
        },
        "required": [
          "video_url"
        ],
        "type": "object"
      },
      "name": "upload_video",
      "outputSchema": null
    },
    {
      "description": "Wait for NEW feedback on an asset. Blocks up to timeout_seconds (default 45) and returns as soon as feedback newer than `since` arrives, or times out with an empty list. To listen continuously, call it again with the returned next_since. Use this after uploading a video for review instead of repeatedly calling feedback_list.",
      "inputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "properties": {
          "asset_id": {
            "description": "Asset id (its current version) or version id to watch for new feedback",
            "type": "string"
          },
          "since": {
            "description": "ISO timestamp — only feedback created after this is returned. Omit on the first call (defaults to now, i.e. waits for the NEXT feedback). On subsequent calls pass the next_since from the previous response.",
            "type": "string"
          },
          "timeout_seconds": {
            "description": "How long to wait before returning empty (10-50, default 45)",
            "type": "number"
          }
        },
        "required": [
          "asset_id"
        ],
        "type": "object"
      },
      "name": "wait_for_feedback",
      "outputSchema": null
    }
  ]
}

Verify it yourself

curl -s https://api.teppi.xyz/v1/evidence/sha256:df0e141a8766123dd09223e78ec1d67ad05b2823c1d18f4e5e65def5be5b8eb0 | sha256sum