34 herramientas de LUVI dentro de Claude y ChatGPT

Submit a generation on a LUVI model. Charges the caller’s LUVI credits. Returns a generationId immediately (async) — poll get_generation_status until "completed". You only need the prompt and any reference(s): LUVI fills each model’s default parameters (resolution, format, …) automatically so the result matches its web app — pass a parameter only to override a default. When you DO override one, first call get_model_schema for that model’s exact keys, CASE-SENSITIVE enum values and numeric ranges: a guessed key or a value in the wrong case/format (e.g. "2K" vs the schema’s "2k") is silently dropped and the default is used instead. References go INSIDE `parameters`: either a public URL, or — to build on something already in the user’s library — the `referenceUri` string (luvi://asset/…) from list_library / get_asset, which LUVI resolves server-side. Put the reference at the model’s schema key if you know it; a common alias (image / images / reference / reference_image) is accepted and remapped. If projectId is omitted, results land in a per-connection auto-project (named after your connection). When the account already runs the most generations LUVI allows at once, the request is QUEUED instead of refused: you still get a generationId at once, it starts by itself when a slot frees, and nothing is charged until it starts — keep polling get_generation_status with that id.

Estimate how many LUVI credits a generation will cost, using the same pricing the charge will use. Call this before `generate` to show the user the cost. Pass the SAME `parameters` you will pass to `generate`, references included — several models price per input image or per second of the source media, so a quote made without them is too low.

Check a generation by id. While queued, returns its place in line (it starts by itself); while processing, returns its status. When completed, embeds image and audio results inline (images render, audio plays in-chat) AND returns direct URLs that open with no login (7-day signed; audio/video play in the browser), plus a login-gated LUVI deep-link for editing — and `creditsCharged`, what this one generation actually took off the account (the ledger figure the account page shows under Billing → Transactions, not an estimate).

Cancel a generation that is still QUEUED (waiting for one of the account’s running generations to finish). It never starts and costs nothing. A generation that has already started cannot be stopped — the provider offers no cancel — and is charged when it finishes; this tool says so instead of pretending. Pass the generationId returned by `generate`.

Return the EXACT parameter contract for a model: every parameter key, its type, the allowed enum values (CASE-SENSITIVE), numeric range, default, and the keys where reference media (image/video/audio URLs) must go. Call this BEFORE generate whenever you set ANY parameter (resolution, size, aspect ratio, duration, output format, quality, …) or attach a reference — the remote schema is authoritative and a guessed key or a value in the wrong case/format is silently dropped, so the model falls back to its default (e.g. you ask for 2K and get 1K). Send back exactly the keys and values listed here, at the reference keys listed here.

List LUVI’s active AI generation models (image, video, 3D, audio). Use this first to discover which model id to pass to `generate`. Returns id, name, provider, category and capabilities.

Return LUVI’s proprietary prompt manual for a model (reference syntax, camera vocabulary, forbidden tokens, emotion handling, length/identity limits, §citations). Call this BEFORE writing a prompt for `generate`: if a manual exists, follow it exactly then verify with check_prompt; if not, write a normal prompt. This is the LUVI Prompt Engine.

Recheck a drafted prompt against LUVI’s manual for the model. Returns rule violations (each with its manual citation) plus a deterministically-corrected prompt. Call this AFTER writing the prompt and BEFORE `generate`: apply the correctedPrompt, resolve any warnings, then generate.

Create an empty LUVI workflow (a node graph) and return its id plus a link the user can open. A workflow is a PLAN: you wire models, prompts and references together, the user reviews it on the canvas, and the server executes it deterministically. Follow this with get_workflow_ports (to learn each model’s exact port names) and wire_workflow (to write the nodes and edges). If projectId is omitted, the per-connection auto-project is used, the same one generate falls back to.

Return the exact PORT contract for one or more models: the id of every input port, what media it accepts, how many items it takes, whether it is required, and whether the model takes a prompt. Call this BEFORE wire_workflow. A generator’s media in-port id IS the provider parameter key, so `targetHandle` on an edge must be one of the ids listed here — there is nothing to guess and nothing to alias. (get_model_schema is the companion for parameter VALUES; this is for wiring.)

Write the nodes and edges of a LUVI workflow. The graph is VALIDATED before it is saved: unknown ports, wrong media kinds (an audio slot fed a video), over-filled slots, unfilled required slots, missing prompts, unknown parameters, out-of-range values and cycles are all returned as errors and NOTHING is written. Fix them and call again. Node variants: "input/text-prompt" (a prompt source), "media/buffer" (a reference SOURCE when you set `ref`, or a result SINK when something is wired into it), "operator/prompt-merge" (joins two prompts), "generator/model" (calls a LUVI model — set `modelId`). Every generator needs a media/buffer sink wired to its `out` port so its result is kept. Call get_workflow_ports first: a generator’s media in-port ids are the model’s real parameter keys. By default this REPLACES the graph; pass replace:false to merge into what is already there. Changing a saved node’s modelId is a hard break — the response carries a rebindProposal telling you exactly which wires to move.

Preview what a whole workflow will cost in LUVI credits, per node and in total, and compare it with the account balance. Uses the same billing path as the real charge, so the number here is the number that will be spent. Some nodes are marked approximate — character-priced audio cannot be quoted before the text is final, and a model priced per second of INPUT media cannot be quoted before the upstream node has produced that media.

Start a run of a LUVI workflow. This SPENDS the account’s credits, so it only works when the owner has armed the workflow for Claude on the canvas (a credit ceiling plus an expiry). If it is not armed, or the ceiling is used up, this returns the link for the owner to press Run themselves — that is a normal outcome, not an error, and you should hand them the link rather than retrying. Poll get_workflow_run for progress and results.

Read a LUVI workflow: its nodes, its wires, and the current validation issues. Use it to inspect a graph before editing it with wire_workflow, or to see why one will not run.

Check a workflow run: per-node status, what each node produced, credits actually charged so far, and any error. Poll this every few seconds while the status is "queued" or "running". Image results are embedded inline once the run finishes; do not present a result before its node reads "completed".

List the caller’s LUVI workflows, most recently updated first, with a link to each. Pass projectId to filter to one project. Use get_workflow to read a graph’s contents.

Browse the caller’s LUVI library — everything they have generated plus everything they have uploaded, newest first, across their own and shared projects. Use this to answer “what do I have”, to find an earlier piece of work, or to pick an existing asset to build on. Every item carries a `referenceUri` (luvi://asset/…): pass that string inside `generate`’s `parameters` at the model’s reference key to edit or riff on that asset, and a `creditsCharged` — what its generation cost, from the same ledger the account page bills from. Paginate with `cursor`.

Fetch one library asset by its `assetId` (from list_library). Embeds the image inline so it can be shown to the user, and returns its `referenceUri` for reuse in `generate`, a no-login share link for generated results, and `creditsCharged` — what the generation behind it cost.

Search the caller’s LUVI library — everything they generated or uploaded — by a free-text query matched against generation prompts and uploaded filenames. Returns a list of results, each with an `id`, `title` and `url`; pass an `id` to `fetch` to read the full record. (This is the ChatGPT / Deep Research compatibility entrypoint; list_library exposes richer filters.)

Fetch the full record for one library asset by the `id` returned from `search`. Returns `id`, `title`, `text` (a description of the prompt, model, media type, dimensions and the credits its generation cost), `url` and `metadata`. (ChatGPT / Deep Research compatibility entrypoint; get_asset returns the same asset with an inline image and share link.)

List the LUVI projects the caller can open — their own plus any shared with them (`shared: true`). Pass a project id to `generate`/`list_folders`/`list_library` to work inside it. If you omit projectId on `generate`, results go to an auto-created project named after your connection (e.g. "ChatGPT Studio").

Create a new LUVI project with a given name in the caller’s account. Returns its id — pass that as `projectId` to `generate` so results land in this project. (Omitting projectId on generate instead uses a per-connection auto-project.)

List folders inside a LUVI project you have access to.

Create a new folder inside a LUVI project you have access to. Returns its id — pass that as `folderId` to `generate` so results land in this folder. Optionally nest it under an existing parent folder (from list_folders) in the same project.

Rename a folder in a LUVI project you have access to. Pass the folderId from list_folders. Only the name changes — the folder keeps its id, its place in the tree, and everything inside it, so any assetId or reference you already have stays valid.

Move generations and/or uploads that ALREADY exist in the library into a folder (or back to the project root). Use this to organize existing results — e.g. after generating a batch, sort them into folders you created. `generate`’s folderId only routes NEW results; this moves ones already made. Pass assetIds from list_library ("gen:<uuid>:<idx>" or "upload:<uuid>") and the target folderId from list_folders (or null / omit to move to the project root). The folder must be one you have access to and must be in the same project as the assets — if any asset belongs to another project, nothing is moved; assets you do not own are skipped.

Move a folder (and any folders nested inside it) to the trash. The files inside are NOT deleted — they stay in the library and appear at the project root while the folder is in the trash. Recoverable with restore_folder for 24 hours, after which the folder itself is removed for good and its contents simply stay at the root. Pass the folderId from list_folders. To empty a folder without removing it, use move_to_folder instead.

Undo a delete_folder within its 24-hour window: the folder comes back with its contents exactly where they were, along with any folders that were nested inside it. If the folder was inside another trashed folder, that parent is restored too — otherwise the folder would have nowhere to sit. Pass the folderId that delete_folder returned. After 24 hours the folder is gone and this will report it as not found; the files it held are not lost, they are at the project root.

PREFERRED way to get a LOCAL/attached image, video, or audio file INTO a LUVI project — no browser, no manual drag. Returns a short-lived signed ticket + a ready-to-run script that uploads the file straight to storage (works for large videos/audio, not just small images). Use it like this: (1) call this tool with the target projectId (and optional folderId); (2) in CODE EXECUTION, find the user’s attached file on the sandbox filesystem (it is typically under /mnt/user-data/uploads/ — list that directory); (3) set FILE_PATH in the returned script to its real path and run the script (Python); (4) it prints a JSON response whose referenceUri you pass to generate. Limits: images up to 50MB, other files up to 1024MB. iPhone .mov videos are accepted (converted to MP4 after upload). Images are always stored as JPEG or PNG — HEIC, WebP, AVIF, GIF, TIFF, BMP and SVG are accepted and converted on upload (PNG when the image has transparency, JPEG otherwise), so never convert them yourself first (call get_upload_limits for the exact contract). Requirements: the user must have code execution enabled with network egress. If their sandbox Domain allowlist is "All domains" (the usual setting once egress is on), it works with no extra setup. If they use a Custom allowlist, the file bytes PUT goes straight to storage, so that allowlist must include the S3 storage host (luvi-content-creator-storage.s3.us-east-1.amazonaws.com, or *.amazonaws.com) in addition to www.luvicreator.com. If code execution is unavailable, use get_upload_link instead (a browser link the user drops the file into). If projectId is omitted, the per-connection auto-project is used; folderId (from list_folders) targets a folder.

Return a ready-to-use LUVI link that opens the upload dialog in the user’s browser, pre-pointed at a project (and optionally a folder inside it). Use this whenever the user has a LOCAL image, video, or file — e.g. one they attached to this chat — that you cannot upload yourself: MCP cannot receive an attached file’s bytes, so the user must drop it in through this link. Hand them the link; once they confirm the upload finished, find the new asset with list_library and pass its referenceUri to generate. If projectId is omitted, the per-connection auto-project is used (the same one generate falls back to); pass folderId (from list_folders) to land the file inside a specific folder.

Return the exact limits for uploading a LOCAL/attached file via create_upload_ticket (or get_upload_link): the max size for images vs. other files, the accepted formats per media type, how images are stored (always JPEG or PNG — other image formats are converted on upload), and what is rejected (ICO/PSD/JPEG XL images; .mov video is accepted and converted to MP4 after upload). Call this before uploading a large or unusual file so you can tell the user up front whether it will go through.

Show which LUVI account this connection is authenticated as — email, display name — and the connection’s name. Call this to answer "which LUVI account am I connected to?" / to confirm identity before generating.

Return the caller’s LUVI credit balance, plus this connection’s spend cap and remaining budget.

The caller’s LUVI credit ledger, newest first — every generation charge, purchase, refund, bonus and adjustment, exactly what they see in Account → Billing → Transactions. Use this for any “what have I spent”, “what did today/this month cost”, “what did I make and for how much” question. Each generation charge carries the generation id, its prompt and the model name, so it doubles as a costed history of what the account produced. Amounts are CREDITS, signed the way the ledger stores them (negative = spent); the response also totals the window. Never estimate spend from estimate_cost when this tool can report the real charge.