Skip to main content
Reliant’s public API is a deliberately small slice of its full API: 22 procedures across six services, all in the reliant.v1 package and all served over Connect. This page lists them. The Go SDK wraps each in a method, and its generated clients contain exactly these procedures and no others, so a procedure that is not here cannot be called through the SDK, whatever token you hold.
This page is written by hand from proto/public-api.txt in the Reliant repository, the file that decides what is public. It is not generated yet, so it can fall behind that file. A generator that writes it from the public descriptors is planned. When this page and the file disagree, the file is right.
A request names a procedure by its path, /reliant.v1.<Service>/<Rpc>, and carries the token as Authorization: Bearer rlat_…. Most code should use an SDK rather than building requests by hand, but any Connect or gRPC client generated from the public definitions can call these.

​
Runs

RunService is fully public. A run is one execution of a workflow. Runs.Follow, Runs.FollowSession, Runs.Status and Runs.StatusSession are not procedures of their own. They are built from the reads below (GetRun, and the chat and workflow-execution reads) and add the verdict logic, which is why they are the better way to ask whether a run succeeded. A Run has a lifecycle (state and stop_reason), an outcome the workflow declared for itself, and a display_state that folds them into the one word a person reads. The display_state is one of QUEUED, RUNNING, NEEDS_INPUT, PAUSED, COMPLETED, FAILED, CANCELLED or WAITING_FOR_MACHINE. A run that completed with outcome failure has COMPLETED for its display state, so check the outcome too; the Go guide explains.

​
Triggers

TriggerService is partly public. Reading a trigger and firing it are; changing what runs unattended is not. Delivering to a webhook trigger is not one of these procedures. It is a plain HTTP POST to /hooks/{trigger id} with the trigger’s own credential, which the Go SDK’s NewWebhook sends. See Webhooks.

​
What following a run needs

A run’s progress is the update feed of the session it lives in, and its open gates are that session’s questions and approvals. The SDK reads them to follow a run, list its gates and answer a question. None of these is a general chat API.

​
Inbox

InboxService is partly public: you can read the inbox and hide or restore items, but not act on the machine-storage items it lists.

​
Which token scope each procedure needs

Reliant enforces token scopes on every call. A token with reliant:api may call any procedure on this page. A narrow token may call only these: Every other procedure on this page, including the trigger reads, the chat reads, the questions, the approvals and the inbox, needs reliant:api. A narrow token that calls one is refused with PermissionDenied (scope_missing).

​
What is not public

proto/public-api.txt classifies every service in reliant.v1, and nothing becomes public by default: a test fails when a service is left unclassified. The following are never public, and the test refuses them even if someone lists them. Every other service in the API, such as projects, workflows, settings, connections and usage, is not part of the first public surface. The set grows additively. When a procedure is added it appears here and in the SDK, and nothing listed on this page is removed within reliant.v1.

​
The TypeScript SDK

@reliantlabs/sdk generates its own, smaller set, for the streams a frontend renders. It is StreamingService (StreamUserUpdates and StreamChatUpdates), BackgroundService/StreamProcessOutput and ChatService/SendMessage. These are not in the Go list above, because a chat stream is how a UI shows a conversation rather than how a program drives a run. The TypeScript guide covers them, and the Go SDK does not wrap them.