Skip to content
Sign in

flagon-io/g1t

public
0

g1t/packages/contracts/src/clients.ts

821 lines49,255 bytesCodeBlame

Pick any line to see why it is the way it is: the commit, the pull request and issue it came from, and what the agent was thinking.

GitHub Actions on g1t, part three: .g1t/workflows, the pages, the docs1import type { ActionsApi } from "./actions";
Billing accounts, terms and enterprises; g1t is no longer free2import type { BillingAdminApi, BillingApi } from "./billing";
Deployments: a preview for every pull request, production on g1t.page3import type { DeploymentsApi } from "./deployments";
Projects: what a workspace builds and runs, first on every page4import type { ProjectsApi } from "./projects";
Events service in Rust, with RFC 3339 times and accurate push events5import type { EventsApi } from "./events";
Billing on Stripe's pages, month-end charges, warnings; sudo by workspace6import type { IdentityAdminApi, IdentityApi } from "./identity";
Integrations: your own model provider, alerts that open issues, tickets agents read7import type { IntegrationsApi } from "./integrations";
Packages, with a container registry on g1t.sh; workspaces deleted whole and kept 30 days; Members for every member8import type { PackagesApi } from "./packages";
Webhooks: every event, to your own addresses, signed and retried9import type { WebhooksApi } from "./webhooks";
Rust repos service with shipping; pull requests kept in the model10import type { ReposApi } from "./repos";
Teams and CODEOWNERS, labels and milestones, dependency updates, the security suite, and a clearer top bar11import type { PullDetail, WorkApi } from "./work";
12import type { Result } from "./result";
Fast pages, required checks on the branch, self-hosted runners, honest incidents13import type { RunnersApi } from "./runners";
API and MCP server, Rust identity service, registration, site redesign14
15/** A service binding, as far as these clients need it. */
16export type ServiceBinding = {
17 fetch(input: string, init?: RequestInit): Promise<Response>;
18};
19
20/**
21 * Calls a method on a service that speaks the JSON protocol used by the
22 * Rust services: `POST /rpc/<method>` with the arguments as the body.
23 */
24async function rpc<T>(
25 service: ServiceBinding,
26 method: string,
27 args: object,
28): Promise<T> {
29 // The hostname is ignored; a service binding always reaches its service.
30 const response = await service.fetch(`https://service/rpc/${method}`, {
31 method: "POST",
32 headers: { "content-type": "application/json" },
33 body: JSON.stringify(args),
34 });
35 if (!response.ok) {
36 throw new Error(`${method} failed with status ${response.status}`);
37 }
Agents as a team: lifecycle, merge queue, billing and a new shell38 return (await response.json()) as T;
API and MCP server, Rust identity service, registration, site redesign39}
40
41export function identityClient(service: ServiceBinding): IdentityApi {
42 const call = <T>(method: string, args: object) => rpc<T>(service, method, args);
43 return {
Invite-only launch: sign in with GitHub, repository access and lifecycle, many emails, a new look44 register: (username, email, password, inviteCode, client) =>
45 call("register", { username, email, password, invite_code: inviteCode ?? null, client: client ?? null }),
46 signIn: (username, password, client) => call("sign_in", { username, password, client: client ?? null }),
API and MCP server, Rust identity service, registration, site redesign47 signOut: (sessionToken) => call("sign_out", { sessionToken }),
Email verification, password reset, and Git for AI scale positioning48 resendVerification: (user) => call("resend_verification", { user }),
49 verifyEmail: (token) => call("verify_email", { token }),
Invite-only launch: sign in with GitHub, repository access and lifecycle, many emails, a new look50 requestPasswordReset: (email, client) => call("request_password_reset", { email, client: client ?? null }),
Email verification, password reset, and Git for AI scale positioning51 resetPassword: (token, password) =>
52 call("reset_password", { token, password }),
Device sign-in replaces registering and minting tokens over the API53 deviceStart: (clientName) => call("device_start", { clientName }),
54 deviceLookup: (userCode) => call("device_lookup", { userCode }),
55 deviceResolve: (userCode, user, approve) =>
56 call("device_resolve", { userCode, user, approve }),
57 deviceClaim: (deviceCode) => call("device_claim", { deviceCode }),
OAuth 2.1 sign-in for MCP clients and other applications58 oauthAuthorize: (user, approval) => call("oauth_authorize", { user, ...approval }),
59 oauthExchange: (code, codeVerifier, clientId, redirectUri) =>
60 call("oauth_exchange", { code, codeVerifier, clientId, redirectUri }),
61 oauthRefresh: (refreshToken, clientId) =>
62 call("oauth_refresh", { refreshToken, clientId }),
63 listOAuthGrants: (user) => call("list_oauth_grants", { user }),
64 revokeOAuthGrant: (user, id) => call("revoke_oauth_grant", { user, id }),
Thirteen MCP tools and classic token scopes; agents rate their confidence and can be put on an issue in one step65 updateOAuthGrant: (user, id, grant) =>
66 call("update_oauth_grant", { user, id, scopes: grant.scopes }),
Workspaces own repositories67 createWorkspace: (user, slug, name) => call("create_workspace", { user, slug, name }),
68 getWorkspace: (slug) => call("get_workspace", { slug }),
Merge branch 'worktree-agent-a2013627e5ea4ab13'69 workspaceResidency: (slug) => call("workspace_residency", { slug }),
70 setWorkspaceResidency: (actor, slug, residency) => call("set_workspace_residency", { actor, slug, residency }),
Workspaces own repositories71 listMembers: (slug, viewer) => call("list_members", { slug, viewer }),
72 addMember: (actor, slug, username) => call("add_member", { actor, slug, username }),
73 removeMember: (actor, slug, username) =>
74 call("remove_member", { actor, slug, username }),
Agents as a team: lifecycle, merge queue, billing and a new shell75 updateWorkspace: (actor, slug, details) =>
76 call("update_workspace", { actor, slug, ...details }),
Agents and memory, checks and conflicts, profiles, slug renames, custom domains77 renameWorkspace: (actor, slug, newSlug) => call("rename_workspace", { actor, slug, newSlug }),
78 checkWorkspaceRename: (actor, slug, newSlug) =>
79 call("check_workspace_rename", { actor, slug, newSlug }),
80 resolveSlug: (slug) => call("resolve_slug", { slug }),
Invite-only launch: sign in with GitHub, repository access and lifecycle, many emails, a new look81 deleteWorkspace: (actor, slug, confirm) => call("delete_workspace", { actor, slug, confirm }),
82 checkWorkspaceDeletion: (actor, slug) => call("check_workspace_deletion", { actor, slug }),
Workspace names and icons, and a component kit for every control83 setWorkspaceAvatar: (actor, slug, image) => call("set_workspace_avatar", { actor, slug, image }),
84 setUserAvatar: (user, image) => call("set_user_avatar", { user, image }),
Agents as a team: lifecycle, merge queue, billing and a new shell85 listWorkspaceTokens: (slug, viewer) => call("list_workspace_tokens", { slug, viewer }),
Thirteen MCP tools and classic token scopes; agents rate their confidence and can be put on an issue in one step86 createWorkspaceToken: (actor, slug, name, grant) =>
87 call("create_workspace_token", {
88 actor,
89 slug,
90 name,
91 scopes: grant?.scopes ?? null,
92 ttl_seconds: grant?.ttlSeconds ?? null,
93 }),
Agents as a team: lifecycle, merge queue, billing and a new shell94 removeWorkspaceToken: (actor, slug, id) =>
95 call("remove_workspace_token", { actor, slug, id }),
API and MCP server, Rust identity service, registration, site redesign96 userForSession: (sessionToken) => call("user_for_session", { sessionToken }),
Invite-only launch: sign in with GitHub, repository access and lifecycle, many emails, a new look97 registration: () => call("registration", {}),
98 listInvites: (user) => call("list_invites", { user }),
99 createInvite: (user, options = {}) =>
100 call("create_invite", { user, email: options.email ?? null, workspace: options.workspace ?? null }),
101 revokeInvite: (user, id) => call("revoke_invite", { user, id }),
status.g1t.sh with incident management, invites that land you in the workspace, settings as pages, usage without quotas102 checkInvite: (code, client, options = {}) =>
103 call("check_invite", {
104 code,
105 client: client ?? null,
106 viewer: options.viewer ?? null,
107 any_status: options.anyStatus ?? false,
108 }),
Invite-only launch: sign in with GitHub, repository access and lifecycle, many emails, a new look109 acceptInvite: (user, code) => call("accept_invite", { user, code }),
110 inviteMember: (actor, slug, email) => call("invite_member", { actor, slug, email }),
111 workspaceInvites: (slug, viewer) => call("workspace_invites", { slug, viewer }),
112 revokeWorkspaceInvite: (actor, slug, id) => call("revoke_workspace_invite", { actor, slug, id }),
113 requestAccess: (email, about, client) => call("request_access", { email, about, client: client ?? null }),
API and MCP server, Rust identity service, registration, site redesign114 userForGitCredentials: (username, secret) =>
115 call("user_for_git_credentials", { username, secret }),
116 userForAccessToken: (token) => call("user_for_access_token", { token }),
117 userForSshKey: (fingerprint) => call("user_for_ssh_key", { fingerprint }),
118 userByUsername: (username) => call("user_by_username", { username }),
What happened across an outcome, as a feed beside its graph119 usernames: (ids) => call("usernames", { ids }),
Agents and memory, checks and conflicts, profiles, slug renames, custom domains120 profile: (username) => call("profile", { username }),
121 updateProfile: (actor, fields) => call("update_profile", { actor, ...fields }),
122 profileWorkspaces: (username, viewer, publicIn) =>
123 call("profile_workspaces", { username, viewer, public: publicIn }),
API and MCP server, Rust identity service, registration, site redesign124 listSshKeys: (user) => call("list_ssh_keys", { user }),
125 addSshKey: (user, title, publicKey) =>
126 call("add_ssh_key", { user, title, publicKey }),
127 removeSshKey: (user, id) => call("remove_ssh_key", { user, id }),
128 listAccessTokens: (user) => call("list_access_tokens", { user }),
Thirteen MCP tools and classic token scopes; agents rate their confidence and can be put on an issue in one step129 createAccessToken: (user, name, ttlSeconds, grant) =>
130 call("create_access_token", {
131 user,
132 name,
133 ttlSeconds,
134 scopes: grant?.scopes ?? null,
135 listed: grant?.listed ?? false,
136 }),
137 updateAccessToken: (user, id, grant) =>
138 call("update_access_token", { user, id, scopes: grant.scopes }),
Agents as a team: lifecycle, merge queue, billing and a new shell139 createAgentToken: (onBehalfOf, scope, ttlSeconds) =>
140 call("create_agent_token", { onBehalfOf, scope, ttlSeconds }),
API and MCP server, Rust identity service, registration, site redesign141 removeAccessToken: (user, id) => call("remove_access_token", { user, id }),
Agents get guardrails, run credentials, an audit log, a context hub, repository instructions and mentions; security upkeep; snake_case API142 createRunCredential: (input) => call("create_run_credential", input),
143 bindRunCredentials: (tokenHashes, runId) => call("bind_run_credentials", { tokenHashes, runId }),
144 revokeRunCredentials: (target) => call("revoke_run_credentials", target),
Invite-only launch: sign in with GitHub, repository access and lifecycle, many emails, a new look145 // Who has access to a repository; see access.ts.
146 repoAccess: (owner, name, viewer) => call("repo_access", { viewer, path: { namespace: owner, name } }),
147 addCollaborator: (actor, owner, name, invitee, role) =>
148 call("add_collaborator", { actor, path: { namespace: owner, name }, invitee, role }),
149 setCollaboratorRole: (actor, owner, name, username, role) =>
150 call("set_collaborator_role", { actor, path: { namespace: owner, name }, username, role }),
151 removeCollaborator: (actor, owner, name, username) =>
152 call("remove_collaborator", { actor, path: { namespace: owner, name }, username }),
153 collaboratorPermission: (viewer, owner, name, username) =>
154 call("collaborator_permission", { viewer, path: { namespace: owner, name }, username }),
155 myRepoInvitations: (user) => call("my_repo_invitations", { user }),
156 respondRepoInvitation: (user, id, accept) => call("respond_repo_invitation", { user, id, accept }),
157 revokeRepoInvitation: (actor, owner, name, id) =>
158 call("revoke_repo_invitation", { actor, path: { namespace: owner, name }, id }),
159 setBasePermission: (actor, slug, base) => call("set_base_permission", { actor, slug, base_permission: base }),
160 outsideCollaborators: (viewer, slug) => call("outside_collaborators", { viewer, slug }),
Teams and CODEOWNERS, labels and milestones, dependency updates, the security suite, and a clearer top bar161 // Teams; see teams.ts.
162 listTeams: (viewer, workspace, query) => call("list_teams", { viewer, workspace, query: query ?? null }),
163 getTeam: (viewer, workspace, team) => call("get_team", { viewer, workspace, team }),
164 createTeam: (actor, workspace, team) => call("create_team", { actor, workspace, ...team }),
Merge branch 'worktree-agent-ad7c6d88d93adc817'165 setTeamCreation: (actor, slug, setting) => call("set_team_creation", { actor, slug, team_creation: setting }),
Teams and CODEOWNERS, labels and milestones, dependency updates, the security suite, and a clearer top bar166 updateTeam: (actor, workspace, team, changes) => call("update_team", { actor, workspace, team, ...changes }),
167 deleteTeam: (actor, workspace, team) => call("delete_team", { actor, workspace, team }),
168 teamMembers: (viewer, workspace, team, includeChildTeams) =>
169 call("team_members", { viewer, workspace, team, include_child_teams: includeChildTeams ?? false }),
170 setTeamMember: (actor, workspace, team, username, role) =>
171 call("set_team_member", { actor, workspace, team, username, role }),
172 removeTeamMember: (actor, workspace, team, username) =>
173 call("remove_team_member", { actor, workspace, team, username }),
174 childTeams: (viewer, workspace, team) => call("child_teams", { viewer, workspace, team }),
175 teamRepos: (viewer, workspace, team) => call("team_repos", { viewer, workspace, team }),
176 setTeamRepo: (actor, workspace, team, owner, name, role) =>
177 call("set_team_repo", { actor, workspace, team, repo: { namespace: owner, name }, role }),
178 removeTeamRepo: (actor, workspace, team, owner, name) =>
179 call("remove_team_repo", { actor, workspace, team, repo: { namespace: owner, name } }),
180 userTeams: (viewer, workspace, username) => call("user_teams", { viewer, workspace, username }),
181 teamMemberships: (viewer, workspace) => call("team_memberships", { viewer, workspace }),
API and MCP server, Rust identity service, registration, site redesign182 };
183}
Rust repos service with shipping; pull requests kept in the model184
Agents and memory, checks and conflicts, profiles, slug renames, custom domains185/**
186 * The slug a renamed workspace has now, for a `workspace.renamed` handler:
187 * asked of identity by the workspace's id, so that renames delivered twice
188 * or out of order converge. Falls back to the event's `to`.
189 */
190export async function currentWorkspaceSlug(
191 identity: ServiceBinding,
192 renamed: { workspaceId: string; to: string },
193): Promise<string> {
194 const names = await identityClient(identity).usernames([renamed.workspaceId]);
195 return names[renamed.workspaceId] ?? renamed.to;
196}
197
198/** The slugs whose rows move to `current`: the two a rename names, less `current`. */
199export function staleSlugs(renamed: { from: string; to: string }, current: string): string[] {
200 return [...new Set([renamed.from, renamed.to])].filter((slug) => slug !== current);
201}
202
Invite-only launch: sign in with GitHub, repository access and lifecycle, many emails, a new look203/**
204 * Where a transferred repository is now, as `namespace/name`, for a
205 * `repo.transferred` handler: asked of repos by id, so transfers delivered
206 * twice or out of order converge. Falls back to the event's destination.
207 */
208export async function currentRepoPath(
209 repos: ServiceBinding,
210 transferred: { repoId: string; name: string; to: string },
211): Promise<string> {
212 const path = await rpc<{ namespace: string; name: string } | null>(repos, "path_by_id", { id: transferred.repoId });
213 return path ? `${path.namespace}/${path.name}` : `${transferred.to}/${transferred.name}`;
214}
215
216/** The paths whose rows move to `current`: the two a transfer names, less `current`. */
217export function stalePaths(transferred: { name: string; from: string; to: string }, current: string): string[] {
218 return [...new Set([transferred.from, transferred.to].map((ns) => `${ns}/${transferred.name}`))].filter(
219 (path) => path !== current,
220 );
221}
222
223/**
224 * A repository's path change, from `repo.transferred` or `repo.renamed`,
225 * read the same way: the two paths (`namespace/name`) the event names, old
226 * then new. Null for any other event.
227 */
228export type RepoMove = { repoId: string; paths: [string, string] };
229
230export function repoMove(event: { type: string; data: unknown }): RepoMove | null {
231 const data = event.data as Record<string, string>;
232 if (event.type === "repo.transferred") {
233 return { repoId: data.repoId!, paths: [`${data.from}/${data.name}`, `${data.to}/${data.name}`] };
234 }
235 if (event.type === "repo.renamed") {
236 return { repoId: data.repoId!, paths: [`${data.namespace}/${data.from}`, `${data.namespace}/${data.to}`] };
237 }
238 return null;
239}
240
241/**
242 * Where a moved repository is now, as `namespace/name`: asked of repos by
243 * id, so moves delivered twice or out of order converge. Falls back to the
244 * event's new path.
245 */
246export async function currentMovedPath(repos: ServiceBinding, move: RepoMove): Promise<string> {
247 const path = await rpc<{ namespace: string; name: string } | null>(repos, "path_by_id", { id: move.repoId });
248 return path ? `${path.namespace}/${path.name}` : move.paths[1];
249}
250
251/** The paths whose rows move to `current`: the two a move names, less `current`. */
252export function staleMovedPaths(move: RepoMove, current: string): string[] {
253 return [...new Set(move.paths)].filter((path) => path !== current);
254}
255
Billing on Stripe's pages, month-end charges, warnings; sudo by workspace256/** Staff-only identity. Only sudo binds to it; see `IdentityAdminApi`. */
257export function identityAdminClient(service: ServiceBinding): IdentityAdminApi {
258 const call = <T>(method: string, args: object) => rpc<T>(service, method, args);
259 return {
260 workspaces: (query) => call("admin_workspaces", { query: query ?? null }),
261 workspace: (slug) => call("admin_workspace", { slug }),
Invite-only launch: sign in with GitHub, repository access and lifecycle, many emails, a new look262 waitlist: (query, status) => call("admin_waitlist", { query: query ?? null, status: status ?? null }),
status.g1t.sh with incident management, invites that land you in the workspace, settings as pages, usage without quotas263 waitlistPending: () => call("admin_waitlist_pending", {}),
264 decideWaitlist: (id, approve, staff, note) => call("admin_decide_waitlist", { id, approve, staff, note: note ?? null }),
Invite-only launch: sign in with GitHub, repository access and lifecycle, many emails, a new look265 invites: (query) => call("admin_invites", { query: query ?? null }),
266 revokeInvite: (id, staff) => call("admin_revoke_invite", { id, staff }),
267 mintInvite: (email, staff) => call("admin_mint_invite", { email, staff }),
268 grantInvites: (target, name, amount, note, staff) =>
269 call("admin_grant_invites", { target, name, amount, note, staff }),
270 inviteTree: (username) => call("admin_invite_tree", { username }),
271 workspaceInvites: (slug) => call("admin_workspace_invites", { slug }),
Packages, with a container registry on g1t.sh; workspaces deleted whole and kept 30 days; Members for every member272 deletedWorkspaces: () => call("admin_deleted_workspaces", {}),
273 restoreWorkspace: (workspaceId, staff) => call("admin_restore_workspace", { workspaceId, staff }),
274 purgeWorkspace: (workspaceId, staff, confirm) => call("admin_purge_workspace", { workspaceId, staff, confirm }),
Merge branch 'worktree-agent-a8385d293d42c913a'275 aliases: () => call("admin_aliases", {}),
276 setAlias: (alias, workspace, note, staff) => call("admin_set_alias", { alias, workspace, note, staff }),
277 removeAlias: (alias, reason, staff) => call("admin_remove_alias", { alias, reason, staff }),
Billing on Stripe's pages, month-end charges, warnings; sudo by workspace278 };
279}
280
Rust repos service with shipping; pull requests kept in the model281export function reposClient(service: ServiceBinding): ReposApi {
282 const call = <T>(method: string, args: object) => rpc<T>(service, method, args);
283 return {
284 get: (path, viewer) => call("get", { path, viewer }),
285 getById: (id, viewer) => call("get_by_id", { id, viewer }),
Fast pages, required checks on the branch, self-hosted runners, honest incidents286 readable: (ids, viewer) => call("readable", { ids, viewer }),
Agents and memory, checks and conflicts, profiles, slug renames, custom domains287 publicNamespaces: (ownerId) => call("public_namespaces", { ownerId }),
Rust repos service with shipping; pull requests kept in the model288 list: (viewer, options = {}) => call("list", { viewer, ...options }),
289 create: (owner, input) => call("create", { owner, ...input }),
Agents as a team: lifecycle, merge queue, billing and a new shell290 update: (actor, path, changes) => call("update", { actor, path, ...changes }),
Invite-only launch: sign in with GitHub, repository access and lifecycle, many emails, a new look291 transfer: (actor, path, to) => call("transfer", { actor, path, to }),
292 delete: (actor, path, confirm) => call("delete", { actor, path, confirm }),
293 deleted: (viewer, namespace) => call("deleted", { viewer, namespace }),
294 restore: (actor, path) => call("restore", { actor, path }),
295 purge: (actor, path, confirm) => call("purge", { actor, path, confirm }),
296 rename: (actor, path, name) => call("rename", { actor, path, name }),
297 archive: (actor, path, archived) => call("archive", { actor, path, archived }),
298 setVisibility: (actor, path, isPrivate, confirm) => call("set_visibility", { actor, path, isPrivate, confirm }),
299 setDefaultBranch: (actor, path, branch) => call("set_default_branch", { actor, path, branch }),
300 renameBranch: (actor, path, from, to) => call("rename_branch", { actor, path, from, to }),
301 resolveBranch: (repoId, branch) => call("resolve_branch", { repoId, branch }),
302 statusById: (id) => call("status_by_id", { id }),
Merge branch 'worktree-agent-a2013627e5ea4ab13'303 storageOptions: () => call("storage_options", {}),
Invite-only launch: sign in with GitHub, repository access and lifecycle, many emails, a new look304 resolvePath: (path) => call("resolve_path", { path }),
Rust repos service with shipping; pull requests kept in the model305 tree: (path, viewer, ref, treePath) =>
306 call("tree", { path, viewer, ref, treePath }),
307 blob: (path, viewer, ref, filePath) =>
308 call("blob", { path, viewer, ref, filePath }),
309 log: (path, viewer, ref, limit) => call("log", { path, viewer, ref, limit }),
Agents as a team: lifecycle, merge queue, billing and a new shell310 blame: (path, viewer, ref, filePath) => call("blame", { path, viewer, ref, filePath }),
Issues and pull requests replace intents and attempts311 forkForPull: (sourceId, pullId, actor) =>
312 call("fork_for_pull", { sourceId, pullId, actor }),
Rust repos service with shipping; pull requests kept in the model313 gitAccess: (path, viewer, service) =>
314 call("git_access", { path, viewer, service }),
Pull requests from branches315 branches: (path, viewer) => call("branches", { path, viewer }),
Branches and Tags pages, each file's last commit, and the branch menu on files316 lastCommits: (path, viewer, ref, treePath) => call("last_commits", { path, viewer, ref, treePath }),
317 tags: (path, viewer) => call("tags", { path, viewer }),
Merge branch 'main' into worktree-agent-a69aeabc4b0deeb97318 about: (path, viewer) => call("about", { path, viewer }),
319 languages: (path, viewer) => call("languages", { path, viewer }),
320 contributors: (path, viewer) => call("contributors", { path, viewer }),
321 license: (path, viewer) => call("license", { path, viewer }),
322 stars: (path, viewer) => call("stars", { path, viewer }),
323 star: (actor, path, starred) => call("star", { path, actor, starred }),
324 stargazers: (path, viewer, page) => call("stargazers", { path, viewer, page: page ?? null }),
325 starred: (username, viewer) => call("starred", { username, viewer }),
326 releases: (path, viewer) => call("releases", { path, viewer }),
327 release: (path, viewer, which) => call("release", { path, viewer, id: which.id ?? null, tag: which.tag ?? null, latest: which.latest ?? false }),
328 createRelease: (actor, path, release) => call("create_release", { path, actor, ...release }),
329 updateRelease: (actor, path, id, change) => call("update_release", { path, actor, id, ...change }),
330 deleteRelease: (actor, path, id) => call("delete_release", { path, actor, id }),
Download ZIP from the Code button; a slimmer lifecycle panel; agent steps say what was done, not sandbox paths331 listFiles: (repoId, ref, limit) => call("list_files", { repoId, ref, skipDirs: [], limit }),
332 rawBlobs: (repoId, hashes, maxBytes) => call("raw_blobs", { repoId, hashes, maxBytes }),
Fast pages, required checks on the branch, self-hosted runners, honest incidents333 commitFile: (repo, actor, file) => call("commit_file", { repo, actor, ...file }),
Pull requests from branches334 land: (sourceId, actor, branch) => call("land", { sourceId, actor, branch }),
Teams and CODEOWNERS, labels and milestones, dependency updates, the security suite, and a clearer top bar335 compare: (repoId, viewer, base, head, baseBranch) => call("compare", { repoId, viewer, base, head, baseBranch }),
Merge branch 'worktree-agent-ac5b181a013e54348'336 claimBackups: (limit, maxRunning) => call("claim_backups", { limit, maxRunning }),
337 // The sandbox's own calls are snake_case (they come through the API).
338 failBackup: (jobId, token, error) => call("backup_fail", { job_id: jobId, token, error }),
Rust repos service with shipping; pull requests kept in the model339 };
340}
Work service in Rust, with RFC 3339 timestamps341
Teams and CODEOWNERS, labels and milestones, dependency updates, the security suite, and a clearer top bar342/**
343 * `PullDetail`'s own fields that the work service writes in snake_case:
344 * `g1t_contracts::work::PullDetail` has no camelCase renaming, though what
345 * it holds (`Pull`, `CheckRun` and the rest) does. Each with its name here.
346 */
347const PULL_DETAIL_FIELDS = [
348 ["review_pending", "reviewPending"],
349 ["earlier_checks", "earlierChecks"],
350 ["required_checks", "requiredChecks"],
351 ["code_owners", "codeOwners"],
352] as const;
353
354/**
355 * A pull request's detail as the work service sent it, with its own fields
356 * in the camelCase this package uses: read at the edge, by `workClient`'s
357 * `getPull`. Either spelling is taken, so a service that already sends
358 * camelCase reads the same.
359 */
360export function pullDetailFromWire(raw: Record<string, unknown>): PullDetail {
361 const detail: Record<string, unknown> = { ...raw };
362 for (const [snake, camel] of PULL_DETAIL_FIELDS) {
363 if (snake in detail) {
364 if (!(camel in detail)) detail[camel] = detail[snake];
365 delete detail[snake];
366 }
367 }
368 if (typeof detail.reviewPending !== "boolean") detail.reviewPending = false;
369 return detail as PullDetail;
370}
371
Work service in Rust, with RFC 3339 timestamps372export function workClient(service: ServiceBinding): WorkApi {
373 const call = <T>(method: string, args: object) => rpc<T>(service, method, args);
374 return {
Issues and pull requests replace intents and attempts375 openIssue: (actor, repo, input) => call("open_issue", { actor, repo, ...input }),
Thirteen MCP tools and classic token scopes; agents rate their confidence and can be put on an issue in one step376 delegateIssue: (actor, repo, input) => call("delegate_issue", { actor, repo, ...input }),
Issues and pull requests replace intents and attempts377 listIssues: (repo, viewer, filter = {}) => call("list_issues", { repo, viewer, ...filter }),
378 getIssue: (repo, number, viewer) => call("get_issue", { repo, number, viewer }),
379 updateIssue: (actor, repo, number, input) =>
380 call("update_issue", { actor, repo, number, ...input }),
381 closeIssue: (actor, repo, number, reason) =>
382 call("close_issue", { actor, repo, number, reason }),
383 reopenIssue: (actor, repo, number) => call("reopen_issue", { actor, repo, number }),
384 listLabels: (repo, viewer) => call("list_labels", { repo, viewer }),
Teams and CODEOWNERS, labels and milestones, dependency updates, the security suite, and a clearer top bar385 saveLabel: (actor, repo, label) => call("save_label", { actor, repo, ...label }),
386 deleteLabel: (actor, repo, name) => call("delete_label", { actor, repo, name }),
387 addDefaultLabels: (actor, repo) => call("add_default_labels", { actor, repo }),
388 setLabels: (actor, repo, number, labels, change = "set") =>
389 call("set_labels", { actor, repo, number, labels, change }),
390 listMilestones: (repo, viewer, state) => call("list_milestones", { repo, viewer, state }),
391 getMilestone: (repo, number, viewer) => call("get_milestone", { repo, number, viewer }),
392 saveMilestone: (actor, repo, milestone) => call("save_milestone", { actor, repo, ...milestone }),
393 deleteMilestone: (actor, repo, number) => call("delete_milestone", { actor, repo, number }),
Issues and pull requests replace intents and attempts394 counts: (repo, viewer) => call("counts", { repo, viewer }),
Acceptance checks in sandboxes, line comments and review verdicts395 addComment: (actor, repo, number, comment) =>
396 call("add_comment", { actor, repo, number, ...comment }),
397 startChecks: (pullId) => call("start_checks", { pullId }),
398 reportChecks: (runId, token, report) =>
399 call("report_checks", { runId, token, ...report }),
Agents as a team: lifecycle, merge queue, billing and a new shell400 startReview: (pullId) => call("start_review", { pullId }),
401 failReview: (runId, token, error) => call("report_review", { runId, token, error }),
Agents and memory, checks and conflicts, profiles, slug renames, custom domains402 startMergecheck: (pullId) => call("start_mergecheck", { pullId }),
403 failMergecheck: (pullId, token, error) => call("report_mergecheck", { pullId, token, error }),
Agents as a team: lifecycle, merge queue, billing and a new shell404 advance: (pullId) => call("advance", { pullId }),
405 stall: (pullId, reason) => call("stall", { pullId, reason }),
406 managedPulls: (repoId) => call("managed_pulls", { repoId }),
407 queue: (repo, viewer) => call("queue", { repo, viewer }),
408 queueBuild: (repoId) => call("queue_build", { repoId }),
409 failQueue: (entryId, token, error) => call("report_queue", { entryId, token, error }),
410 removeFromQueue: (actor, repo, number) => call("remove_from_queue", { actor, repo, number }),
Usage, like a hosting provider's: what agents cost, per day, task, repository and pull request411 messageAgent: (actor, repo, number, body) => call("message_agent", { actor, repo, number, body }),
Agents as a team: lifecycle, merge queue, billing and a new shell412 catchUpJob: (pullId) => call("catch_up_job", { pullId }),
Agents asked while not at work are woken to answer413 wakeForMessages: (pullId) => call("wake_for_messages", { pullId }),
Agents as a team: lifecycle, merge queue, billing and a new shell414 getSettings: (repo, viewer) => call("get_settings", { repo, viewer }),
Merge rulesets: branch and tag rules, agent-first, enforced on push and merge415 // Rulesets travel in snake_case (rules.ts).
416 listRulesets: (owner, viewer, includeParents = false) =>
417 call("list_rulesets", { viewer, ...owner, include_parents: includeParents }),
418 getRuleset: (owner, id, viewer) => call("get_ruleset", { viewer, ...owner, id }),
419 saveRuleset: (actor, owner, ruleset, id) => call("save_ruleset", { actor, ...owner, id: id ?? null, ruleset }),
420 deleteRuleset: (actor, owner, id) => call("delete_ruleset", { actor, ...owner, id }),
421 effectiveRules: (repo, name, viewer, target = "branch") => call("effective_rules", { viewer, repo, name, target }),
422 ruleEvaluations: (owner, viewer, filter = {}) => call("rule_evaluations", { viewer, ...owner, ...filter }),
Fast pages, required checks on the branch, self-hosted runners, honest incidents423 seenChecks: (repo, viewer) => call("seen_checks", { repo, viewer }),
Merge checks: statuses and check runs on every commit424 commitChecks: (repo, viewer, shas) => call("commit_checks", { repo, viewer, shas }),
425 getCheckRun: (repo, id, viewer) => call("get_check_run", { repo, id, viewer }),
426 checkRunAnnotations: (repo, id, viewer) => call("check_run_annotations", { repo, id, viewer }),
427 requestCheckAction: (actor, repo, id, identifier) => call("request_check_action", { actor, repo, id, identifier }),
428 rerequestCheckRun: (actor, repo, id) => call("rerequest_check_run", { actor, repo, id }),
Teams and CODEOWNERS, labels and milestones, dependency updates, the security suite, and a clearer top bar429 codeownersErrors: (repo, viewer, ref) => call("codeowners_errors", { repo, viewer, ref: ref ?? null }),
Agents as a team: lifecycle, merge queue, billing and a new shell430 updateSettings: (actor, repo, settings) =>
431 call("update_settings", { actor, repo, settings }),
Issues and pull requests replace intents and attempts432 openPull: (actor, repo, input) => call("open_pull", { actor, repo, ...input }),
Teams and CODEOWNERS, labels and milestones, dependency updates, the security suite, and a clearer top bar433 listPulls: (repo, viewer, state, filter = {}) => call("list_pulls", { repo, viewer, state, ...filter }),
Fast pages, required checks on the branch, self-hosted runners, honest incidents434 pullsForRepos: (repoIds, viewer, limit) => call("pulls_for_repos", { repoIds, viewer, limit }),
Teams and CODEOWNERS, labels and milestones, dependency updates, the security suite, and a clearer top bar435 // Its own fields arrive in snake_case: read into camelCase here.
436 getPull: (repo, number, viewer) =>
437 call<Result<Record<string, unknown>>>("get_pull", { repo, number, viewer }).then(
438 (found): Result<PullDetail> => (found.ok ? { ok: true, value: pullDetailFromWire(found.value) } : found),
439 ),
Agents as a team: lifecycle, merge queue, billing and a new shell440 updatePull: (actor, repo, number, changes) =>
441 call("update_pull", { actor, repo, number, ...changes }),
Catching up with main takes seconds when the two sides touched different files442 catchUpPull: (actor, repo, number) => call("catch_up_pull", { actor, repo, number }),
Issues and pull requests replace intents and attempts443 readyPull: (actor, repo, number, summary) =>
444 call("ready_pull", { actor, repo, number, summary }),
445 closePull: (actor, repo, number) => call("close_pull", { actor, repo, number }),
Acceptance checks in sandboxes, line comments and review verdicts446 mergePull: (actor, repo, number, options = {}) =>
447 call("merge_pull", { actor, repo, number, ...options }),
Issues and pull requests replace intents and attempts448 listActivePulls: (viewer) => call("list_active_pulls", { viewer }),
Agents and memory, checks and conflicts, profiles, slug renames, custom domains449 byAuthor: (username, viewer, filter = {}) => call("by_author", { username, viewer, ...filter }),
Agents as a team: lifecycle, merge queue, billing and a new shell450 startPlan: (actor, repo, brief) => call("start_plan", { actor, repo, brief }),
451 failPlan: (planId, token, error) => call("report_plan", { planId, token, error }),
452 getPlan: (repo, viewer, id) => call("get_plan", { repo, viewer, id }),
453 listPlans: (repo, viewer) => call("list_plans", { repo, viewer }),
454 applyPlan: (actor, repo, id, options = {}) =>
455 call("apply_plan", { actor, repo, id, ...options }),
456 queueIssue: (actor, repo, number, queued) =>
457 call("queue_issue", { actor, repo, number, queued }),
458 readyIssues: (repoId) => call("ready_issues", { repoId }),
459 listAssignedIssues: (viewer) => call("list_assigned_issues", { viewer }),
Issues and pull requests replace intents and attempts460 appendSession: (actor, repo, number, entries) =>
461 call("append_session", { actor, repo, number, entries }),
462 readSession: (repo, number, viewer, afterSeq = 0) =>
463 call("read_session", { repo, number, viewer, afterSeq }),
Work service in Rust, with RFC 3339 timestamps464 };
465}
Events service in Rust, with RFC 3339 times and accurate push events466
Agents as a team: lifecycle, merge queue, billing and a new shell467export function billingClient(service: ServiceBinding): BillingApi {
468 const call = <T>(method: string, args: object) => rpc<T>(service, method, args);
469 return {
470 status: () => call("status", {}),
471 account: (workspace, viewer) => call("account", { workspace, viewer }),
472 ledger: (workspace, viewer) => call("ledger", { workspace, viewer }),
Billing: credits with a kind and expiry, discounts instead of comped, and safer charging473 credits: (workspace, viewer) => call("credits", { workspace, viewer }),
The statement is a month at a time, a line per kind of charge474 statement: (workspace, viewer, month = null, group = "day") => call("statement", { workspace, viewer, month, group }),
475 statementEntries: (workspace, viewer, filter) =>
476 call("statement_entries", {
477 workspace,
478 viewer,
479 month: filter.month,
480 kind: filter.kind,
481 day: filter.day ?? null,
482 project: filter.project ?? null,
483 before: filter.before ?? null,
484 }),
Usage, like a hosting provider's: what agents cost, per day, task, repository and pull request485 usage: (workspace, viewer, since) => call("usage", { workspace, viewer, since }),
Mission control shows model usage, yours and the workspace's: tokens, cost, active days, cache share, each day, and the mix486 tokenUsage: (workspace, viewer, options = {}) =>
487 call("token_usage", { workspace, viewer, person: options.person ?? null, days: options.days ?? null }),
488 recordTokens: (usage) => call("record_tokens", usage),
Merge the AI Gateway: Anthropic's Messages API on a workspace's tokens489 gatewayModels: () => call("gateway_models", {}),
Models: g1t keeps up with new models, and staff choose each default in sudo490 modelDefaults: () => call("model_defaults", {}),
491 recordDiscovery: (provider, models, by, error = null) => call("record_discovery", { provider, models, by, error }),
Merge the AI Gateway: Anthropic's Messages API on a workspace's tokens492 gatewayAdmit: (workspace) => call("gateway_admit", { workspace }),
493 recordGateway: (record) => call("record_gateway", record),
494 gatewayRequests: (workspace, viewer, options = {}) =>
495 call("gateway_requests", { workspace, viewer, limit: options.limit ?? null, before: options.before ?? null }),
Invite-only launch: sign in with GitHub, repository access and lifecycle, many emails, a new look496 checkout: (actor, workspace, amountCents, returnUrl, method = "card") =>
497 call("checkout", { actor, workspace, amountCents, returnUrl, method }),
Agents as a team: lifecycle, merge queue, billing and a new shell498 confirm: (workspace, viewer, session) => call("confirm", { workspace, viewer, session }),
499 canStart: (workspace) => call("can_start", { workspace }),
A free allowance on g1t's models, so anyone can try its agents500 trial: (workspace, exempt) => call("trial", { workspace, exempt }),
Agents as a team: lifecycle, merge queue, billing and a new shell501 startRun: (run) => call("start_run", run),
Paid features: a workspace turns on Deployments with a monthly plan502 features: (workspace, viewer) => call("features", { workspace, viewer }),
503 subscribe: (actor, workspace, feature, returnUrl) =>
504 call("subscribe", { actor, workspace, feature, returnUrl }),
505 confirmSubscription: (workspace, viewer, session) =>
506 call("confirm_subscription", { workspace, viewer, session }),
507 cancelSubscription: (actor, workspace, feature, resume = false) =>
508 call("cancel_subscription", { actor, workspace, feature, resume }),
509 hasFeature: (workspace, feature) => call("has_feature", { workspace, feature }),
Merge Stripe Tax, the card fee on card payments, and one free workspace per person510 freeWorkspaces: (workspaces) => call("free_workspaces", { workspaces }),
Paid features: a workspace turns on Deployments with a monthly plan511 chargeFeature: (charge) => call("charge_feature", charge),
Billing on Stripe's pages, month-end charges, warnings; sudo by workspace512 billingPortal: (actor, workspace, returnUrl) => call("billing_portal", { actor, workspace, return_url: returnUrl }),
Every sandbox is metered by the second513 recordSandbox: (usage) => call("record_sandbox", usage),
Usage limits: unpaid usage can only go so far514 limit: (workspace, viewer) => call("limit", { workspace, viewer }),
515 checkLimit: (workspace) => call("check_limit", { workspace }),
Prices keep themselves current with what g1t pays516 prices: () => call("prices", {}),
status.g1t.sh with incident management, invites that land you in the workspace, settings as pages, usage without quotas517 notePending: (workspace, source, costMicros, detail = null) => call("note_pending", { workspace, source, costMicros, detail }),
518 usageMeters: (workspace, viewer) => call("usage_meters", { workspace, viewer }),
Invite-only launch: sign in with GitHub, repository access and lifecycle, many emails, a new look519 setSpendLimit: (actor, workspace, spendLimitMicros, useFullLimit = false, raiseOnce = false) =>
520 call("set_spend_limit", { actor, workspace, spendLimitMicros, use_full_limit: useFullLimit, raise_once: raiseOnce }),
Two limits, real invoices, trust that grows by itself, sales signals521 invoices: (workspace, viewer) => call("invoices", { workspace, viewer }),
Team plan, an open-source pool, monthly trials and honest metering; the sidebar for everyone; a workspace that stays put522 entitlements: (workspace) => call("entitlements", { workspace }),
Invite-only launch: sign in with GitHub, repository access and lifecycle, many emails, a new look523 reserve: (reservation) => call("reserve", reservation),
524 settle: (reservationId, actualMicros) => call("settle", { reservationId, actualMicros }),
525 cardCheck: (actor, workspace, returnUrl) => call("card_check", { actor, workspace, returnUrl }),
526 confirmCardCheck: (workspace, viewer, session) => call("confirm_card_check", { workspace, viewer, session }),
527 requestLimit: (actor, workspace, request) => call("request_limit", { actor, workspace, ...request }),
528 limitRequests: (workspace, viewer) => call("limit_requests", { workspace, viewer }),
529 confirmSpike: (actor, workspace, keepGoing) => call("confirm_spike", { actor, workspace, keepGoing }),
530 setCaps: (actor, workspace, caps) => call("set_caps", { actor, workspace, ...caps }),
Usage, Billing settings and prepaid AI credit; fixes from the UX audit531 usageReport: (workspace, viewer, range) =>
532 call("usage_report", { workspace, viewer, from: range.from, until: range.until, products: range.products ?? [], projects: range.projects ?? [] }),
533 aiCredit: (workspace, viewer) => call("ai_credit", { workspace, viewer }),
534 buyAiCredit: (actor, workspace, amountCents, returnUrl) => call("buy_ai_credit", { actor, workspace, amountCents, returnUrl }),
535 confirmAiCredit: (workspace, viewer, session) => call("confirm_ai_credit", { workspace, viewer, session }),
536 setAiReload: (actor, workspace, reload) => call("set_ai_reload", { actor, workspace, ...reload }),
537 setBudget: (actor, workspace, budget) => call("set_budget", { actor, workspace, ...budget }),
538 billingDetails: (workspace, viewer) => call("billing_details", { workspace, viewer }),
539 setBillingDetails: (actor, workspace, details) => call("set_billing_details", { actor, workspace, ...details }),
Agents as a team: lifecycle, merge queue, billing and a new shell540 };
541}
542
Billing accounts, terms and enterprises; g1t is no longer free543export function billingAdminClient(service: ServiceBinding): BillingAdminApi {
544 const call = <T>(method: string, args: object) => rpc<T>(service, method, args);
545 return {
546 accounts: (query) => call("admin_accounts", { query: query ?? null }),
547 account: (id) => call("admin_account", { id }),
548 setTerms: (id, terms, by) => call("admin_set_terms", { id, terms, by }),
Team plan, an open-source pool, monthly trials and honest metering; the sidebar for everyone; a workspace that stays put549 setAllowances: (id, allowances, note, by) => call("admin_set_allowances", { id, allowances, note, by }),
Billing accounts, terms and enterprises; g1t is no longer free550 createEnterprise: (name, workspaces, by) => call("admin_create_enterprise", { name, workspaces, by }),
551 attach: (workspace, account, by) => call("admin_attach", { workspace, account, by }),
Billing: credits with a kind and expiry, discounts instead of comped, and safer charging552 credit: (workspace, amountMicros, note, by, options = { kind: "goodwill" }) =>
553 call("admin_credit", {
554 workspace,
555 amount_micros: amountMicros,
556 note,
557 by,
558 kind: options.kind,
559 expires_at: options.expiresAt ?? null,
560 refund_for: options.refundFor ?? null,
561 refund_day: options.refundDay ?? null,
562 }),
563 credits: (filter = {}) =>
564 call("admin_credits", {
565 workspace: filter.workspace ?? null,
566 kind: filter.kind ?? null,
567 month: filter.month ?? null,
568 by: filter.by ?? null,
569 }),
570 revokeCredit: (id, note, by) => call("admin_revoke_credit", { id, note, by }),
sudo: reset a test workspace's billing so it starts again as a new customer; refused on a live Stripe key, for comped workspaces and for an enterprise's571 resetBilling: (workspace, confirm, note, by) => call("admin_reset_billing", { workspace, confirm, note, by }),
Billing on Stripe's pages, month-end charges, warnings; sudo by workspace572 billingLink: (workspace, by) => call("admin_billing_link", { workspace, by }),
Stripe's webhook secret is a Worker secret, STRIPE_WEBHOOK_SECRET, from a destination made in Stripe's dashboard573 stripe: (fix = false, by) => call("admin_stripe", { fix, by: by ?? null }),
Stripe webhooks, enterprise invoices, and sudo for both574 enterpriseBilling: (id, email, by) => call("admin_enterprise_billing", { id, email, by }),
Merge Stripe Tax, the card fee on card payments, and one free workspace per person575 enterpriseAddress: (id, address, taxIdType, taxId, by) => call("admin_enterprise_address", { id, address, taxIdType, taxId, by }),
Stripe webhooks, enterprise invoices, and sudo for both576 invoiceEnterprise: (id, by) => call("admin_invoice_enterprise", { id, by }),
577 accountsFor: (workspaces) => call("admin_accounts", { query: null, workspaces }),
Two limits, real invoices, trust that grows by itself, sales signals578 signals: () => call("admin_signals", {}),
579 overview: () => call("admin_overview", {}),
580 sales: (workspace) => call("admin_sales", { workspace }),
581 setSales: (workspace, record, by) =>
582 call("admin_set_sales", {
583 workspace,
584 stage: record.stage,
585 owner: record.owner ?? null,
586 next_step: record.nextStep ?? null,
587 next_at: record.nextAt ?? null,
588 by,
589 }),
590 addNote: (workspace, text, by) => call("admin_add_note", { workspace, text, by }),
591 workspaceInvoices: (workspace) => call("admin_workspace_invoices", { workspace }),
Billing lists every invoice and every staff change; signals carry follow-ups592 allInvoices: (filter = {}) => call("admin_invoices", { status: filter.status ?? null, month: filter.month ?? null }),
593 audit: (filter = {}) =>
594 call("admin_audit", { by: filter.by ?? null, action: filter.action ?? null, before: filter.before ?? null }),
Invite-only launch: sign in with GitHub, repository access and lifecycle, many emails, a new look595 limitRequests: (status = "open") => call("admin_limit_requests", { status }),
596 decideLimitRequest: (id, decision, amountMicros, note, by) =>
597 call("admin_decide_limit_request", { id, decision, amount_micros: amountMicros, note, by }),
598 overages: () => call("admin_overages", {}),
599 goodwill: (workspace, amountMicros, reason, by, day = null) =>
600 call("admin_goodwill", { workspace, amount_micros: amountMicros, reason, by, day }),
601 velocity: () => call("admin_velocity", {}),
602 recordPayment: (workspace, amountMicros, reference, note, by) =>
603 call("admin_record_payment", { workspace, amount_micros: amountMicros, reference, note, by }),
Git storage hardened, pages in tens of milliseconds, honest security alerts, and costs reconciled daily604 costs: (days) => call("admin_costs", { days: days ?? null }),
605 costAlerts: () => call("admin_cost_alerts", {}),
Spend caps: a monthly budget for comped workspaces and a daily breaker on what g1t pays606 spendCaps: () => call("admin_spend_caps", {}),
607 liftBreaker: (note, by) => call("admin_lift_breaker", { note, by }),
Git storage hardened, pages in tens of milliseconds, honest security alerts, and costs reconciled daily608 decideProposal: (id, decision, note, by) => call("admin_decide_proposal", { id, decision, note, by }),
609 setCostSettings: (settings, by) => call("admin_set_cost_settings", { settings, by }),
610 setCostMapping: (mapping, by) =>
611 call("admin_set_cost_mapping", {
612 product: mapping.product,
613 meter: mapping.meter,
614 bucket: mapping.bucket ?? "",
615 price_meter: mapping.priceMeter ?? null,
616 own_meter: mapping.ownMeter ?? null,
617 scale_to_own: mapping.scaleToOwn ?? false,
618 drift_percent: mapping.driftPercent ?? null,
619 note: mapping.note ?? "",
620 remove: mapping.remove ?? false,
621 by,
622 }),
623 runCosts: (by) => call("admin_run_costs", { by }),
Models: g1t keeps up with new models, and staff choose each default in sudo624 models: () => call("admin_models", {}),
625 decideModel: (model, decision, details, reason, by) =>
626 call("admin_decide_model", {
627 model,
628 decision,
629 name: details.name ?? null,
630 tier_hint: details.tierHint ?? null,
631 prices: details.prices
632 ? {
633 input_micros: details.prices.inputMicros,
634 output_micros: details.prices.outputMicros,
635 cache_read_micros: details.prices.cacheReadMicros,
636 cache_write_micros: details.prices.cacheWriteMicros,
637 cache_write_1h_micros: details.prices.cacheWrite1hMicros,
638 threshold: details.prices.threshold,
639 over_input_micros: details.prices.overInputMicros,
640 over_output_micros: details.prices.overOutputMicros,
641 over_cache_read_micros: details.prices.overCacheReadMicros,
642 over_cache_write_micros: details.prices.overCacheWriteMicros,
643 over_cache_write_1h_micros: details.prices.overCacheWrite1hMicros,
644 }
645 : null,
646 reason,
647 by,
648 }),
649 setModelDefault: (purpose, value, reason, by) =>
650 call("admin_set_model_default", {
651 purpose,
652 model: value.model ?? null,
653 tier: value.tier ?? null,
654 effort: value.effort ?? null,
655 reason,
656 by,
657 }),
Billing accounts, terms and enterprises; g1t is no longer free658 };
659}
660
Events service in Rust, with RFC 3339 times and accurate push events661export function eventsClient(service: ServiceBinding): EventsApi {
662 const call = <T>(method: string, args: object) => rpc<T>(service, method, args);
663 return {
664 publish: (events) => call("publish", { events }),
665 list: (query) => call("list", query),
666 };
667}
Integrations: your own model provider, alerts that open issues, tickets agents read668
669export function integrationsClient(service: ServiceBinding): IntegrationsApi {
670 const call = <T>(method: string, args: object) => rpc<T>(service, method, args);
671 return {
672 list: (workspace, viewer) => call("list", { workspace, viewer }),
673 connect: (actor, workspace, input) => call("connect", { actor, workspace, ...input }),
674 update: (actor, workspace, id, input) => call("update", { actor, workspace, id, ...input }),
675 disconnect: (actor, workspace, id) => call("disconnect", { actor, workspace, id }),
676 test: (actor, workspace, id) => call("test", { actor, workspace, id }),
677 deliveries: (workspace, viewer, id) => call("deliveries", { workspace, viewer, id }),
678 resolve: (workspace, viewer, reference) => call("resolve", { workspace, viewer, reference }),
679 references: (workspace, text, limit) => call("references", { workspace, text, limit }),
680 import: (actor, repo, reference, assign) => call("import", { actor, repo, reference, assign }),
681 links: (repo, number) => call("links", { repo, number }),
682 modelProvider: (workspace) => call("model_provider", { workspace }),
683 openModelSession: (run) => call("open_model_session", run),
684 modelUpstream: (token) => call("model_upstream", { token }),
Merge the AI Gateway: Anthropic's Messages API on a workspace's tokens685 gatewayUpstream: (workspace) => call("gateway_upstream", { workspace }),
AI Gateway: OpenAI's format, open models, and your own providers686 gatewayProviders: (workspace) => call("gateway_providers", { workspace }),
Git storage hardened, pages in tens of milliseconds, honest security alerts, and costs reconciled daily687 closeModelSessions: (tokenHashes) => call("close_model_sessions", { token_hashes: tokenHashes }),
Models per workspace: several providers, routed by kind of work688 routes: (workspace, viewer) => call("routes", { workspace, viewer }),
689 setRoutes: (actor, workspace, routes) => call("set_routes", { actor, workspace, routes }),
Integrations: your own model provider, alerts that open issues, tickets agents read690 };
691}
Webhooks: every event, to your own addresses, signed and retried692
693export function webhooksClient(service: ServiceBinding): WebhooksApi {
694 const call = <T>(method: string, args: object) => rpc<T>(service, method, args);
695 return {
696 list: (viewer, owner) => call("list", { viewer, ...owner }),
697 create: (actor, owner, input) => call("create", { actor, ...owner, ...input }),
698 update: (actor, owner, id, input) => call("update", { actor, ...owner, id, ...input }),
699 delete: (actor, owner, id) => call("delete", { actor, ...owner, id }),
700 ping: (actor, owner, id) => call("ping", { actor, ...owner, id }),
701 deliveries: (viewer, owner, id) => call("deliveries", { viewer, ...owner, id }),
702 redeliver: (actor, owner, deliveryId) => call("redeliver", { actor, ...owner, deliveryId }),
703 };
704}
Automations: rules in .g1t/automations that act when something happens705
GitHub Actions on g1t, part three: .g1t/workflows, the pages, the docs706export function actionsClient(service: ServiceBinding): ActionsApi {
707 const call = <T>(method: string, args: object) => rpc<T>(service, method, args);
708 return {
709 workflows: (repo, viewer) => call("workflows", { repo, viewer }),
710 runs: (repo, viewer, filter = {}) => call("runs", { repo, viewer, ...filter }),
711 run: (repo, viewer, id) => call("run", { repo, viewer, id }),
712 logs: (repo, viewer, job, after = 0) => call("logs", { repo, viewer, job, after }),
713 dispatch: (actor, repo, workflow, ref, inputs) => call("dispatch", { actor, repo, workflow, ref, inputs }),
714 cancel: (actor, repo, id) => call("cancel", { actor, repo, id }),
715 rerun: (actor, repo, id, failedOnly = false) => call("rerun", { actor, repo, id, failed_only: failedOnly }),
716 setWorkflowEnabled: (actor, repo, workflow, enabled) =>
717 call("set_workflow_enabled", { actor, repo, workflow, enabled }),
718 settings: (actor, owner, kind) => call("settings", { actor, ...owner, kind }),
Secrets and variables: one list, rows per environment, for workflows and deployments719 setSetting: (actor, owner, kind, name, value, options = {}) =>
720 call("set_setting", { actor, ...owner, kind, name, value, ...options }),
721 deleteSetting: (actor, owner, kind, name, id) => call("delete_setting", { actor, ...owner, kind, name, id }),
GitHub Actions on g1t, part three: .g1t/workflows, the pages, the docs722 };
723}
724
Deployments: a preview for every pull request, production on g1t.page725
Fast pages, required checks on the branch, self-hosted runners, honest incidents726/** Self-hosted runners, kept by the actions service. */
727export function runnersClient(service: ServiceBinding): RunnersApi {
728 const call = <T>(method: string, args: object) => rpc<T>(service, method, args);
729 return {
730 stuck: (viewer) => call("stuck_jobs", { viewer }),
731 list: (actor, owner) => call("runners", { actor, ...owner }),
732 createToken: (actor, owner, group) => call("create_registration_token", { actor, ...owner, group }),
733 remove: (actor, owner, id) => call("remove_runner", { actor, ...owner, id }),
734 groups: (actor, workspace) => call("runner_groups", { actor, workspace }),
735 setGroup: (actor, workspace, group) => call("set_runner_group", { actor, workspace, ...group }),
736 deleteGroup: (actor, workspace, id) => call("delete_runner_group", { actor, workspace, id }),
737 settings: (actor, owner) => call("runner_settings", { actor, ...owner }),
738 setSettings: (actor, owner, change) => call("set_runner_settings", { actor, ...owner, ...change }),
739 };
740}
741
Deployments: a preview for every pull request, production on g1t.page742export function deploymentsClient(service: ServiceBinding): DeploymentsApi {
743 const call = <T>(method: string, args: object) => rpc<T>(service, method, args);
744 return {
Projects: what a workspace builds and runs, first on every page745 settings: (project, viewer) => call("settings", { project, viewer }),
746 updateSettings: (actor, project, changes) => call("update_settings", { actor, project, changes }),
747 list: (project, viewer) => call("list", { project, viewer }),
748 get: (project, id, viewer) => call("get", { project, id, viewer }),
749 redeploy: (actor, project, branch) => call("redeploy", { actor, project, branch }),
750 takeDown: (actor, project, branch) => call("take_down", { actor, project, branch }),
Project dependencies: addresses, preview stacks, Affects, and agents who know751 stack: (actor, project, branch) => call("stack", { actor, project, branch }),
Projects: what a workspace builds and runs, first on every page752 overview: (workspace, viewer) => call("overview", { workspace, viewer }),
Deployments: a preview for every pull request, production on g1t.page753 usage: (workspace, viewer) => call("usage", { workspace, viewer }),
Agents and memory, checks and conflicts, profiles, slug renames, custom domains754 domains: (project, viewer) => call("domains", { project, viewer }),
755 addDomain: (actor, project, hostname, options = {}) =>
756 call("add_domain", { actor, project, hostname, twin: !!options.twin }),
757 removeDomain: (actor, project, id) => call("remove_domain", { actor, project, id }),
758 refreshDomain: (actor, project, id) => call("refresh_domain", { actor, project, id }),
Merge branch 'main' into worktree-agent-a69aeabc4b0deeb97759 repoDeployments: (repo, viewer, filter = {}) => call("list_deployments", { repo, viewer, ...filter }),
760 repoDeployment: (repo, id, viewer) => call("get_deployment", { repo, id, viewer }),
761 environments: (repo, viewer) => call("list_environments", { repo, viewer }),
762 createDeployment: (actor, repo, input) => call("create_deployment", { repo, actor, ...input }),
763 createDeploymentStatus: (actor, repo, id, input) => call("create_deployment_status", { repo, actor, id, ...input }),
Deployments: a preview for every pull request, production on g1t.page764 };
765}
Projects: what a workspace builds and runs, first on every page766
Packages, with a container registry on g1t.sh; workspaces deleted whole and kept 30 days; Members for every member767/** Packages: the registries beside the code (services/packages). */
768export function packagesClient(service: ServiceBinding): PackagesApi {
769 const call = <T>(method: string, args: object) => rpc<T>(service, method, args);
770 return {
771 list: (workspace, viewer, filter = {}) =>
772 call("list_packages", {
773 workspace,
774 viewer,
775 ecosystem: filter.ecosystem ?? null,
776 repo_id: filter.repoId ?? null,
777 query: filter.query ?? null,
778 }),
779 get: (workspace, ecosystem, name, viewer) => call("get_package", { workspace, ecosystem, name, viewer }),
780 deleteVersion: (actor, workspace, ecosystem, name, version, surface) =>
781 call("delete_version", { actor, workspace, ecosystem, name, version, surface: surface ?? null }),
782 deletePackage: (actor, workspace, ecosystem, name, surface) =>
783 call("delete_package", { actor, workspace, ecosystem, name, surface: surface ?? null }),
784 set: (actor, workspace, ecosystem, name, change, surface) =>
785 call("set_package", {
786 actor,
787 workspace,
788 ecosystem,
789 name,
790 visibility: change.visibility ?? null,
791 link: change.link ?? null,
792 unlink: change.unlink ?? false,
793 surface: surface ?? null,
794 }),
795 storage: (workspace) => call("storage", { workspace }),
796 storageAll: () => call("storage_all", {}),
Composer from the workspace's own repositories, and go get from g1t.sh797 syncComposer: (repoId) => call("sync_composer", { repo_id: repoId }),
Packages, with a container registry on g1t.sh; workspaces deleted whole and kept 30 days; Members for every member798 };
799}
800
Projects: what a workspace builds and runs, first on every page801export function projectsClient(service: ServiceBinding): ProjectsApi {
802 const call = <T>(method: string, args: object) => rpc<T>(service, method, args);
803 return {
804 list: (workspace, viewer) => call("list", { workspace, viewer }),
805 get: (workspace, slug, viewer) => call("get", { workspace, slug, viewer }),
806 byRepo: (repoId) => call("by_repo", { repoId }),
807 create: (actor, workspace, input) => call("create", { actor, workspace, input }),
808 update: (actor, workspace, slug, changes) => call("update", { actor, workspace, slug, changes }),
A project is an app or a library: libraries show their package and how to ship a release, not production809 deploymentsChanged: (projectId, enabled) => call("deployments_changed", { projectId, enabled }),
Project dependencies: addresses, preview stacks, Affects, and agents who know810 dependencies: (workspace, slug, viewer) => call("dependencies", { workspace, slug, viewer }),
811 addDependency: (actor, workspace, slug, on, as) => call("add_dependency", { actor, workspace, slug, on, as }),
812 removeDependency: (actor, workspace, slug, on) => call("remove_dependency", { actor, workspace, slug, on }),
813 graph: (projectId) => call("graph", { projectId }),
Projects: pinned and recent projects, per person per workspace814 shortcuts: (workspace, viewer) => call("shortcuts", { workspace, viewer }),
815 pin: (actor, workspace, slug, position) => call("pin", { actor, workspace, slug, position: position ?? null }),
816 unpin: (actor, workspace, slug) => call("unpin", { actor, workspace, slug }),
817 reorderPins: (actor, workspace, slugs) => call("reorder_pins", { actor, workspace, slugs }),
818 visited: (actor, projectId) => call("visited", { actor, projectId }),
Merge branch 'main' into worktree-agent-a69aeabc4b0deeb97819 publicLinks: (repos) => call("public_links", { repos }),
Projects: what a workspace builds and runs, first on every page820 };
821}

This file's history is long; its oldest lines are credited to the oldest commit read.