Corte

Define a content type. `name` is the machine name (camelCase, immutable — it is the GraphQL identity and the delivery `type=` value); `title` is what editors see. Field types: string (opt. enum), text, number, boolean, datetime, portableText, media ({storageId}), reference ({documentId}, needs `to`: [typeName]), object (nested `fields`), embed (`target`: another type’s name, its shape stored inline), array (`of`: ONE field definition every item shares — an object, never a list, e.g. {"name":"authors","title":"Authors","type":"array","of":{"type":"reference","to":["author"]}}; a list of lists is not allowed, nest an object). Set `titleField` to the field that names documents in lists. Reference targets must already exist in the project. A string, text, portableText or media field may set `localized: true` — its value is then kept per locale ({"en": …, "de": …}) across the locales in get_content_settings.

create_content_type

Start a campaign to group a set of posts — name it for the story it tells ("Spring lookbook launch"), optionally with a description and the content document it centres on. Returns the campaign; pass its id as campaignId when drafting the posts.

create_growth_campaign

Draft a social post into the Growth queue. By default it lands in `pending_review`: the person sees it in their review lane with the text, media and your suggested time, and approves, edits or declines it there — approval is the one step a tool cannot take, so tell the person the post is waiting for them rather than that it is scheduled. Pass state "draft" instead to park it unreviewed for someone to finish in the composer. Write the text platform-native for the channel (list_growth_channels) — it is checked against that platform’s limits and refused with the reason when it would not post. Media are library asset ids; links in the text become tracked links so get_growth_post_analytics can count clicks. Returns the post with its `postUrl`.

create_growth_post

Make a new project owned by the caller — a workspace whose media, cuts, workflows and generations sit together, with its own members and its own spend history. The caller pays for work done in it unless it is created in a team whose wallet pays. Returns the project (its id is what every other tool’s `projectId` takes), the member list (just the caller, as owner) and a link to the app’s project page. Do not create a project the person did not ask for: most work belongs in the one they already have, and list_projects shows what exists.

create_project

Reserve a direct upload for a file the person dropped on an inline view: returns a storageId and a signed url to PUT the bytes to; commit_upload then finalizes it. For views only — an agent with a URL uses upload_asset.

create_upload

Save a new workflow — a reusable pipeline of generation steps the person can open on the Corte canvas, run from the app, run through run_workflow, or hand to an agent. Compose the graph from a description using the node types in list_workflow_node_types: prompt and media input nodes feeding generate nodes, ending in an output node. The graph is checked before saving (unknown types, dangling edges, mismatched ports) and every problem comes back at once, so fix and resend rather than guessing. Saving is free; running spends credits. Returns the saved workflow with its id, the graph as stored, and a workflowUrl to show the person. Lands in the account’s default project unless projectId names a shared project the caller belongs to, in which case every member can see, edit and run it.

create_workflow

Decline a post that is awaiting review: it leaves the review lane and stays as history in state `declined`, never published. Only a pending_review post can be declined — anything else answers with its current state. Use it when the person says no to a draft, or to withdraw one you queued by mistake; to remove the record entirely use delete_growth_post.

decline_growth_post

Delete an agent for good: its definition, its schedule and event subscriptions, its standing credential, and its entire run history including replies and transcripts. A run still in flight is stopped first. What the agent made — documents, posts — is not touched; only the agent and the record of its runs go. This cannot be undone and there is no archive: to stop an agent without losing it, use update_agent with enabled: false instead. Only the agent’s owner can delete it. Confirm with the person before calling this unless they asked for the deletion in so many words.

delete_agent

Remove one note from an agent — how a person corrects an agent that learned something wrong, or withdraws an instruction they gave it. Takes the note’s id from list_agent_memories. The agent may learn the same thing again from a later run if the reason it learned it is still there; deleting the note fixes the note, not the cause. Owner-only.

delete_agent_memory

Permanently delete a content document, its draft, its published copy and its full revision history. This cannot be undone — confirm with the user before calling it, and prefer unpublish_content_document when they only want it off the live site. Refuses when another published document references it; force:true deletes anyway and leaves those references dangling.

delete_content_document

Permanently delete a content type and every schema version of it. This cannot be undone — confirm with the user first. Refuses outright while another type embeds this one (fix those fields first). Refuses while documents still use it unless force:true, which DELETES THOSE DOCUMENTS TOO — call list_content_documents first, tell the user how many will go, and only then force.

delete_content_type

Delete a campaign. Its posts survive — they are simply no longer grouped — so nothing scheduled is affected and nothing published is lost.

delete_growth_campaign

Remove a post from the Growth queue for good. A scheduled post is pulled back first so it cannot go out; a post whose send is already in progress cannot be deleted. Deleting a published post removes Corte’s record of it, not the post on the platform. Prefer decline_growth_post for a reviewed draft the person said no to — that keeps the history.

delete_growth_post

Delete a workflow and its run history. Cannot be undone; the media its runs produced stays in the library. Only the creator or the project owner may delete one. Confirm with the person before calling this for anything they did not just ask you to remove.

delete_workflow

Make the ads for ONE product in an ad set (call once per product): every fitting library layout at every size of the ad set, plus AI-designed ads. Regenerating replaces the product’s unapproved ads and keeps approved ones. The product must be prepared first (prepare_catalog_product). Returns the new ads with their images, which layouts didn’t fit and why, and the credits spent.

generate_catalog_ads

Submit a generation job on any Corte model. `params` must match the model kind — image: {kind:"image", prompt, aspectRatio, resolution?, numImages?, referenceStorageIds?}; video: {kind:"video", prompt, duration, aspectRatio, resolution?, sourceVideoStorageId?, startFrameStorageId?, endFrameStorageId? (models with supportsLastFrame — pins the final frame, so two clips can be chained frame-identically), referenceImageStorageIds?, referenceVideoStorageIds?, referenceAudioStorageIds?, generateAudio? (false = video-only file, on models with supportsAudioToggle)} — LIP SYNC is a video model (sync-lipsync): sourceVideoStorageId = the clip, referenceAudioStorageIds = [the voice track], prompt optional; audio: {kind:"audio", prompt?, voice?, lyrics?, instrumental?, styleInstructions?, durationSeconds?, sourceStorageId?, videoStorageId?, targetLanguage?} — audio models carry a `category` in capabilities: tts (prompt = the words to speak — write pronunciation into the script itself, e.g. “Kimi (KEE-mee)”, since there is no separate direction field; shape delivery inline with interjection tags — (laughs), (sighs), (clears throat), (gasps) — and timed pauses as <#0.5#>; voice: OMIT it to speak in the brand’s default voice, name another of the brand’s voices (list_models’ `brandVoices`) to use that one with its delivery, and pick a stock voice from `voices` only when the person asks for one or the brand has none), dialogue (two to four people talking — an interview, a podcast, a conversation — in ONE audio file: prompt = the script, one turn per line as “Speaker: words”, where each Speaker is one of the brand’s cloned voices by name (list_models’ `brandVoices` on that model) or a stock name from the model’s `voices`; only the spoken lines — no title, notes or stage directions; no tags, punctuation carries the pacing; no `voice` param; it renders at about real time, so a long script takes minutes), music (prompt = style; lyrics on models with supportsLyrics, instrumental on models with supportsInstrumental — a vocal-song model needs lyrics), sfx (prompt), cleanup (sourceStorageId = the noisy recording + durationSeconds, its length), dubbing (sourceStorageId or videoStorageId = the source, targetLanguage from `targetLanguages`); upscale: {kind:"upscale", sourceStorageId, durationSeconds}. Models listing `resolutions` in capabilities price per tier — omit `resolution` for the default (first) tier. Check list_models for valid values. `numImages` defaults to 1 and multiplies the charge: ask for one image unless the person asked to choose between options ("give me a few", "some variations") — filling a page means one generation per slot, not four takes of each. Waits up to waitSeconds, then returns the job either way (poll with get_generation). A finished job carries `results[]`: per result a storageId, a downloadUrl that opens for 24 hours without sign-in, and a libraryUrl that is permanent and opens the asset in Corte — show the person the libraryUrl. For a permanent public URL to embed anywhere, call publish_asset with the storageId.

generate

Fetch one Corte UI registry item with its full file contents (shadcn registry-item shape). Prefer `npx shadcn@latest add @corte-ui/<name>` when working in an app with the registry configured — it resolves dependencies too; use this when you need the source directly. Every component is available on every plan.

ui_get

The authenticated account: plan (tier, price, monthly credit budget, renewal date, whether it is set to cancel or is past due), credits (remaining, purchased, spent this period, the first-top-up bonus still owed), storage (bytes used against the plan’s quota — a full quota blocks uploads and imports until files are deleted or the plan grows), and the gates that decide whether a spend goes through: emailVerified (an unconfirmed address cannot spend unless it has paid), hasPaid (any top-up or plan, which also unlocks the models list_models marks paidOnly) and suspended. Call it when the person asks what plan they are on, why something was refused, or how much room they have; for the balance alone, get_credits is cheaper and takes a projectId. Shared projects bill their owner, so this describes the caller’s own account, not a project’s payer.

get_account

Fetch one agent by id: its full prompt, the scopes it runs with, its schedule and time zone, the content events it subscribes to, whether it is enabled, and its lastRunAt / nextRunAt. Read this before update_agent — an update replaces the fields you send, so you need to know what is there. When an agent has a recipeId it tracks a curated recipe: the prompt you read back is that recipe’s current text, maintained by Corte and liable to change under the agent, not wording its owner chose. A null recipeId means the agent owns its prompt outright.

get_agent

Read one run of an agent: its subject, the owner’s message, its report, what it made, what it cost (`creditsSpent` includes the media the run generated or transcribed; `mediaCreditsSpent` is that media share), and its transcript — use it to see what an earlier run actually did before continuing its thread.

get_agent_run

Fetch one stored file by storageId: filename, content type, size, when it was added, a downloadUrl that opens for 24 hours without sign-in (plus a thumbDownloadUrl for images and video), and a permanent libraryUrl that opens it in Corte — the link to show the person. Use it to check what an id actually refers to before placing it in a document or handing it to a model. Only files the account owns or that are shared with it through a project are visible; anything else reads as unknown.

get_asset

The project’s brand: a structured identity (overview, color tokens, typography families and levels, layout spacing/rounded/elevation, component tokens, photography direction with a generation-ready `promptSuffix`, voice and tone, logo rules, dos/donts) plus `designMd`, the same rendered as a DESIGN.md. Read it before generating on-brand images, copy or UI.

get_brand

The project’s brand rendered as DESIGN.md (YAML tokens + prose sections) — drop it into a repo or a system prompt as-is.

get_brand_design_md

Fetch a brand-creation session by id: status ("running", "ready", "failed" or "accepted"), the current stage and detail while it runs, and once ready the three candidate directions in `session.worlds`, each with its id, title, rationale, full brand doc, copy, and `hero` / `ad` picture links. The polling tool for create_brand_directions; pass the same projectId the session was started in.

get_brand_directions

Fetch a brand import by id: its status ("running", "ready", "applied" or "failed"), progress stages, the extracted brand doc and — once ready — `diff`, the field-by-field changes against the project’s current brand. The polling tool for import_brand; pass the same projectId the import was started in.

get_brand_import

Inspect one Build app: the app itself, its current builder thread if it has one running, its most recent checkpoints and its most recent deploys. A checkpoint is a commit the app’s coding agent made — the newest one is first, and its `sha` is what trigger_deploy takes. A deploy carries its status and, once live, the public url. Use this to see whether a change you requested has actually landed.

get_build_app

Read what a Build app’s coding agent has said and done: its replies, a question it is waiting on (answer it with send_build_message), checkpoints it committed, errors, and the thread status (queued | provisioning | running | awaiting_input | completed | failed | cancelled). Pass `waitSeconds` to block until something worth reacting to lands instead of polling; pass the returned `lastEventId` back as `since` to read only what is new. This is the reply side of send_build_message and create_build_app.

get_build_thread

Fetch one content document: its draft and published payloads, status, and the schema it validates against. `valid`/`issues` report whether the draft would publish.

get_content_document

The project’s Content settings: its locales (code, title, fallback, required-for-publish), which one is the default/source locale, the translation settings (tone-of-voice brief, auto-translate on publish, model), and `models` — the translation models this project may choose from. Read this before adding a locale or translating.

get_content_settings

Fetch one content type by id or by machine name (e.g. "post"), with its field definitions. A name is looked up in `projectId`. Pass `version` for a historical schema.

get_content_type

Credit balance the work will spend from: the wallet that pays for the project — its owner’s, or the organisation’s — and the number that decides whether a generation there runs. Without a projectId, the account’s default project, where work that names none lands. Cheap — call it before expensive work, and again after the person says they have added credits.

get_credits

Fetch a generation job by id: status, cost, and once finished `results[]` — per result a storageId, a 24-hour downloadUrl and a permanent libraryUrl (the one to show the person). publish_asset turns a storageId into a permanent public URL.

get_generation

One campaign with every post in it (all states, newest first) and its combined performance: clicks and visitors across all its tracked links. `analytics.enabled` false means links are not tracked on this deployment and `ok` false means the read failed — neither is zero. Per-post engagement is get_growth_post_analytics.

get_growth_campaign

One post in the Growth queue: its text and media, channel, campaign, state (draft, pending_review, scheduled, publishing, pending_platform, published, failed, declined), publish time, the live URL once it is out, and `lastError` when a send failed. Use it to check whether something you drafted was approved, and before update_growth_post to see what is there now. `postUrl` opens it for the person.

get_growth_post

How one post landed: clicks and unique visitors on its tracked links (with a per-day series) and, where the platform reports it, the post’s own likes, comments, shares and views with the time they were read. Read the flags before quoting numbers: `enabled` false means this deployment does not track links at all, `ok` false means the click read failed — neither is zero clicks. `metrics` is null until the post is live or when the platform has no readable engagement; a missing field inside it means the platform does not report that number, not that it is zero.

get_growth_post_analytics

One project in full: its name and description, the caller’s role in it (owner or contributor), who pays for work done in it and the credits it can spend right now, every member with their role and email, and — when the caller owns it — the invites still waiting to be accepted. Use it before invite_to_project or remove_project_member (members carry the userId the latter takes), and whenever the person asks who is in a project or what it can spend. A project the caller is not a member of reads as unknown. Show the person the name, the role and the member list; the ids are for the other tools.

get_project

What a project has spent: its credit ledger newest first (each entry’s kind, credits, the member who spent them and when) plus, in `totalsByActor`, every member’s spend over the project’s whole history regardless of the page. The owner sees everyone’s spend; a contributor sees only their own. Pages with limit/offset and returns `total`, the number of entries visible to the caller. Use it to answer "what has this project cost", "who is spending the most" or "what did we do yesterday"; for the balance still available, get_project has remainingCredits.

get_project_usage

Read a deployed Build app’s web traffic: page views, unique visitors, views over time, top pages, referrers, countries and devices — collected on the live site itself, bots excluded. Use it to answer "how is my site doing" or to ground a change in what visitors actually do. `events` lists what happened in the window — deploys that went live and social posts whose tracked links point at this site (kind: deploy | post, actor: agent or human, with a summary) — so traffic moves can be correlated with releases and posts. Counts are estimates from sampled data, and `visitors` over multi-day ranges counts visitor-days (the count resets daily). `ok: false` means the analytics backend could not be reached — say so; it is NOT zero traffic.

get_site_analytics

One platform skill in full: its description, the interview section (the questions a brief should answer up front — for scroll-craft: subject and vibe, the belief and the action, the journey, the feeling curve and the peak, the signature-move seed, aesthetic range, one world or distinct scenes, existing assets; for scroll-world: subject, brand kit, art direction, camera, sections, mobile, resolution and media cap) and the complete procedure text. Read the interview, answer it in the brief, and the builder can start without asking.

get_skill

Fetch a transcription job by id: status, cost, and once finished the text, timed segments and `srt`/`vtt` subtitle strings. The polling tool for transcribe_asset.

get_transcription