blob_bucket
ChatGPTLists, creates or deletes Upstash Blob buckets — object storage an agent can upload files to and link to afterwards. Actions: list (every bucket in the authorized account scope), create (needs name), delete (needs bucket_id; permanent, and refused while the bucket still holds objects — empty it with blob_object delete first). A public bucket serves its objects at a permanent URL under public_host, which is what you want for a link that has to keep working, such as an image embedded in a PR body; a private bucket has no public host and its objects are reachable only through short-lived signed URLs. Never returns bucket tokens — blob_upload_url resolves those server-side.
blob_download_url
ChatGPTMints short-lived presigned GET URLs for objects in a Blob bucket, so their bytes are downloaded straight from storage — a curl inside a box, a browser — without passing through this server. This is the way to read a private bucket, whose objects have no public link; on a public bucket the permanent public_url works too and is returned alongside. The URLs only read, so they are available on read-only connections. A URL lives at most 10 minutes; set download_as to have storage serve the object as an attachment with that filename. A missing object is a 404 from storage when the URL is fetched, not an error here.
blob_object
ChatGPTLists or deletes objects in an Upstash Blob bucket — their paths, sizes and links, never their bytes. Actions: list (needs bucket_id; optional prefix and cursor; up to 1000 objects per page, and a cursor in the result means more follow — pass it back to continue), delete (needs bucket_id and paths, up to 1000 exact keys; permanent, and a path that is already gone counts as deleted). To empty a bucket before blob_bucket delete, list a page, delete its paths, repeat until list comes back empty. Never returns bucket tokens.
blob_upload_url
ChatGPTMints presigned PUT URLs for paths in a Blob bucket, so files are uploaded straight to storage from wherever they already are — a curl inside a box, a CI job — without their bytes passing through this server. Send the returned headers verbatim with the PUT: they are part of the signature, so a changed, dropped or added header is a 403 from storage. A URL lives at most 10 minutes, so mint it immediately before uploading rather than up front. On a public bucket each file also comes back with public_url, the permanent link to use once the upload succeeds (in a PR body, say); a private bucket has none. The result's curl_example is the first file's real command line.
box_account
ChatGPTAccount-wide views across every box. Actions: summary (each active box with its cost; status deleted lists the deleted ones instead), billing (this month's token and compute totals), logs (log lines from all boxes; limit, offset, level, source, search, start_time and end_time filter them).
box_apikey
ChatGPTManages Box API keys for the authorized account scope, the credential the Box SDK, CLI and deployed apps use. Actions: list (metadata only: id, name, prefix, never the secret), create (optional name; returns the secret once, so surface it to the user to store), delete (needs api_key_id; anything still using the key stops working immediately). A key is account-scoped and independent of this connection: it keeps working after the OAuth grant that created it is revoked, so tell the user to delete it, here or in the Upstash console, once it is no longer needed. Read-only OAuth grants get 403 on create and delete.
box_browser
ChatGPTDrives the headless Chromium in a box created with browser=true. Actions: goto (navigate to url and return the page), content (read the current page as title/url/text/links), screenshot (PNG of the page — returned as an image unless path is given, in which case it is saved into the box at that path instead), tabs (list the open tabs), tab_new (open a tab, optionally at url), tab_close (needs tab), live_view (a view-only page a person can open to watch the tab live — frames flow out, no input goes in, so hand the URL to the user rather than trying to click in it). box_id is required for every action.
box_config
ChatGPTChanges a running box's configuration. Actions: get (model, MCP servers and enabled skills; labels are on box_manage get); set_model (needs model); add_label and remove_label (need label); add_skill and remove_skill (need skill, as owner/repo/skill-name); add_mcp_server (needs mcp_server) and remove_mcp_server (needs name); set_network_policy (needs network_policy); set_git_identity (needs git_user_name and git_user_email); get_init_command, set_init_command (needs init_command) and delete_init_command, which apply to keep-alive boxes only. Size, browser and keep_alive are fixed at create time. Read-only OAuth connections are refused with 403 on the actions that write.
box_env
ChatGPTAccount-level environment variables, merged into every box created afterwards; a box's own env_vars win for the same key, and a box that already exists is not changed. Actions: list (values come back masked), set (needs key and value), set_all (needs env_vars, and replaces the whole set), delete (needs key). Not a secrets store: a value set here is visible inside every future box. Read-only OAuth connections are refused with 403 on the actions that write.
box_exec
ChatGPTRuns a shell command inside a box, waits for it to finish, and returns its exit code and output. Use it for file operations, package installs, builds, tests — anything a shell does. For repository work (clone, commit, push, pull request) use box_git, which also puts the GitHub credentials into the box. The command is an argv array, e.g. ['bash', '-c', 'ls -la']; an inline program is one too: ['node', '-e', code], ['python3', '-c', code] or ['npx', 'tsx', '-e', code], and content written with ['sh', '-c', 'printf %s "$1" > "$2"', 'sh', content, path] needs no quoting. folder defaults to /workspace/home, the workspace root; a clone sits at /workspace/home/<repo name>. To start something long-running (a dev server, say) without blocking, detach it inside the shell: ['sh', '-c', '( my-server > server.log 2>&1 & )']. A paused box is resumed first. Read-only OAuth connections cannot run commands: the box API refuses them with 403.
box_git
ChatGPTRuns git inside a box. Authentication comes from the GitHub installation linked to the Upstash account — the tool takes no token, and a private repo works only if that installation can see it. Actions: clone (needs repo), status, diff, commit (needs message), checkout (needs branch), push, create_pr (needs title), create_issue (needs title). Anything else git does (add, log, rebase) is a box_exec command such as ['git', 'log', '-1']. Clone with this tool rather than with git in box_exec: clone is what puts the GitHub credentials into the box, and without them push and create_pr fail with a 500. A clone lands at /workspace/home/<repo name>; pass that as folder on every other action, since the default is the workspace root, which is not a repository. create_pr opens the pull request for the branch as it exists on the remote and pushes nothing itself, so push first, and give push the branch name: without one the API pushes to a branch named after the box. Read-only OAuth connections are refused with 403 on the actions that write (clone, commit, checkout, push, create_pr, create_issue).
box_logs
ChatGPTReads a box's timestamped log entries — system, user and agent sources — which is how to find out what happened inside it. Filterable by source, level, free-text search and a timestamp window.
box_manage
ChatGPTManages Upstash Boxes — sandboxed cloud containers with a shell, a filesystem and an optional headless browser. Actions: create (set browser=true to make box_browser usable), list (optionally filtered by label or status), get, delete (permanent, takes the workspace with it), pause, resume, fork (copies an idle or paused non-ephemeral box). Every action except create and list needs box_id. Ephemeral boxes need no paid plan and are cleaned up when their TTL expires; keep-alive boxes require one.
box_metrics
ChatGPTResource and token usage for a box. Actions: current (CPU, memory and disk right now), history (a time series; range such as 1h or 24h, step such as 1m), tokens (token counts and cost over the last days), steps (the agent's commits, one per prompt, newest first), step_diff (needs sha; the diff one step made).
box_preview
ChatGPTManages public preview URLs for ports inside a box, so a service running in it is reachable from the internet. Actions: create (needs port; basic_auth or bearer_token add a generated credential, which is returned once and only here), list, delete (needs port). box_id is required for every action.
box_runs
ChatGPTInspects a box's run history — agent prompts, shell executions and browser runs — with their status, output, token usage and cost. Actions: list, get (needs run_id), cancel (needs run_id; only a run that is still running can be cancelled). box_id is required for every action.
box_schedules
ChatGPTCron schedules that run a shell command or an agent prompt inside a box on a UTC cron expression. Actions: create (needs cron and either command or prompt), list, get, update, pause, resume, delete (the last five need schedule_id). update changes only the fields given, so a new cron leaves the command alone. timeout is milliseconds; 0 clears it on update. Read-only OAuth connections are refused with 403 on the actions that write.
box_snapshots
ChatGPTManages box snapshots — full filesystem copies a new box can be built from. Actions: create (needs box_id), list (one box's snapshots, needs box_id), list_all (every snapshot in the account), delete (needs box_id and snapshot_id), restore (needs snapshot_id; creates a NEW box from the snapshot and leaves the original alone, inheriting the snapshot's model and runtime unless they are overridden).
console_redis_keys
ChatGPTConsole only: one SCAN page of a Redis database with each key's type and TTL.
console_redis_value
ChatGPTConsole only: one Redis key's type, TTL, size and a bounded read of its value.
dlq_list
ChatGPTLists the dead-letter queue for QStash messages or Workflow runs (service picks which). Paginated via cursor.
dlq_manage
ChatGPTManages a dead-letter-queue entry: get or delete (QStash and Workflow), restart or resume (Workflow only).
index_create
ChatGPTCreates a Vector index or a Search database and returns it. Its REST tokens are included only when include_credentials is true — set it when the user is going to configure an app with it; they can also be fetched later with index_get. Search takes only name, region and plan — its embedding, reranking and enrichment models are fixed by the service, and its named indexes are created implicitly by the first search_upsert. Vector takes the rest: dimensions come from the embedding model when one is given, so pass dimensionCount only for an index you will supply your own vectors to; a SPARSE index takes neither and is described by sparseEmbeddingModel alone; a HYBRID index takes both models or neither.
index_delete
ChatGPTPERMANENTLY deletes an entire Vector index or Search database, everything stored in it and its credentials. This cannot be undone. To empty one while keeping it, use index_reset; to remove a single namespace or named index, use index_delete_namespace.
index_delete_documents
ChatGPTDeletes documents from a namespace, leaving the namespace and the index in place. Payload e.g. {"ids":["a","b"]}, {"prefix":"doc-"} or {"filter":"..."}. To empty a namespace entirely use index_reset; to delete the index itself use index_delete.
index_delete_namespace
ChatGPTPERMANENTLY deletes a namespace and everything in it — for a Search database, one of its named indexes. This cannot be undone. The default namespace cannot be deleted; empty it with index_reset instead.
index_fetch
ChatGPTFetches documents by ID. Payload e.g. {"ids":["a","b"],"includeMetadata":true}, or {"prefix":"doc-","includeMetadata":true} to match an ID prefix.
index_get
ChatGPTGets details of one Vector index or Search database (endpoint, models, limits, usage). Its REST tokens are included only when include_credentials is true and the connection is read-write; on a read-only connection they are omitted (get them from the Upstash console).
index_get_stats
ChatGPTGets usage statistics of one Vector index or Search database: queries and updates today and this month, storage, bandwidth and cost this month, queries and updates per day, throughput and latency (mean and p99) over the period, and document count and data size over time. Search databases add rerank and input-enrichment figures.
index_info
ChatGPTGets runtime info: total and pending document counts, index size, and a per-namespace breakdown. For Search those namespaces are its named indexes, with their document counts.
index_list
ChatGPTLists the Upstash Vector indexes or Search databases in the authorized account scope. Never includes tokens — call index_get with include_credentials for one of them.
index_list_namespaces
ChatGPTLists the namespaces of a Vector index — or, for a Search database, its named indexes, which are the same thing. This is what search.listIndexes() calls.
index_range
ChatGPTIterates through the documents of a namespace, a page at a time. Payload e.g. {"cursor":"0","limit":100,"includeMetadata":true}; reuse the returned cursor for the next page, and stop to ask the user if the results get large.
index_rename_namespace
ChatGPTRenames a namespace — for a Search database, one of its named indexes. The new name must not already be in use, and the default namespace cannot be renamed.
index_reset
ChatGPTPERMANENTLY deletes every document in a namespace, leaving the empty namespace behind. Set allNamespaces to empty the whole index instead. This cannot be undone.
index_update
ChatGPTUpdates one existing document in place, without re-sending the rest of it. Payload e.g. {"id":"a","metadata":{...},"metadataUpdateMode":"patch"} to merge into the existing metadata, or "overwrite" (the default) to replace it; may also carry vector, sparseVector or data to re-embed. Does nothing if the id does not exist — use vector_upsert or search_upsert to create.
logs_list
ChatGPTLists delivery/run logs for QStash messages or Workflow runs (service picks which), newest first. Paginated via cursor. This is the way to inspect a Workflow run by ID, whether it has finished or is still running: pass service workflow and workflowRunId, and the entry holds the run's state, its steps and their error bodies, in one call. workflowRunId, workflowUrl, state, workflowCreatedAt and label filter Workflow runs and are refused for service qstash; count works for both.
qstash_flow_control_get
ChatGPTGets flow-control state: rate/parallelism info for a flow-control key, or the account's global parallelism when key is omitted.
qstash_flow_control_manage
ChatGPTManages a flow-control key: pause, resume, pin (payload = pin options JSON), unpin (payload = unpin options JSON) or reset_rate.
qstash_get_stats
ChatGPTGets usage statistics of a region's QStash user, which QStash and Workflow share. daily_requests has one point per day of the current month (y: QStash messages, workflow_message: the Workflow share of them, workflow_run: Workflow runs), as do daily_billings (cost) and daily_bandwidths; days still to come in the month are zeros. daily_qstash_messages (delivered, failed, retry, error, canceled, total) and daily_workflow_messages (success, failed, canceled, total) are today's running counts by outcome, sampled across period and reset at 00:00 UTC, so their last point is today so far. Also global parallelism over the period and the DLQ size. service keeps only one side's outcome series. With refresh, the API recomputes the cached figures first.
qstash_list_schedules
ChatGPTLists QStash schedules in a region.
qstash_list_users
ChatGPTLists the QStash users in the authorized account scope, one per region. Each region's REST tokens, and with region ("eu" or "us") that region's request signing keys ({ current, next }, fetched live), are included only when include_credentials is true and the connection is read-write; on a read-only connection they are omitted. The REST base URL for a region is https://qstash-<region>.upstash.io (e.g. qstash-us-east-1.upstash.io).
qstash_manage_schedule
ChatGPTManages a QStash schedule: create (destinationUrl + cron required), get, delete, pause or resume (scheduleId required).
qstash_publish_message
ChatGPTPublishes a message to a destination URL via QStash. No tokens needed — the region's QStash token is resolved server-side.
redis_create_backup
ChatGPTCreates a manual backup of an Upstash Redis database.
redis_create_database
ChatGPTCreates a new Upstash Redis database and returns it. Its credentials (password and REST tokens) are included only when include_credentials is true — set it when the user is going to configure an app with the new database; they can also be fetched later with redis_get_database.
redis_delete_database
ChatGPTPERMANENTLY deletes an Upstash Redis database and all of its data. This cannot be undone.
redis_get_database
ChatGPTGets details of a single Upstash Redis database: endpoint, region, plan, limits and state. Credentials (password and REST tokens) are included only when include_credentials is true and the connection is read-write; on a read-only connection they are omitted (get them from the Upstash console).
redis_get_insights
ChatGPTGets the Redis Insights series of a database, as the Upstash console's Insights tab shows them: latency percentiles (overall, read, write, command, Lua, replication, wait), throughput, bandwidth, disk, expired entries and replication lag, for the whole database and per region (or one replica). Also counters over the period (throttled commands, auth failures, over-size requests, undeliverable messages, Lua executions, failures, timeouts and memory-limit hits, REST commands, connections opened), each metric's mean now against the window before, and anomalies the backend detected (start, peak, baseline and change, heaviest first). Start with anomalies and counters when asked why a database is slow or failing. metrics trims the per-metric series, which are most of the response.
redis_get_stats
ChatGPTGets usage statistics of an Upstash Redis database (throughput, data size, hits/misses, etc.).
redis_get_traffic
ChatGPTGets where a Redis database's traffic comes from and how it is served: the client networks the proxies sampled (masked prefixes, cloud provider and region, share), the SDKs, platforms and runtimes clients report with their retry rate, routes from entry region to serving region with requests, connections, bytes, errors and whether they cross regions, the entry regions by share, the cross-region share of bytes, and REST vs. Lua command counts. Use it to find clients far from the database, or traffic served cross-region.
redis_list_backups
ChatGPTLists backups of an Upstash Redis database.
redis_list_databases
ChatGPTLists all Upstash Redis databases in the authorized account scope. Never includes credentials — call redis_get_database with include_credentials for one database's.
redis_rename_database
ChatGPTRenames an Upstash Redis database.
redis_run_command
ChatGPTRuns Redis commands directly on an Upstash Redis database over its REST API. No tokens needed — credentials are resolved server-side and never exposed. Each command is an array of strings, e.g. [["SET","key","value"],["GET","key"]]. One command runs directly; several run as a pipeline. Note for SCAN: reuse the returned cursor, and stop to ask the user if results get large.
redis_set_auto_upgrade
ChatGPTEnables or disables automatic plan upgrade for an Upstash Redis database.
redis_set_eviction
ChatGPTEnables or disables key eviction for an Upstash Redis database.
search_query
ChatGPTRuns a full-text and semantic search over one named index of a Search database. No tokens needed. Payload per the Search REST API, e.g. {"query":"space odyssey","limit":5,"reranking":true}.
search_upsert
ChatGPTUpserts documents into a named index of a Search database (server-side embedding), creating the named index if it does not exist. Payload e.g. [{"id":"movie-1","content":{"title":"Star Wars"},"metadata":{...}}].
upstash_console
ChatGPTOpens the Upstash console: an interactive view of the user's Redis databases and keys, QStash and Workflow schedules, logs and DLQs, Vector and Search indexes, Boxes and Blob buckets. Call it when the user asks to see, browse or open their Upstash resources rather than for a specific answer. To show one resource, pass product and resource (and a tab): the console opens on it, and the user can still navigate from there.
vector_query
ChatGPTQueries a Vector index by vector similarity. No tokens needed. Payload per the Vector REST API, e.g. {"vector":[...],"topK":10,"includeMetadata":true} — or with useData=true, {"data":"text to embed","topK":10} for embedding-model indexes. For a Search database use search_query instead.
vector_upsert
ChatGPTUpserts vectors into a Vector index. Payload e.g. [{"id":"a","vector":[...],"metadata":{...}}] — or with useData=true, [{"id":"a","data":"text to embed"}]. For a Search database use search_upsert instead.
workflow_manage_run
ChatGPTOperates on a Workflow run: get_steps returns the run's recorded steps, cancel stops it.
