FLORA

Create a shared skill in a workspace (ws_…) from flora_list_workspaces or current_workspace_id. The workspace needs the paid workspace-skills feature and write access; on a 402/403 refusal, ask for access or use a workspace that grants it. The content is the instruction body agents follow. Returns the slug flora_discover_skills retrieves it by. Personal user skills are not writable through this API.

flora_create_skill

Permanently delete one comment from a thread. The caller can delete their own comments and FLORA comments they posted; thread managers can also delete FLORA comments. Someone else's comment returns forbidden. Deleting a thread's last comment resolves the thread (thread_resolved: true).

flora_delete_comment

Discover reusable FLORA skills. Call without a name to list skills — the FLORA catalog, plus your own user skills (always included, no workspace_id needed), plus shared skills when you pass a workspace_id from flora_list_workspaces (or its current_workspace_id). Pass a name to retrieve instructions; include workspace_id for a workspace skill. If workspace access is refused (402/403), omit workspace_id or ask for access to the paid workspace-skills feature.

flora_discover_skills

Open the FLORA projects browser. Launched from the sidebar, not by the model.

flora_projects

Read a saved LoRA Style's readiness, base_model and saved trigger metadata in a workspace. Pass the style_id from flora_train_lora. When ready, pass this ID as params.lora_id (not params.style_id) in an item of flora_create_generations with a compatible model. Missing, deleted and inaccessible Styles return 404; poll the training run_id with flora_list_generations using run_ids to diagnose a failed training.

flora_get_lora

Read one prebuilt catalog action's definition: its name, description, declared inputs and outputs, and the params it accepts with their types and defaults. Read-only: it runs nothing. An action is a deterministic media or text transform (crop, resize, rotate, colour-grade, stitch or split video, split or replace text, …): one of FLORA's 42 prebuilt catalog actions, or a custom action a user wrote as code on a canvas. Actions spend no credits, but the workspace plan must include them.

flora_get_action

Get one asset's metadata, including failure_message when its upload did not finish. flora_list_assets covers the rest. Pass asset_ids instead (up to 100) to resolve a batch of ids to their URLs in one call — the asset_ids a generation's inputs report — each entry echoes the id with its url or not_found:true.

flora_get_asset

Read a project canvas in full: every node with its short id (n7), UUID, type, label, group (direct parent field short id, null for top-level nodes; omitted on older APIs), prompt, model, params, position (the anchor: top-center of the box for every type but group, which anchors top-left), size (the measured or authored box, or a conservative estimate until painted), generation status and current output, the edges between them, and an opaque revision that changes whenever anything here does. Idle nodes (added but never run) appear here; flora_list_canvas_nodes lists only media outputs. The short ids are what every canvas write accepts. A timeline node reports only a document summary: read the whole document with flora_get_canvas_node_document. A notes node carries its whole body in text.

flora_get_canvas

Read one comment thread with its live messages, oldest first. Read-only. Each message carries comment_id (cmt_…), body, author and created_at.

flora_get_comment_thread

Before reading or editing a Deck, call flora_discover_skills with name="flora-deck-editor" and follow its workflow. Read the full authored content of a document-bearing canvas node — a timeline's tracks, items and assets, a deck's slides and layers, or a note's whole text body — with its revision. For a timeline or deck, flora_get_canvas carries only a summary. To edit: read the document here, change it, and send the whole document back with flora_update_canvas_node_document, passing base_revision set to the revision read here; a stale base_revision is rejected with revision_conflict instead of overwriting another edit. Deck updates require base_revision; change only the requested slides/layers and preserve the others, including their IDs and source bindings. Deck revision checks reject observed stale reads but do not serialize simultaneous collaborators. A node that carries no document is rejected — use flora_get_canvas for its prompt, model and params; use flora_list_canvas_nodes for media outputs, including Model3D files; a timeline with no document yet returns not_found (write one with base_revision 0). A note reads as {kind:"notes", text} at revision 0 and is edited with flora_update_canvas_nodes carrying text, not with flora_update_canvas_node_document. For a deck node, pass slide to read one slide — its frame, guides and layers — instead of the whole document, and slide plus layer to read one layer; both return the revision a scoped write needs.

flora_get_canvas_node_document

Get one project's metadata. Pass project_id with the prj_ prefix from flora_list_projects or flora_create_project; an API-issued canvas URL's /projects/<id> segment becomes prj_<id>, while a bare ID is not accepted.

flora_get_project

Read how a project is shared: link sharing mode, the active share link (only when the user may manage sharing), owner, and members.

flora_get_project_sharing

Get one technique's declared inputs and outputs. Call this before flora_run_technique: the input ids it returns are the keys that tool's inputs map expects.

flora_get_technique

Read balance and spend in USD, not credits, for one workspace (workspace_id, ws_…) or across an organization (organization_id, org_…); pass exactly one. Unsure which workspace? Call flora_list_workspaces first: it returns both ids, and current_workspace_id when the user is already in one. Workspace: available_cost is what can be spent now. It is current rather than limited to the date range, does not reflect workspace spending caps, and does not guarantee a run will be admitted. What it covers depends on the caller, who may see only their own balance, and workspaces of one organization may share a pool, so never sum it across workspaces. balance_scope workspace (billing permission on a plan with usage reporting): the pool's balance, and spend carries the workspace's total_cost, classified_runs and runs_by_category for the range. balance_scope caller (anyone else, including billing admins on a plan without usage reporting): only the caller's own allowance, plus member_limit when a spending limit binds them, and spend is unavailable with reason entitlement_missing (the plan lacks usage reporting) or permission_missing (the caller lacks billing permission). Relay that reason; it never means zero spend. summary_unavailable means the totals could not be computed; a shorter range may help. classified_runs counts only runs with a known output type; unclassified spend still counts in total_cost. Organization: spend only, no balance. It returns total_cost, total_runs and runs_by_category across all its workspaces, and group_by adds by_workspace, by_model or by_day. It needs billing permission in an organization with multiple workspaces enabled. Dates are inclusive UTC days (YYYY-MM-DD) and default to the 30 days ending today; a workspace range spans at most 31 days and ends no later than today, an organization range at most 366 days. An API key needs billing permission on the workspace; other workspaces and organizations return 403.

flora_get_usage

Discover available LoRA trainer families, supported training parameters and effective web defaults, image-count limits/formats, and compatible inference model IDs with strength defaults/ranges. Call before flora_train_lora so base_model and trainer_params come from the live catalog. The resulting Style is attached to inference with params.lora_id. Defaults describe a dataset without manual labels; supplying labels selects manual captioning unless an explicit automatic mode conflicts.

flora_list_lora_trainers

List assets in a workspace or project.

flora_list_assets

List a project canvas's media nodes with their asset URLs. Idle generation nodes (added but never run) do not appear here — use flora_get_canvas to see them and the graph structure.

flora_list_canvas_nodes

List one project's comment threads, newest first. Read-only. Each thread has comment_thread_id (cth_…), status (open or resolved), anchor, position (x, y and the node_id it is pinned to), comment_count and a preview of its first comment. Filter with status, anchor, node_id and query. Read a thread's messages with flora_get_comment_thread.

flora_list_comment_threads

List a workspace's shared project folders — folder_id (fld_…), name and project count, in workspace order; private folders never appear. Pass a folder name as flora_create_project's folder to file new projects into it.

flora_list_folders

Read specific generation runs or list history. Given run IDs, pass run_ids (an array even for one run); never substitute history or another run's result. Regular run IDs need no workspace or project lookup. For technique runs, also pass technique_id; flora_list_technique_runs lists history, not an exact run lookup. Read all IDs of a batch in one call, up to 20. Reading does not block: runs take tens of seconds, so wait between polls of the same batch — at least 15 seconds, and about 2 seconds per id for larger batches (40 seconds for 20) — because every id in run_ids is one API request against the workspace's per-minute rate limit, and faster polling returns status 429 error entries. Repeated or overlapping reads inside the poll interval receive a cooldown error with retry_after_seconds; no run payload is cached, so every returned run is freshly authorized by the API. A batch where every id is rate-limited or cooling down fails the whole call with retry_after_seconds. run_ids returns {runs}, with a separate error entry (ok:false, error, and status when the API answered) for each unreadable ID. Only omit run_ids when the user wants history; that returns the API page under generations, newest first, with cost and outputs. Pass include_inputs on a history read to also get each run's submitted prompt and input references. Past the tool-result size budget, long text fields come back as previews flagged inputs.truncated — narrow the page or read full text through the API (GET /generations?include_inputs=true) or SDK directly.

flora_list_generations

List the generation models available to this account. When FLORA curates featured models they come first under `featured`, grouped by type (featured models are not repeated in `models`, and `limit` caps the total across both). Returns a summary per model with its capabilities, such as text-to-image or image-to-video; pass model_id to get one model's full parameter list for flora_create_generations.

flora_list_models

List projects in a workspace, most recently active first. workspace_id may be omitted when the caller has a single workspace (or the connection is signed into one). Without visibility, the caller's own projects; visibility narrows to their private ones or widens to every member's shared canvases. Project ids (prj_…) come from this response or an API-issued canvas URL; never guess one.

flora_list_projects

List past technique runs with their status, cost, and outputs. Also the way to find technique ids from work already done in a workspace.

flora_list_technique_runs

List saved techniques (reusable multi-step workflows) with their declared inputs, outputs, and run cost.

flora_list_techniques

List the tools available to the model on this FLORA connection, with a short purpose and safety hints for each. These purposes are abbreviated previews, not calling instructions. Before calling a listed tool, read its full registered description and input schema from your host's tools/list, including payment, retry and permission constraints.

flora_list_tools

List the FLORA workspaces this account can use. For an existing project, use its own workspace: canvas tools with optional workspace_id resolve it from project_id, so no separate workspace lookup is needed. For operations that require choosing a workspace, use current_workspace_id when returned; it is the workspace the user is already in. Otherwise, if multiple workspaces come back, name them and ask which to bill — workspaces differ in plan and entitlements. Pair any explicit workspace_id with the project's own workspace; a mismatch is rejected.

flora_list_workspaces

Search FLORA projects for composer @-mentions. Called by the host as the user types, not by the model.

flora_mention_projects

Open the FLORA action studio on one prebuilt catalog action and the inline inputs you supply, without running it, so the user can tune its parameters first. An action is a deterministic media or text transform (crop, resize, rotate, colour-grade, stitch or split video, split or replace text, …): one of FLORA's 42 prebuilt catalog actions, or a custom action a user wrote as code on a canvas. Actions spend no credits, but the workspace plan must include them. Read-only: it starts no run, writes nothing and spends nothing. To build the view it reads the action's definition. The user adjusts the parameters there and clicks Apply, which calls flora_run_action once with the chosen settings; once that run starts the view reads its status with flora_list_generations until it finishes, and Save to canvas adds the outputs with flora_add_to_canvas. Do not start a run yourself and do not poll: when the applied run finishes, the studio hands you its run id, status, outputs and final params. Hosts without MCP Apps cannot show the studio; run the action with flora_run_action there instead.

flora_open_action_studio

Open the FLORA action studio on one action node that already sits on a project canvas, prebuilt or custom, without running it, so the user can tune its parameters first. The studio shows the node's stored parameter values and wired inputs. Read-only: it starts no run, writes nothing and spends nothing. To build the view it reads the action's definition. The user adjusts the parameters there and clicks Apply, which calls flora_run_canvas_action once with the chosen settings; once that run starts the view reads its status with flora_list_generations until it finishes, and Save to canvas adds the outputs with flora_add_to_canvas. Do not start a run yourself and do not poll: when the applied run finishes, the studio hands you its run id, status, outputs and final params. Hosts without MCP Apps cannot show the studio; run the action with flora_run_canvas_action there instead.

flora_open_canvas_action_studio

Create a single-use sign-in link that opens one project canvas in a browser, signed in as the user, for session_hours. One API operation; it changes nothing in the project and returns url, canvas_url and expires_at. Open url in a browser tab you control and navigate within that tab rather than reloading it; the canvas then behaves as it does for the user. Only useful in hosts that can open and operate a browser tab (Claude Code Desktop, Cowork, or similar); elsewhere read the project with flora_get_project and flora_get_canvas, and change it with the canvas tools, instead. The link works once and acts as the user — never share it or put it in a reply. A 404 means the project id is wrong or the caller lacks access — report it, do not retry.

flora_open_project

Organize existing nodes into named fields without recreating nodes or changing their content or edges. Pass fields with labels and existing node_ids from flora_get_canvas (up to 200 requested members total). Prefer this tool for sorting work into Concepts/Finals or other fields: it validates all members first, reuses a unique matching top-level field label or creates an empty field, moves the existing nodes, grids each field's members, then separates the fitted field frames in a row clear of untouched work. Existing members of reused fields are preserved and reflowed. If existing positions must stay fixed, add or arrange only the new IDs with the dedicated add/arrange tools instead. Duplicate member IDs, ambiguous labels, nested frames, notes, labels and groups as members reject before writes. This is a multi-request workflow, not an atomic transaction: if interrupted, read the canvas and retry with the same field labels and member IDs to reuse committed frames. No explicit coordinates are accepted; use flora_update_canvas_nodes and flora_arrange_canvas for precise placement. Does not run generations.

flora_organize_canvas_fields

Open the FLORA project tray beside this conversation. Launched from the conversation's tabs, not by the model.

flora_project_tray

Delete nodes from a project canvas. Every edge touching a deleted node goes with it, and deleting a group deletes its members too; the response's removed count includes them. Deletion is immediate and cannot be undone through the API, so pass only the nodes the user asked to remove — to clear a node's content or wiring instead, edit it with flora_update_canvas_nodes. Nodes are addressed by the short id (n7) or UUID flora_get_canvas reports; an unknown id rejects the whole call with ref_not_found and nothing is deleted.

flora_remove_from_canvas

Rename a project: pass project_id (prj_…) and the new name. The API allows up to 120 characters, trims surrounding whitespace, and rejects an empty result. Projects managed by a Generation Table or backing a Production cannot be renamed here — rename them from the owning surface.

flora_rename_project

Reopen a resolved comment thread so it accepts replies again. An already-open thread is returned unchanged. A thread whose comments were all deleted stays resolved; start a new one with flora_create_comment_thread. Needs thread-manage permission; a guest who can only comment receives forbidden. Returns the thread with its messages.

flora_reopen_comment_thread

Post a reply on an open comment thread. A resolved thread rejects replies with input_validation_error: reopen it with flora_reopen_comment_thread first. A thread whose comments were all deleted stays resolved; start a new one with flora_create_comment_thread. Returns the new comment with comment_id (cmt_…).

flora_reply_to_comment_thread

Mark a comment thread resolved. Its comments are kept, and an already-resolved thread is returned unchanged. Needs thread-manage permission; a guest who can only comment receives forbidden. Returns the thread with its messages.

flora_resolve_comment_thread

Run one prebuilt catalog action headlessly on inputs you supply inline, as a single API operation that starts one run. An action is a deterministic media or text transform (crop, resize, rotate, colour-grade, stitch or split video, split or replace text, …): one of FLORA's 42 prebuilt catalog actions, or a custom action a user wrote as code on a canvas. Actions spend no credits, but the workspace plan must include them. Read the action's declared inputs and params first (flora_get_action or flora_search_actions) and pass only those; undeclared parameter names are rejected. A 403 means either the credential cannot write to that workspace (check workspace_id against flora_list_workspaces) or the plan lacks actions (tell the user that the plan does not include this) — do not retry either way. This does NOT touch the canvas — nothing appears in the project, and outputs come back from flora_list_generations. project_id only scopes authorization and generation history. To produce a canvas node, use flora_add_action then flora_run_canvas_action. To let the user tune the settings before anything runs, use flora_open_action_studio instead. Returns canvas_url; give the user that link rather than building one from an id. In MCP Apps hosts the result opens the FLORA action studio view, where the user adjusts the action's parameters (previewed live in the browser for browser-runtime actions). To build the view, the call reads the action's definition: the catalog action, or the canvas node's action (its catalog action on an API without that read). Once the run has started, the view reads its status with flora_list_generations automatically, without a click, until it finishes. The view's only other calls are on the user's click: Apply calls this tool once more with the chosen parameters, and Save to canvas adds the outputs with flora_add_to_canvas. The studio waits for the run itself, so do not poll flora_list_generations for it or ask the user to send a message to check. When the run finishes the studio hands you its run id, status, outputs and final params. For writing or fixing custom action code, the flora-action-studio skill (flora_discover_skills with name="flora-action-studio") carries tested templates.

flora_run_action

Run one action node that already sits on a project canvas — a prebuilt action, or a custom action whose user-authored code runs in FLORA's sandbox — taking its inputs from the nodes wired into it. An action is a deterministic media or text transform (crop, resize, rotate, colour-grade, stitch or split video, split or replace text, …): one of FLORA's 42 prebuilt catalog actions, or a custom action a user wrote as code on a canvas. Actions spend no credits, but the workspace plan must include them. One call is one API operation that starts one run, with these writes: params and preview state given are first saved on the node, overwriting the values they name, and its outputs replace what the node's result nodes show. A 403 means the plan lacks actions or the credential cannot write to the project's workspace, so check the workspace before telling the user that the plan does not include this. For an existing action node, use its persisted short id or UUID from flora_get_canvas; do not add a duplicate. Only add a node (flora_add_action, or flora_create_custom_action for code) when it does not exist. Connect the action's inputs — an action with required inputs and no incoming edges fails. Returns canvas_url; give the user that link rather than building one from an id. Actions cannot connect directly to other actions. Run the source action first and wait for its outputs with flora_list_generations. A browser materializes its RESULT nodes; a headless run may finish without creating canvas result nodes. Read flora_get_canvas and connect a result node only if it exists. If absent, run the next action headlessly with flora_run_action using those output URLs/text as inline inputs. To continue a media chain on the canvas, add image/video/audio output URLs with flora_add_to_canvas using type and content_url, then connect the created node to the next action and run it. In MCP Apps hosts the result opens the FLORA action studio view, where the user adjusts the action's parameters (previewed live in the browser for browser-runtime actions). To build the view, the call reads the action's definition: the catalog action, or the canvas node's action (its catalog action on an API without that read). Once the run has started, the view reads its status with flora_list_generations automatically, without a click, until it finishes. The view's only other calls are on the user's click: Apply calls this tool once more with the chosen parameters, and Save to canvas adds the outputs with flora_add_to_canvas. The studio waits for the run itself, so do not poll flora_list_generations for it or ask the user to send a message to check. When the run finishes the studio hands you its run id, status, outputs and final params. For writing or fixing custom action code, the flora-action-studio skill (flora_discover_skills with name="flora-action-studio") carries tested templates.

flora_run_canvas_action

Run generation nodes (image, video, text, audio, model3d) and timeline (video editor) nodes that already sit on a project canvas. Generation nodes run using the model, prompt, parameters and wired upstream inputs each node carries — configure the node first with flora_add_to_canvas or flora_update_canvas_nodes. A timeline node renders its document through the video editor render pipeline instead: it needs a document (written via flora_add_to_canvas, flora_update_canvas_node_document, or the editor) and spends timeline render usage rather than generation usage, so its started entry carries no model or cost estimate. SPENDS USAGE immediately, with no confirmation step; quote a cost to the user first. Returns one entry per node_id: started entries carry a run_id to poll with flora_list_generations (generations) or GET /runs/{runId} (timeline renders report progress and the finished video there), skipped entries carry a machine-readable reason (node_not_found, node_not_executable, no_model_configured, generation_already_running, timeline_no_document, timeline_not_entitled, …) and never fail the rest of the batch. Connected nodes run in dependency order, so a whole chain can be started in one call. For action nodes use flora_run_canvas_action instead.

flora_run_canvas_nodes