Jetpost

Create a team workspace, with the user as its admin. Invite people with invite_to_workspace. Only when the user asks for one.

create_workspace

Change part of a note: replaces old_text with new_text. Works on any note the user can edit, not only their own. Copy old_text exactly from the note's current markdown (call get_note first). It must match exactly one place, so include enough surrounding text. new_text can be empty to delete. If the note changed since you read it, you get an error: re-read it and retry. Set source to say whose thinking new_text is, or pass segments when it mixes theirs and yours. The author can also change the title; pass it on its own or with a text change.

edit_note

Change part of an applet you made: replaces old_text with new_text in its HTML, and every note it's in shows the change at once. Copy old_text exactly from get_applet; it must match exactly one place. new_text can be empty to delete. For a full rewrite, use add_applet with replace.

edit_applet

The Markdown syntax, rules and an example for components create_note's ui_spec didn't cover, or for editing an existing note. Pass names to get just those. For Image and MediaHeader, assetId can be a direct public https image URL (no upload needed), or the full uploaded filename from upload_image's URL, including its extension (e.g. uuid.jpg; upload bytes first). External images load directly from their host, which must allow embedding. For Applet, appletId is the id in add_applet's url (/api/applets/<id>.html); the url works too.

get_ui_spec

A team workspace's invite link, with how many people joined through it and whether it expired: anyone signed in who has it can join. Null when there isn't one. Admins only.

get_invite_link

Invite people to a team workspace by email; each gets an invitation to accept. Admins only. Joining a team lets people see its members and every note opened to everyone there, never anyone's private notes.

invite_to_workspace

Join a team workspace with an invite link (…/join/…) or an email invitation's link (…/invite/…), as the user. Only when the user asks you to.

join_workspace

Take the user out of a team workspace. They lose its notes, including their own, and need a new invitation to come back.

leave_workspace

List the people the user can share with in a workspace: the user, everyone in it (inside: true), and people they've shared notes with there. Their ids work as recipient_ids. party is who they count as for sharing outside the workspace: their company's domain, or "personal" for a personal address (each is its own party). ambiguous_name: true means someone else in the list has the same name; it comes with their email so you can ask the user which one. Pass id (a note) to list people for that note's workspace. Share with anyone else by email address.

list_members

Make a new invite link for a team workspace. The old link, if any, stops working. Admins only.

reset_invite_link

Move a component (and everything inside it) to another parent or position.

move_component

Read or change the user's notification settings, as in the app's Settings › Notifications. note_emails: notes sent to them, and new messages in their chats, also come by email. message_sound: a quiet chime when someone writes in a note's chat while Jetpost is open in the background. With nothing passed it reads them; pass a field only when the user asks to change it. Open tabs pick up a change within about 30 seconds.

notification_settings

The signed-in user's Jetpost account: id and name.

get_profile

A components note's outline: one line per component, indented under its parent. Pass components to get their current Markdown properties and child/slot IDs before replacing their properties with patch_component(markdown).

get_note_components

Read one note: its title, workspace, author (and agent, when an agent made it), recipients, and its full text as markdown. comments is the note's chat as people see it: one stream of messages, oldest first, each with an id (pass it to add_comment as reply_to to answer it), a url linking straight to it, its author, reply_to (the id of the message it answers, or null), quote (the passage of the note it's about, or null), applet (on a message about an applet, that applet's src, written while it was expanded), its markdown, and how many thumbs-ups it has. agent is set on messages an agent wrote for its person, and primary says whose thinking it was: the person's ("user") or the agent's own ("agent"). Pass a message's link as id (or its id as message_id) and the result also has message: the message the user opened, which is what they want to work on. For the note's author, access_requests lists people asking to open it (approve or decline with share_note). A note the user can't open answers no_access. Pass since "last_seen" to get only what changed since you last read this note: the new messages (with the ones they reply to), and the body as a word diff or "unchanged". Use it when you're woken by a reply. Reading the note marks it seen for you. With authorship, the result also has authorship: the note's text in order, in spans by who wrote them ("Kyle", "Kyle via Claude", "Kyle's agent", "Kyle with Claude" for an agent's writing that didn't say whose thinking it was, or unknown when nothing recorded it), as the app's "Show who wrote what" shows it.

get_note

Read the HTML of an applet in a note (its /api/applets/... URL, as in the note's :::applet line), to see what it shows or to change it with edit_applet. Works for any applet the user can open.

get_applet

What happened recently across the notes the user can read in one workspace, newest first: edits (with who made them, a word diff, [-removed-] {+added+}, and a one-line summary when its agent described it, else null), new notes, notes shared with the user or opened to the workspace or the link, chat messages (with message_id, and quote when one quotes a passage of the note), thumbs-ups, and requests to open the user's notes (access_requested, with the request's id for share_note's approve_request_ids or decline_request_ids). The user's own activity is included. Use it to answer "what changed since I last looked?" or to decide what's worth raising with the user. Reading it doesn't mark anything seen for the user. Pass since to get only newer events: "last_looked" for everything since the user last had Jetpost open in that workspace (to catch them up), or a time. Pass before (from next_before) for older ones. When checking on a schedule, pass after: the latest_event_id from your last check, so nothing is missed. The result includes last_looked_at, when the user last had Jetpost open in that workspace. Pass notifications: true for only what was addressed to the user by someone else: notes shared with them, messages on their notes (ones they wrote, are on, or wrote in the chat of), replies to their messages, thumbs-ups on them, edits to notes they're on, and pending requests to open their notes, each with unread.

list_activity

Remove a component and everything inside it.

remove_component

Remove people from a team workspace. They lose the team's notes, including ones shared with them there. Admins only.

remove_members

Rename a team workspace. Admins only.

rename_workspace

Email pending invitations to a team workspace again (ids from get_workspace). Admins only.

resend_invitations

Find notes the user can read in one workspace, by words in their title, text or chat, and by who and when. Each result is a pointer: title, author, when it last changed, and up to two snippets showing where it matched, with **matched words** in bold and a link straight to a matching chat message. Read the whole note with get_note. Words match as prefixes and every word must appear; "quoted phrases" match exactly, or matches either side, and -word leaves notes out. Leave query empty to list notes by the filters alone, newest first. Person filters take ids from list_members. Searching the user's personal workspace also finds notes shared with them from workspaces they aren't in. For what changed recently, use list_activity instead.

search_notes

Send feedback about Jetpost to the people who build it: bugs, confusing behavior, missing features, ideas. Use it when the user asks you to send feedback, or when you hit a Jetpost problem worth reporting and the user agrees. Write it for a person: what happened, what you expected, and steps if it's a bug. It creates a note with the Jetpost team; their replies come back in that note's chat, and the user can reply by email.

send_feedback

Set a value that components read or bind to (a checkbox, a selection, a number), by its JSON Pointer, like /shared/tickets. Everyone sees the change.

set_state

Add people to one of the user's notes, take people off, open it to everyone in its workspace or to anyone with the link, answer requests to open it, email people, or a mix. Only the note's author can share it. recipient_ids are added to the people already on it (from list_members); they see the note in their inbox right away. access sets what those people can do, including people already on it. general_access sets who else can open it: only_people_added, everyone_at_workspace (a team workspace's members) or anyone_with_link (anyone signed in who has the link); general_access_role is what they can do. approve_request_ids and decline_request_ids answer access requests from get_note or list_activity; approving adds the person and emails them the note. With notify, everyone on the note who has note emails enabled and hasn't been emailed it yet gets an email from the user, sent via Jetpost. Use notify alone to email people already on a note once it's ready. Sharing with a second, different outside party, or opening the note wider, needs the user's OK: the result is needs_confirmation with a message to show them. Pass confirm only after they say yes.

share_note

Take everyone off notes shared by people who left a team workspace (ids from get_workspace's former_member_notes). Admins only.

stop_sharing_notes

Turn off a team workspace's invite link, so nobody new can join through it. Admins only.

turn_off_invite_link

Upload an image from the user's computer for a note. Call once per image with its file name. It returns upload_url and headers; send the file with one HTTP PUT from a shell: curl -sS --fail-with-body -X PUT -T <file> '<upload_url>', adding each returned header with -H 'name: value'. The file goes to Jetpost's image storage (Vercel Blob, vercel.com/api/blob). PNG, JPEG, GIF, or WebP up to 20 MB. Then put the returned markdown, with short alt text describing the image, where it belongs in the note's content (create_note, edit_note, append_to_note); if you leave the alt text empty, Jetpost writes one. Only the user can open the image until you place it: then everyone who can read that note can. For an applet, use the returned url in its HTML (<img src>, CSS or JS) instead: everyone who can open the applet sees it. The upload address expires in 15 minutes. Needs a shell; if you can't run commands, ask the user to paste the image into the note instead.

upload_image

The user's Jetpost account and the workspaces this connection can use, with their slugs, the user's role, and has_unread when a workspace has notes the user hasn't read (the app's switcher dot). lock is set when this connection is set to one workspace.

whoami

A workspace's details: the user's role and member count, and for admins its members, pending invitations (with ids), the invite link and former_member_notes (shared notes whose author left).

get_workspace

Post a message in a note's chat as the user, marked as written by you. Set primary to say whose thinking it is: "user" when you're posting what your person said or asked you to say, "agent" when the observations or suggestions are your own (e.g. they asked you to read the note and comment). People see the difference, so be honest about it. A message is about the whole note, about a passage when you pass quote, about an applet in the note when you pass applet, or answers another message when you pass reply_to (its id from get_note, or its link); passing a message link as id does the same. A reply quotes the message it answers. When your point answers a particular message, reply to it. Keep it short: one point per message, a sentence or two, no reports. Anyone who can read the note can write in its chat.

add_comment