Skip to content
Sign in

flagon-io/g1t

public
0

g1t/apps/api/src/tools.rs

961 lines58,794 bytesCodeBlame
1//! The MCP server's tools: a few resource tools, each with an `action`.
2//!
3//! Every operation is one action of one tool. A call is dispatched to the
4//! operation it names, so permissions, the audit log, billing and outcomes
5//! are exactly those of the REST API. A token sees only the actions its
6//! scopes allow, and a tool none of whose actions it may use is not listed.
7//!
8//! The listed input schema is one flat object: `action`, then every field
9//! any of its actions takes. Which fields each action needs is in the
10//! `action` field's description and checked on every call. Claude's API,
11//! and so most MCP clients, refuse a tool whose input schema has `oneOf`
12//! at its top level, so the schema keyed by action, with each action's
13//! required fields, is [`discriminated`], published on the server's card
14//! and in the docs.
15
16use g1t_contracts::credentials::NEVER;
17use g1t_contracts::identity::AgentScope;
18use g1t_contracts::scopes::{Level, NO_SCOPE, TokenAccess, scope_for};
19use serde_json::{Map, Value, json};
20
21use crate::about::AboutOp;
22use crate::artifacts::ArtifactsOp;
23use crate::deployments::DeploymentsOp;
24use crate::protection::ProtectionOp;
25use crate::operations::Op;
26use crate::checks::ChecksOp;
27use crate::rules::RulesOp;
28use crate::security::SecurityOp;
29
30pub struct Action {
31 pub name: &'static str,
32 pub op: Op,
33 /// One line, for the `action` field's description.
34 pub summary: &'static str,
35}
36
37pub struct Tool {
38 pub name: &'static str,
39 pub title: &'static str,
40 /// What it is for, in a sentence or two.
41 pub description: &'static str,
42 pub actions: &'static [Action],
43 /// The action a call without one runs.
44 pub default_action: Option<&'static str>,
45}
46
47const fn a(name: &'static str, op: Op, summary: &'static str) -> Action {
48 Action { name, op, summary }
49}
50
51pub const TOOLS: &[Tool] = &[
52 Tool {
53 name: "search",
54 title: "Search",
55 description: "Find things. `code` (the default) searches all of g1t you can see: repositories, code, issues, pull requests and people, with qualifiers like repo:owner/name, language:rust, is:issue. `context` searches one workspace's catalog, docs, issues and memory by meaning.",
56 default_action: Some("code"),
57 actions: &[
58 a("code", Op::Search, "Search all of g1t: repositories, code, issues, pull requests, people"),
59 a("context", Op::SearchContext, "Search a workspace's context hub by meaning"),
60 a("entity", Op::GetEntity, "One catalog entry and its relations"),
61 a("ticket", Op::GetContext, "A Jira, Linear or Sentry item the work refers to, as it is now"),
62 ],
63 },
64 Tool {
65 name: "repository",
66 title: "Repositories",
67 description: "Repositories: find, read and create them, change their settings and rulesets (what may happen to branches and tags, and what a pull request needs to merge), check their CODEOWNERS file, manage their labels and milestones, see and dismiss their security alerts (secrets and vulnerable dependencies), read what their default branch says (languages, contributors, license), star them, and publish releases. Name one as \"owner/name\". Deleting, transferring and changing visibility need `confirm`.",
68 default_action: None,
69 actions: &[
70 a("list", Op::ListRepos, "Repositories you can see"),
71 a("get", Op::GetRepo, "One repository"),
72 a("create", Op::CreateRepo, "Create one, empty or copied from a public git URL"),
73 a("update", Op::UpdateRepo, "Change description, website, topics, default branch, protection"),
74 a("get_settings", Op::GetRepoSettings, "How pull requests merge, and the default branch's protection as its rules stack"),
75 a("update_settings", Op::UpdateRepoSettings, "Change how pull requests merge and the default branch protection ruleset"),
76 a("check_names", Op::ListCheckNames, "Check names reported lately, to require in a ruleset"),
77 a("list_rulesets", Op::Rules(RulesOp::ListRepoRulesets), "Its rulesets, and its workspace's that hold in it"),
78 a("get_ruleset", Op::Rules(RulesOp::GetRepoRuleset), "One ruleset"),
79 a("create_ruleset", Op::Rules(RulesOp::CreateRepoRuleset), "Create a ruleset for its branches or tags"),
80 a("update_ruleset", Op::Rules(RulesOp::UpdateRepoRuleset), "Change a ruleset"),
81 a("delete_ruleset", Op::Rules(RulesOp::DeleteRepoRuleset), "Delete a ruleset"),
82 a("branch_rules", Op::Rules(RulesOp::GetBranchRules), "Every rule that holds for a branch or tag, and where it comes from"),
83 a("rule_evaluations", Op::Rules(RulesOp::ListRuleEvaluations), "How its rules judged pushes and merges, with insights"),
84 a("codeowners", Op::GetCodeownersErrors, "Problems in its CODEOWNERS file, by line"),
85 a("list_labels", Op::ListLabels, "Labels, with colors and how many issues and pull requests carry each"),
86 a("create_label", Op::CreateLabel, "Create a label"),
87 a("update_label", Op::UpdateLabel, "Rename a label or change its color or description"),
88 a("delete_label", Op::DeleteLabel, "Delete a label, from everything that carries it"),
89 a("add_default_labels", Op::AddDefaultLabels, "Add the default labels it is missing"),
90 a("list_milestones", Op::ListMilestones, "Milestones, with progress and due dates"),
91 a("get_milestone", Op::GetMilestone, "One milestone with its issues and pull requests"),
92 a("create_milestone", Op::CreateMilestone, "Create a milestone"),
93 a("update_milestone", Op::UpdateMilestone, "Change a milestone's title, description, due date or state"),
94 a("delete_milestone", Op::DeleteMilestone, "Delete a milestone"),
95 a("list_events", Op::ListEvents, "Timeline: pushes, issues, pull requests, comments"),
96 a("languages", Op::About(AboutOp::GetLanguages), "Its languages by bytes, with colors and percentages"),
97 a("contributors", Op::About(AboutOp::ListContributors), "Who made it: commits per person, agent and author, by week"),
98 a("license", Op::About(AboutOp::GetLicense), "The license its LICENSE file holds"),
99 a("stargazers", Op::About(AboutOp::ListStargazers), "Who starred it"),
100 a("starred", Op::About(AboutOp::CheckStarred), "Whether you starred it, and how many have"),
101 a("star", Op::About(AboutOp::Star), "Star it"),
102 a("unstar", Op::About(AboutOp::Unstar), "Take your star back"),
103 a("list_starred", Op::About(AboutOp::ListStarred), "Repositories you starred"),
104 a("list_releases", Op::About(AboutOp::ListReleases), "Releases, newest first"),
105 a("latest_release", Op::About(AboutOp::GetLatestRelease), "The latest release"),
106 a("get_release", Op::About(AboutOp::GetRelease), "One release by id"),
107 a("get_release_by_tag", Op::About(AboutOp::GetReleaseByTag), "The release of a tag"),
108 a("create_release", Op::About(AboutOp::CreateRelease), "Publish a release of a tag, making the tag if needed"),
109 a("update_release", Op::About(AboutOp::UpdateRelease), "Change a release's title, notes, draft or prerelease"),
110 a("delete_release", Op::About(AboutOp::DeleteRelease), "Delete a release; its tag stays"),
111 a("rename_branch", Op::RenameBranch, "Rename a branch"),
112 a("rename", Op::RenameRepo, "Rename it; old addresses redirect"),
113 a("transfer", Op::TransferRepo, "Move it to another workspace you own"),
114 a("archive", Op::ArchiveRepo, "Make it read-only"),
115 a("unarchive", Op::UnarchiveRepo, "Make it writable again"),
116 a("set_visibility", Op::SetRepoVisibility, "Make it public or private"),
117 a("delete", Op::DeleteRepo, "Delete it; restorable for 30 days"),
118 a("list_deleted", Op::ListDeletedRepos, "A workspace's deleted repositories"),
119 a("restore", Op::RestoreRepo, "Restore a deleted one"),
120 a("purge", Op::PurgeRepo, "Remove a deleted one for good"),
121 a("security_alerts", Op::ListSecurityAlerts, "Secret and dependency alerts, filtered by state"),
122 a("dismiss_alert", Op::DismissSecurityAlert, "Dismiss an alert with a reason"),
123 a("reopen_alert", Op::ReopenSecurityAlert, "Reopen a dismissed alert"),
124 ],
125 },
126 Tool {
127 name: "issue",
128 title: "Issues",
129 description: "Issues: what should change. Read one before working on it to see the pull requests already made for it. Issues and pull requests share numbers; `comment` works on either.",
130 default_action: None,
131 actions: &[
132 a("list", Op::ListIssues, "Issues on a repository, newest first"),
133 a("get", Op::GetIssue, "One issue with comments and its pull requests"),
134 a("create", Op::CreateIssue, "Open an issue"),
135 a("update", Op::UpdateIssue, "Change title, body, labels, milestone or assignees"),
136 a("labels", Op::ListIssueLabels, "The labels an issue or pull request carries"),
137 a("add_labels", Op::AddIssueLabels, "Add labels to an issue or pull request"),
138 a("set_labels", Op::SetIssueLabels, "Replace the labels of an issue or pull request"),
139 a("remove_labels", Op::RemoveIssueLabels, "Take labels off an issue or pull request"),
140 a("close", Op::CloseIssue, "Close it without a pull request"),
141 a("reopen", Op::ReopenIssue, "Reopen it"),
142 a("comment", Op::AddComment, "Comment on an issue or pull request; path and line for one line of a change"),
143 a("import", Op::ImportIssue, "Open an issue from a Jira, Linear or Sentry item"),
144 ],
145 },
146 Tool {
147 name: "pull_request",
148 title: "Pull requests",
149 description: "Pull requests: start a change for an issue, record your session, mark it ready, ask people and teams to review, review and merge. Read `overlaps` and `behind` on `get` before going far, and `code_owners` for whose approval it needs.",
150 default_action: None,
151 actions: &[
152 a("list", Op::ListPullRequests, "Pull requests on a repository, newest first"),
153 a("get", Op::GetPullRequest, "Status, checks and required checks, reviews, overlaps, whether it is behind"),
154 a("changes", Op::GetPullRequestChanges, "Files and line-by-line diff"),
155 a("create", Op::CreatePullRequest, "Start a draft with its own fork to push to, or open one from a pushed branch"),
156 a("update", Op::UpdatePullRequest, "Change its base branch, labels, milestone, assignees or reviewers"),
157 a("record_session", Op::RecordSession, "Append prompt, reasoning and tool entries to its session"),
158 a("read_session", Op::ReadSession, "Its recorded session"),
159 a("ready", Op::MarkPullRequestReady, "Mark a draft ready, with a summary"),
160 a("request_reviewers", Op::RequestReviewers, "Ask people or teams to review it"),
161 a("remove_requested_reviewers", Op::RemoveRequestedReviewers, "Stop asking people or teams to review it"),
162 a("review", Op::ReviewPullRequest, "Approve or request changes"),
163 a("close", Op::ClosePullRequest, "Close without merging"),
164 a("merge", Op::MergePullRequest, "Land it, or join the merge queue"),
165 a("merge_queue", Op::GetMergeQueue, "The repository's merge queue"),
166 ],
167 },
168 Tool {
169 name: "agent",
170 title: "g1t agents",
171 description: "Put g1t's agent to work and talk to it. One agent per issue; to do more at once, use more issues. Starting an agent uses the workspace's money.",
172 default_action: None,
173 actions: &[
174 a("delegate", Op::Delegate, "Open an issue and put an agent on it in one step"),
175 a("assign", Op::AssignIssue, "Put an agent on an existing issue"),
176 a("message", Op::MessageAgent, "Tell the agent on a pull request something, or ask another agent"),
177 a("answer", Op::AnswerMessage, "Answer a question or handoff sent to you"),
178 a("take_messages", Op::TakeMessages, "For a g1t agent: messages not seen yet"),
179 ],
180 },
181 Tool {
182 name: "plan",
183 title: "Plans",
184 description: "Turn an outcome into issues: an agent proposes them with what done means and their dependencies; nothing opens until you apply the plan.",
185 default_action: None,
186 actions: &[
187 a("create", Op::PlanWork, "Ask an agent for a plan; read it with get until ready"),
188 a("get", Op::GetPlan, "A plan and the issues it proposes"),
189 a("apply", Op::ApplyPlan, "Open its issues; with assign, agents start in dependency order"),
190 ],
191 },
192 Tool {
193 name: "memory",
194 title: "Memory",
195 description: "What the project and its workspace remember for the next agent: how to build, conventions, decisions, traps. Recall before you start; remember one short fact at a time, never a secret.",
196 default_action: None,
197 actions: &[
198 a("recall", Op::Recall, "Search memory, or list it all"),
199 a("remember", Op::Remember, "Save one fact"),
200 ],
201 },
202 Tool {
203 name: "workflow",
204 title: "Workflows",
205 description: "GitHub Actions workflows from .g1t/workflows: their runs, jobs and logs, and running, cancelling or rerunning them. Runs' artifacts: listing, a download link, deleting, and how long they are kept. Deployments wherever they run (reported from any CI, made by jobs with an `environment:`, or built on g1t.page), their statuses and environments, and reporting your own; environments' protection rules, approving or rejecting the jobs they hold, approving a pull request's run from outside, the token's default permissions and repository dispatch. Checks on commits: statuses, check runs (a g1t Actions job is one) and check suites, to read where a commit stands or report on it from CI or an integration. Also the self-hosted runners they run on: a workspace's (`workspace`) or a repository's own (`repo`), their groups, and where agent work runs.",
206 default_action: None,
207 actions: &[
208 a("list", Op::ListWorkflows, "Workflows on the default branch"),
209 a("list_runs", Op::ListWorkflowRuns, "Runs, newest first"),
210 a("get_run", Op::GetWorkflowRun, "One run with its jobs and steps"),
211 a("job_logs", Op::GetJobLogs, "A job's log after a sequence number"),
212 a("dispatch", Op::DispatchWorkflow, "Run a workflow_dispatch workflow"),
213 a("cancel", Op::CancelWorkflowRun, "Cancel a run"),
214 a("rerun", Op::RerunWorkflowRun, "Run a finished run again"),
215 a("update", Op::UpdateWorkflow, "Turn a workflow on or off"),
216 a("list_artifacts", Op::Artifacts(ArtifactsOp::ListArtifacts), "A repository's artifacts, newest first; or a run's with run_artifacts"),
217 a("run_artifacts", Op::Artifacts(ArtifactsOp::ListRunArtifacts), "One run's artifacts"),
218 a("get_artifact", Op::Artifacts(ArtifactsOp::GetArtifact), "One artifact: size, digest, expiry, run"),
219 a("download_artifact", Op::Artifacts(ArtifactsOp::DownloadArtifact), "A 10-minute link to an artifact's zip"),
220 a("delete_artifact", Op::Artifacts(ArtifactsOp::DeleteArtifact), "Delete an artifact before it expires"),
221 a("artifact_retention", Op::Artifacts(ArtifactsOp::GetArtifactRetention), "Days the repository keeps artifacts"),
222 a("set_artifact_retention", Op::Artifacts(ArtifactsOp::SetArtifactRetention), "Change the days the repository keeps artifacts"),
223 a("combined_status", Op::Checks(ChecksOp::GetCombinedStatus), "A commit's statuses and the state they add up to"),
224 a("list_statuses", Op::Checks(ChecksOp::ListCommitStatuses), "A commit's statuses, newest first"),
225 a("set_status", Op::Checks(ChecksOp::CreateCommitStatus), "Set a status on a commit"),
226 a("list_check_runs", Op::Checks(ChecksOp::ListCheckRunsForRef), "A commit's check runs, g1t Actions jobs included"),
227 a("get_check_run", Op::Checks(ChecksOp::GetCheckRun), "One check run with its report"),
228 a("check_run_annotations", Op::Checks(ChecksOp::ListCheckRunAnnotations), "What a check run says about lines of files"),
229 a("create_check_run", Op::Checks(ChecksOp::CreateCheckRun), "Report a check run on a commit"),
230 a("update_check_run", Op::Checks(ChecksOp::UpdateCheckRun), "Move a check run on, complete it, add annotations"),
231 a("rerequest_check_run", Op::Checks(ChecksOp::RerequestCheckRun), "Ask for a check run to run again"),
232 a("list_check_suites", Op::Checks(ChecksOp::ListCheckSuitesForRef), "A commit's check suites, one per reporter or workflow run"),
233 a("get_check_suite", Op::Checks(ChecksOp::GetCheckSuite), "One check suite"),
234 a("rerequest_check_suite", Op::Checks(ChecksOp::RerequestCheckSuite), "Ask for a check suite to run again"),
235 a("list_deployments", Op::Deployments(DeploymentsOp::ListDeployments), "Deployments wherever they run, newest first, filtered"),
236 a("get_deployment", Op::Deployments(DeploymentsOp::GetDeployment), "One deployment with every status it has had"),
237 a("create_deployment", Op::Deployments(DeploymentsOp::CreateDeployment), "Report a deployment of a ref to an environment"),
238 a("deployment_statuses", Op::Deployments(DeploymentsOp::ListDeploymentStatuses), "A deployment's statuses, newest first"),
239 a("create_deployment_status", Op::Deployments(DeploymentsOp::CreateDeploymentStatus), "Report where a deployment is: in_progress, success, failure"),
240 a("list_environments", Op::Deployments(DeploymentsOp::ListEnvironments), "Environments with their current and latest deployments"),
241 a("get_environment", Op::Deployments(DeploymentsOp::GetEnvironment), "One environment by name, with its protection rules"),
242 a("update_environment", Op::Protection(ProtectionOp::UpdateEnvironment), "Set an environment's reviewers, wait timer and branches"),
243 a("delete_environment", Op::Protection(ProtectionOp::DeleteEnvironment), "Remove an environment's protection rules"),
244 a("pending_deployments", Op::Protection(ProtectionOp::GetPendingDeployments), "The environments holding a run's jobs"),
245 a("review_deployments", Op::Protection(ProtectionOp::ReviewPendingDeployments), "Approve or reject a run's jobs for its environments"),
246 a("approve_run", Op::Protection(ProtectionOp::ApproveWorkflowRun), "Let a run of a pull request from outside start"),
247 a("get_permissions", Op::Protection(ProtectionOp::GetWorkflowPermissions), "What a job's token gets without `permissions:`"),
248 a("set_permissions", Op::Protection(ProtectionOp::SetWorkflowPermissions), "Set it: read or write"),
249 a("get_approval_policy", Op::Protection(ProtectionOp::GetForkPrApproval), "Which pull requests' runs wait for approval"),
250 a("set_approval_policy", Op::Protection(ProtectionOp::SetForkPrApproval), "Set which pull requests' runs wait for approval"),
251 a("repository_dispatch", Op::Protection(ProtectionOp::CreateRepositoryDispatch), "Start repository_dispatch workflows with an event"),
252 a("get_workspace_permissions", Op::Protection(ProtectionOp::GetWorkspaceWorkflowPermissions), "A workspace's default and maximum token permissions"),
253 a("set_workspace_permissions", Op::Protection(ProtectionOp::SetWorkspaceWorkflowPermissions), "Set them, and whether jobs may open pull requests"),
254 a("list_runners", Op::ListRunners, "Self-hosted runners, with status, labels and what each is doing"),
255 a("create_runner_token", Op::CreateRunnerRegistrationToken, "A one-hour token for g1t-runner register"),
256 a("remove_runner", Op::RemoveRunner, "Remove a self-hosted runner"),
257 a("list_runner_groups", Op::ListRunnerGroups, "A workspace's runner groups"),
258 a("create_runner_group", Op::CreateRunnerGroup, "Make a group, for some repositories"),
259 a("update_runner_group", Op::UpdateRunnerGroup, "Rename a group or change its repositories"),
260 a("delete_runner_group", Op::DeleteRunnerGroup, "Delete a group; its runners join the default"),
261 a("get_runner_settings", Op::GetRunnerSettings, "Where agent work runs; whether forks may use runners"),
262 a("update_runner_settings", Op::UpdateRunnerSettings, "Change them"),
263 ],
264 },
265 Tool {
266 name: "secret",
267 title: "Secrets and variables",
268 description: "A repository's or workspace's secrets and variables, read by workflows and deployments. Secret values are never returned.",
269 default_action: None,
270 actions: &[
271 a("list_secrets", Op::ListActionsSecrets, "Secrets, without values"),
272 a("set_secret", Op::SetActionsSecret, "Add or change a secret"),
273 a("delete_secret", Op::DeleteActionsSecret, "Remove a secret"),
274 a("list_variables", Op::ListActionsVariables, "Variables, with values"),
275 a("set_variable", Op::SetActionsVariable, "Add or change a variable"),
276 a("delete_variable", Op::DeleteActionsVariable, "Remove a variable"),
277 ],
278 },
279 Tool {
280 name: "webhook",
281 title: "Webhooks",
282 description: "HTTPS addresses sent signed events as they happen, for a repository or a whole workspace.",
283 default_action: None,
284 actions: &[
285 a("list", Op::ListWebhooks, "Webhooks, without secrets"),
286 a("create", Op::CreateWebhook, "Register one; a ping is sent"),
287 a("update", Op::UpdateWebhook, "Change address, events or active"),
288 a("delete", Op::DeleteWebhook, "Remove one"),
289 a("ping", Op::PingWebhook, "Send a ping"),
290 a("list_deliveries", Op::ListWebhookDeliveries, "Latest deliveries"),
291 a("redeliver", Op::RedeliverWebhook, "Send a delivery again"),
292 ],
293 },
294 Tool {
295 name: "access",
296 title: "Who has access",
297 description: "Who has access to a repository and with which role (read, triage, write, maintain, admin), outside collaborators, and a workspace's base permission.",
298 default_action: None,
299 actions: &[
300 a("list_collaborators", Op::ListCollaborators, "Everyone with a role, and pending invitations"),
301 a("get_permission", Op::GetCollaboratorPermission, "One person's role and capabilities"),
302 a("add_collaborator", Op::AddCollaborator, "Give someone a role, by username or email"),
303 a("update_collaborator", Op::UpdateCollaborator, "Change a direct role"),
304 a("remove_collaborator", Op::RemoveCollaborator, "Take away a direct role"),
305 a("list_invitations", Op::ListRepoInvitations, "Pending invitations to a repository"),
306 a("revoke_invitation", Op::RevokeRepoInvitation, "Withdraw one"),
307 a("set_base_permission", Op::SetBasePermission, "What every member gets on each repository"),
308 a("list_outside_collaborators", Op::ListOutsideCollaborators, "People with roles who are not members"),
309 ],
310 },
311 Tool {
312 name: "team",
313 title: "Teams",
314 description: "Teams: groups of a workspace's members, given roles on repositories together, mentioned as @workspace/team and asked to review together. Name one by `workspace` and its slug (`team`). Any member may create a team; the workspace's owners and the team's maintainers manage it. A secret team is seen only by its people and the owners.",
315 default_action: None,
316 actions: &[
317 a("list", Op::ListTeams, "A workspace's teams you can see"),
318 a("get", Op::GetTeam, "One team"),
319 a("create", Op::CreateTeam, "Create a team; you become its maintainer"),
320 a("update", Op::UpdateTeam, "Change its name, slug, description, visibility, parent or notifications"),
321 a("delete", Op::DeleteTeam, "Delete it; its child teams move up"),
322 a("list_members", Op::ListTeamMembers, "Its people and their roles, child teams' with include_child_teams"),
323 a("set_member", Op::SetTeamMember, "Add a member of the workspace, or change their role"),
324 a("remove_member", Op::RemoveTeamMember, "Take someone out of it"),
325 a("list_child_teams", Op::ListChildTeams, "The teams nested under it"),
326 a("list_repos", Op::ListTeamRepos, "The repositories it has a role on"),
327 a("set_repo", Op::SetTeamRepo, "Give it a role on a repository"),
328 a("remove_repo", Op::RemoveTeamRepo, "Take its role on a repository away"),
329 a("set_review_assignment", Op::SetTeamReviewAssignment, "Whom it picks when asked to review"),
330 a("list_user_teams", Op::ListUserTeams, "The teams someone is in"),
331 ],
332 },
333 Tool {
334 name: "workspace",
335 title: "Workspaces",
336 description: "Workspaces own repositories (g1t.sh/{workspace}/{repo}): create, update or delete one, invite members, connect integrations and model providers, set rulesets that hold across its repositories, read and change its projects (what each is, where it runs, its links), and keep your own pinned projects at the top of its sidebar.",
337 default_action: None,
338 actions: &[
339 a("get", Op::GetWorkspace, "A workspace's details and settings"),
340 a("create", Op::CreateWorkspace, "Create a workspace"),
341 a("delete", Op::DeleteWorkspace, "Delete a workspace and everything in it (support can restore it for 30 days)"),
342 a("update", Op::UpdateWorkspace, "Change its name, description, base permission, who may create teams, member privileges or the two-factor requirement"),
343 a("list_members", Op::ListMembers, "Its members, owners first, with their roles"),
344 a("update_member", Op::UpdateMember, "Make someone an owner or a member, billing manager or security manager"),
345 a("remove_member", Op::RemoveMember, "Remove someone from it"),
346 a("transfer_ownership", Op::TransferOwnership, "Hand it to another member: they become an owner, you a member"),
347 a("leave", Op::LeaveWorkspace, "Leave it yourself"),
348 a("list_invites", Op::ListWorkspaceInvites, "Its invites"),
349 a("invite_member", Op::InviteMember, "Invite an email address"),
350 a("revoke_invite", Op::RevokeWorkspaceInvite, "Revoke a pending invite"),
351 a("list_integrations", Op::ListIntegrations, "Model providers, alert sources, trackers"),
352 a("connect_integration", Op::ConnectIntegration, "Connect one"),
353 a("update_integration", Op::UpdateIntegration, "Change one: rotate its key, choose its AI Gateway models"),
354 a("disconnect_integration", Op::DisconnectIntegration, "Remove one"),
355 a("test_integration", Op::TestIntegration, "Check its credentials"),
356 a("get_model_routes", Op::GetModelRoutes, "Where each kind of work's model requests go"),
357 a("set_model_routes", Op::SetModelRoutes, "Replace them"),
358 a("list_projects", Op::ListProjects, "Its projects you can see: what each is, where it runs, its links"),
359 a("get_project", Op::GetProject, "One project"),
360 a("update_project", Op::UpdateProject, "Change a project's name, description, kind, where it runs or its links"),
361 a("list_pinned_projects", Op::ListPinnedProjects, "Your pinned projects in it, in your order"),
362 a("pin_project", Op::PinProject, "Pin a project, at a position or the end"),
363 a("unpin_project", Op::UnpinProject, "Unpin a project"),
364 a("reorder_pinned_projects", Op::ReorderPinnedProjects, "Put your pins in a new order"),
365 a("list_rulesets", Op::Rules(RulesOp::ListWorkspaceRulesets), "Its rulesets, which hold across its repositories"),
366 a("get_ruleset", Op::Rules(RulesOp::GetWorkspaceRuleset), "One of its rulesets"),
367 a("create_ruleset", Op::Rules(RulesOp::CreateWorkspaceRuleset), "Create a ruleset for some or all of its repositories"),
368 a("update_ruleset", Op::Rules(RulesOp::UpdateWorkspaceRuleset), "Change one of its rulesets"),
369 a("delete_ruleset", Op::Rules(RulesOp::DeleteWorkspaceRuleset), "Delete one of its rulesets"),
370 a("rule_evaluations", Op::Rules(RulesOp::ListWorkspaceRuleEvaluations), "How rules judged changes across its repositories"),
371 ],
372 },
373 Tool {
374 name: "billing",
375 title: "Billing",
376 description: "A workspace's billing: its usage by product, project and day, its budget (the monthly spend limit, alerts and whether usage pauses at it), its AI credit, its invoices, and its AI Gateway requests. Amounts are whole millionths of a dollar (`_micros`), or cents (`_cents`) where named. Members read it; changing the budget and buying credit are for owners, as people, and never for g1t's agents.",
377 default_action: Some("usage"),
378 actions: &[
379 a("usage", Op::GetUsage, "Usage over a range of days, by product, meter, project and day, and what paid for it"),
380 a("budget", Op::GetBudget, "The monthly spend limit, what was spent, alerts and whether usage pauses at the limit"),
381 a("set_budget", Op::SetBudget, "Change the spend limit, alerts, pausing or the alert webhook"),
382 a("ai_credit", Op::GetAiCredit, "AI credit left, its grants, auto-reload and how to buy more"),
383 a("buy_ai_credit", Op::BuyAiCredit, "A payment page to buy AI credit, for a person to open"),
384 a("invoices", Op::ListInvoices, "Every invoice, the itemised usage invoices, and the next one so far"),
385 a("billing_details", Op::GetBillingDetails, "Who invoices are made out to and the payment method on file"),
386 a("gateway_requests", Op::ListGatewayRequests, "Recent AI Gateway requests: model, tokens, cost, status and token"),
387 ],
388 },
389 Tool {
390 name: "security",
391 title: "Security",
392 description: "A repository's security: secret scanning alerts and push protection bypasses, custom secret patterns, code scanning alerts and SARIF uploads, vulnerability alerts, the dependency graph and its SBOM, dependency review, settings, and a workspace's overview. Fix an alert with g1t. Findings are shown to those who can change the code only. Give `repo` (owner/name), or `workspace` for lists across one.",
393 default_action: Some("secret_alerts"),
394 actions: &[
395 a("secret_alerts", Op::Security(SecurityOp::ListSecretAlerts), "Secret scanning alerts; by state, secret_type, validity, bypassed"),
396 a("secret_alert", Op::Security(SecurityOp::GetSecretAlert), "One secret alert, with where it was found and its bypass requests"),
397 a("update_secret_alert", Op::Security(SecurityOp::UpdateSecretAlert), "Dismiss a secret alert with a reason, or reopen it"),
398 a("secret_locations", Op::Security(SecurityOp::ListSecretLocations), "Every file, line and commit a secret is in"),
399 a("bypass", Op::Security(SecurityOp::BypassPushProtection), "Push past push protection with a reason, or ask to"),
400 a("check_validity", Op::Security(SecurityOp::CheckSecretValidity), "Ask a secret's issuer whether it still works"),
401 a("bypass_requests", Op::Security(SecurityOp::ListBypassRequests), "A workspace's push protection bypass requests"),
402 a("review_bypass", Op::Security(SecurityOp::ReviewBypassRequest), "Approve, deny or cancel a bypass request"),
403 a("patterns", Op::Security(SecurityOp::ListCustomPatterns), "Custom secret patterns of a repository or workspace"),
404 a("create_pattern", Op::Security(SecurityOp::CreateCustomPattern), "Create a custom secret pattern, as a draft or published"),
405 a("update_pattern", Op::Security(SecurityOp::UpdateCustomPattern), "Change, publish or unpublish a custom pattern"),
406 a("delete_pattern", Op::Security(SecurityOp::DeleteCustomPattern), "Delete a custom pattern"),
407 a("dry_run_pattern", Op::Security(SecurityOp::DryRunCustomPattern), "Run a pattern over the default branch without saving it"),
408 a("code_alerts", Op::Security(SecurityOp::ListCodeAlerts), "Code scanning alerts; by state, severity, tool, rule_id"),
409 a("code_alert", Op::Security(SecurityOp::GetCodeAlert), "One code scanning alert by number"),
410 a("update_code_alert", Op::Security(SecurityOp::UpdateCodeAlert), "Dismiss a code scanning alert with a reason, or reopen it"),
411 a("analyses", Op::Security(SecurityOp::ListAnalyses), "Code scanning analyses, newest first"),
412 a("upload_sarif", Op::Security(SecurityOp::UploadSarif), "Upload a SARIF file, gzipped and base64-encoded"),
413 a("sarif_upload", Op::Security(SecurityOp::GetSarifUpload), "Whether a SARIF upload was read, and its analyses"),
414 a("vulnerability_alerts", Op::Security(SecurityOp::ListVulnerabilityAlerts), "Vulnerable dependencies; by state, severity, ecosystem, package"),
415 a("vulnerability_alert", Op::Security(SecurityOp::GetVulnerabilityAlert), "One vulnerability alert"),
416 a("update_vulnerability_alert", Op::Security(SecurityOp::UpdateVulnerabilityAlert), "Dismiss a vulnerability alert with a reason, or reopen it"),
417 a("fix", Op::Security(SecurityOp::FixAlert), "Put g1t on an issue to fix an alert"),
418 a("dependency_graph", Op::Security(SecurityOp::GetDependencyGraph), "Every package the lockfiles resolve, direct or transitive"),
419 a("sbom", Op::Security(SecurityOp::GetSbom), "The dependency graph as an SPDX 2.3 document"),
420 a("compare_dependencies", Op::Security(SecurityOp::CompareDependencies), "What changes in dependencies between base...head"),
421 a("settings", Op::Security(SecurityOp::GetSettings), "A repository's security settings"),
422 a("update_settings", Op::Security(SecurityOp::UpdateSettings), "Change when checks fail and dependency review's policy"),
423 a("workspace_settings", Op::Security(SecurityOp::GetWorkspaceSettings), "A workspace's delegated bypass and validity checks"),
424 a("update_workspace_settings", Op::Security(SecurityOp::UpdateWorkspaceSettings), "Turn delegated bypass or validity checks on or off"),
425 a("overview", Op::Security(SecurityOp::GetOverview), "A workspace's alerts, trends and coverage"),
426 ],
427 },
428 Tool {
429 name: "notifications",
430 title: "Notifications",
431 description: "Your inbox: what needs you, and what you follow. One thread per issue, pull request, workflow or deployment, with why you were told (`reason`): an agent waiting on you, a review asked of you, an assignment, a mention, your work's checks, or what you subscribe to and watch. Mark threads read or done once handled, and choose what you hear of with subscribe, unsubscribe and watch. Your own: a personal token.",
432 default_action: Some("list"),
433 actions: &[
434 a("list", Op::ListNotifications, "Unread threads, latest first; all, a view, a reason, a repository"),
435 a("get", Op::GetNotificationThread, "One thread with its recent activity and your subscription"),
436 a("mark_read", Op::MarkThreadRead, "Mark a thread read, or unread"),
437 a("mark_all_read", Op::MarkNotificationsRead, "Mark everything read up to a time, or one repository's"),
438 a("done", Op::MarkThreadDone, "Mark a thread done; new activity brings it back"),
439 a("save", Op::SaveThread, "Save a thread, or unsave it"),
440 a("snooze", Op::SnoozeThread, "Snooze a thread until a time, or bring it back"),
441 a("subscription", Op::GetThreadSubscription, "Your subscription to an issue or pull request"),
442 a("subscribe", Op::SetThreadSubscription, "Subscribe to an issue or pull request, or ignore it"),
443 a("unsubscribe", Op::DeleteThreadSubscription, "Unsubscribe until you comment or are mentioned"),
444 a("watching", Op::GetRepoSubscription, "How you watch a repository"),
445 a("watch", Op::SetRepoSubscription, "Watch a repository: participating, all, ignore or custom"),
446 a("unwatch", Op::DeleteRepoSubscription, "Stop watching a repository"),
447 a("watched", Op::ListWatchedRepos, "Repositories you watch other than the default way"),
448 ],
449 },
450 Tool {
451 name: "account",
452 title: "Your account",
453 description: "Who this token acts as and its workspaces (`whoami`), your email addresses, your invites, and invitations to repositories waiting for you.",
454 default_action: Some("whoami"),
455 actions: &[
456 a("whoami", Op::Whoami, "Who the token acts as, and its workspaces"),
457 a("list_emails", Op::ListEmails, "Your addresses"),
458 a("add_email", Op::AddEmail, "Add an address"),
459 a("remove_email", Op::RemoveEmail, "Remove an address"),
460 a("update_email_settings", Op::UpdateEmailSettings, "Primary, backup and privacy"),
461 a("list_invites", Op::ListInvites, "Your invites to g1t"),
462 a("create_invite", Op::CreateInvite, "Make an invite"),
463 a("revoke_invite", Op::RevokeInvite, "Revoke one"),
464 a("list_repository_invitations", Op::ListMyRepoInvitations, "Invitations to repositories for you"),
465 a("accept_repository_invitation", Op::AcceptRepoInvitation, "Accept one"),
466 a("decline_repository_invitation", Op::DeclineRepoInvitation, "Decline one"),
467 ],
468 },
469];
470
471/// Operations that cannot be undone, or reach beyond g1t's own records:
472/// clients ask before running a tool that has any of them.
473fn destructive(op: Op) -> bool {
474 matches!(
475 op,
476 Op::Security(SecurityOp::DeleteCustomPattern | SecurityOp::BypassPushProtection)
477 | Op::Rules(RulesOp::DeleteRepoRuleset | RulesOp::DeleteWorkspaceRuleset)
478 | Op::DeleteWorkspace
479 | Op::UpdateWorkspace
480 | Op::RemoveMember
481 | Op::TransferOwnership
482 | Op::LeaveWorkspace
483 | Op::DeleteRepo
484 | Op::PurgeRepo
485 | Op::TransferRepo
486 | Op::SetRepoVisibility
487 | Op::RemoveEmail
488 | Op::RemoveCollaborator
489 | Op::DisconnectIntegration
490 | Op::UpdateIntegration
491 | Op::DeleteWebhook
492 | Op::DeleteActionsSecret
493 | Op::DeleteActionsVariable
494 | Op::SetActionsSecret
495 | Op::SetActionsVariable
496 | Op::SetModelRoutes
497 | Op::SetBasePermission
498 | Op::DeleteTeam
499 | Op::RemoveTeamRepo
500 | Op::MergePullRequest
501 | Op::RemoveRunner
502 | Op::DeleteRunnerGroup
503 | Op::UpdateRunnerSettings
504 )
505}
506
507/// Whether an operation only reads.
508pub fn reads_only(op: Op) -> bool {
509 NO_SCOPE.contains(&op.name())
510 || scope_for(op.name()).is_some_and(|scope| scope.level() == Level::Read)
511}
512
513/// What decides which actions a caller sees.
514pub enum Gate<'a> {
515 /// No limit beyond the person's own role.
516 Everything,
517 /// A g1t agent's token: the operations its run lists.
518 Agent(&'a AgentScope),
519 /// An access token with scopes.
520 Token(&'a TokenAccess),
521}
522
523impl Gate<'_> {
524 pub fn allows(&self, op: Op) -> bool {
525 match self {
526 Gate::Everything => true,
527 Gate::Agent(scope) => op.allowed_by(scope) && !NEVER.contains(&op.name()),
528 Gate::Token(access) => {
529 if NO_SCOPE.contains(&op.name()) {
530 return true;
531 }
532 match scope_for(op.name()) {
533 Some(scope) => access.allows(scope),
534 None => access.scopes.is_none(),
535 }
536 }
537 }
538 }
539}
540
541impl Tool {
542 pub fn by_name(name: &str) -> Option<&'static Tool> {
543 TOOLS.iter().find(|tool| tool.name == name)
544 }
545
546 pub fn action(&self, name: &str) -> Option<&'static Action> {
547 // The tools are 'static; find through TOOLS to keep the lifetime.
548 TOOLS
549 .iter()
550 .find(|tool| tool.name == self.name)
551 .and_then(|tool| tool.actions.iter().find(|action| action.name == name))
552 }
553
554 pub fn visible(&self, gate: &Gate) -> Vec<&'static Action> {
555 TOOLS
556 .iter()
557 .find(|tool| tool.name == self.name)
558 .map(|tool| tool.actions.iter().filter(|action| gate.allows(action.op)).collect())
559 .unwrap_or_default()
560 }
561
562 /// The flat input schema of the actions given.
563 pub fn input_schema(&self, actions: &[&Action]) -> Value {
564 let mut properties = Map::new();
565 let lines: Vec<String> = actions
566 .iter()
567 .map(|action| {
568 let required: Vec<String> = action.op.required();
569 if required.is_empty() {
570 format!("{}: {}.", action.name, action.summary)
571 } else {
572 format!("{} ({}): {}.", action.name, required.join(", "), action.summary)
573 }
574 })
575 .collect();
576 let mut action_schema = json!({
577 "type": "string",
578 "enum": actions.iter().map(|action| action.name).collect::<Vec<_>>(),
579 "description": lines.join("\n"),
580 });
581 if let Some(default) = self.default_action.filter(|name| actions.iter().any(|action| action.name == *name)) {
582 action_schema["default"] = json!(default);
583 }
584 properties.insert("action".to_owned(), action_schema);
585 for action in actions {
586 for (name, schema) in action.op.properties() {
587 merge_property(&mut properties, name, schema);
588 }
589 }
590 let mut required = vec![];
591 if self.default_action.is_none() {
592 required.push("action");
593 }
594 let mut schema = json!({ "type": "object", "properties": properties });
595 if !required.is_empty() {
596 schema["required"] = json!(required);
597 }
598 schema
599 }
600
601 /// The input schema keyed by action: one `oneOf` branch per action,
602 /// each with its own fields and the ones it needs.
603 pub fn discriminated(&self, actions: &[&Action]) -> Value {
604 let branches: Vec<Value> = actions
605 .iter()
606 .map(|action| {
607 let mut properties = Map::new();
608 properties.insert("action".to_owned(), json!({ "const": action.name }));
609 properties.extend(action.op.properties());
610 let mut required = vec![Value::String("action".to_owned())];
611 // The default action may leave `action` out.
612 if self.default_action == Some(action.name) {
613 required.clear();
614 }
615 required.extend(action.op.required().into_iter().map(Value::String));
616 json!({
617 "title": action.name,
618 "description": action.summary,
619 "type": "object",
620 "properties": properties,
621 "required": required,
622 })
623 })
624 .collect();
625 json!({ "type": "object", "oneOf": branches })
626 }
627
628 /// MCP's hints about the actions given: whether the tool only reads,
629 /// whether it can destroy something, and whether calling it twice is
630 /// the same as once.
631 pub fn annotations(&self, actions: &[&Action]) -> Value {
632 let read_only = actions.iter().all(|action| reads_only(action.op));
633 json!({
634 "title": self.title,
635 "readOnlyHint": read_only,
636 "destructiveHint": !read_only && actions.iter().any(|action| destructive(action.op)),
637 "idempotentHint": read_only,
638 "openWorldHint": false,
639 })
640 }
641
642 /// The tool as `tools/list` gives it, for a caller behind `gate`, or
643 /// `None` when it may use none of its actions.
644 pub fn listed(&self, gate: &Gate) -> Option<Value> {
645 let actions = self.visible(gate);
646 if actions.is_empty() {
647 return None;
648 }
649 Some(json!({
650 "name": self.name,
651 "title": self.title,
652 "description": self.description,
653 "inputSchema": self.input_schema(&actions),
654 "annotations": self.annotations(&actions),
655 }))
656 }
657}
658
659/// Adds a property to a tool's flat schema. The first action to use a name
660/// describes it; a later one with other allowed values adds them.
661fn merge_property(properties: &mut Map<String, Value>, name: String, schema: Value) {
662 match properties.get_mut(&name) {
663 None => {
664 properties.insert(name, schema);
665 }
666 Some(existing) => {
667 if let (Some(Value::Array(had)), Some(Value::Array(more))) =
668 (existing.get("enum").cloned(), schema.get("enum"))
669 {
670 let mut merged = had;
671 for value in more {
672 if !merged.contains(value) {
673 merged.push(value.clone());
674 }
675 }
676 existing["enum"] = Value::Array(merged);
677 }
678 // Different kinds of value under one name: say less, accept both.
679 if existing.get("type") != schema.get("type")
680 && let Some(fields) = existing.as_object_mut()
681 {
682 fields.remove("type");
683 fields.remove("items");
684 }
685 }
686 }
687}
688
689/// What a call to a tool runs: the operation its action names, or why not.
690pub fn resolve(tool: &Tool, arguments: &Value) -> Result<Op, String> {
691 let names = || {
692 tool.actions
693 .iter()
694 .map(|action| action.name)
695 .collect::<Vec<_>>()
696 .join(", ")
697 };
698 let Some(name) = arguments["action"].as_str().or(tool.default_action) else {
699 return Err(format!("Give an action: one of {}.", names()));
700 };
701 let Some(action) = tool.action(name) else {
702 return Err(format!("{} has no action {name}. Its actions: {}.", tool.name, names()));
703 };
704 let missing: Vec<String> = action
705 .op
706 .required()
707 .into_iter()
708 .filter(|field| arguments.get(field).is_none_or(Value::is_null))
709 .collect();
710 if !missing.is_empty() {
711 return Err(format!("{}.{name} needs {}.", tool.name, missing.join(", ")));
712 }
713 Ok(action.op)
714}
715
716#[cfg(test)]
717mod tests {
718 use super::*;
719 use g1t_contracts::scopes::{Preset, Scope};
720
721 fn listed(gate: &Gate) -> Vec<Value> {
722 TOOLS.iter().filter_map(|tool| tool.listed(gate)).collect()
723 }
724
725 fn token(scopes: Option<Vec<Scope>>) -> TokenAccess {
726 TokenAccess {
727 token_id: "tok_1".to_owned(),
728 scopes: scopes.map(|scopes| scopes.iter().map(|scope| scope.as_str().to_owned()).collect()),
729 legacy: false,
730 name: None,
731 ..TokenAccess::default()
732 }
733 }
734
735 #[test]
736 fn every_operation_is_exactly_one_action_of_one_tool() {
737 for op in Op::ALL {
738 let count = TOOLS
739 .iter()
740 .flat_map(|tool| tool.actions.iter())
741 .filter(|action| action.op == op)
742 .count();
743 assert_eq!(count, 1, "{} is {count} actions", op.name());
744 }
745 for tool in TOOLS {
746 let mut names = std::collections::HashSet::new();
747 for action in tool.actions {
748 assert!(names.insert(action.name), "{}.{} twice", tool.name, action.name);
749 }
750 if let Some(default) = tool.default_action {
751 assert!(tool.action(default).is_some(), "{}", tool.name);
752 }
753 }
754 assert!(TOOLS.len() <= 17, "{} tools", TOOLS.len());
755 }
756
757 #[test]
758 fn every_operation_needs_exactly_one_scope_or_none() {
759 use g1t_contracts::scopes::OPERATIONS;
760 for op in Op::ALL {
761 let mapped = OPERATIONS.iter().filter(|(name, _)| *name == op.name()).count();
762 let free = NO_SCOPE.contains(&op.name());
763 assert_eq!(mapped + usize::from(free), 1, "{}", op.name());
764 }
765 for (name, _) in OPERATIONS {
766 assert!(Op::by_name(name).is_some(), "{name} is not an operation");
767 }
768 }
769
770 #[test]
771 fn each_tool_schema_is_valid_with_one_branch_per_action() {
772 for tool in TOOLS {
773 let actions: Vec<&Action> = tool.actions.iter().collect();
774 let flat = tool.input_schema(&actions);
775 assert_eq!(flat["type"], "object");
776 assert!(flat.get("oneOf").is_none(), "no oneOf at the top level");
777 let listed: Vec<&str> = flat["properties"]["action"]["enum"]
778 .as_array()
779 .unwrap()
780 .iter()
781 .map(|name| name.as_str().unwrap())
782 .collect();
783 assert_eq!(listed, tool.actions.iter().map(|action| action.name).collect::<Vec<_>>());
784 for action in tool.actions {
785 for field in action.op.required() {
786 assert!(flat["properties"].get(&field).is_some(), "{}.{}: {field}", tool.name, action.name);
787 }
788 }
789 let keyed = tool.discriminated(&actions);
790 let branches = keyed["oneOf"].as_array().unwrap();
791 assert_eq!(branches.len(), tool.actions.len());
792 for (branch, action) in branches.iter().zip(tool.actions) {
793 assert_eq!(branch["properties"]["action"]["const"], action.name);
794 for field in branch["required"].as_array().unwrap() {
795 assert!(branch["properties"].get(field.as_str().unwrap()).is_some(), "{}.{}: {field}", tool.name, action.name);
796 }
797 }
798 // A well-formed JSON Schema object throughout.
799 let text = serde_json::to_string(&flat).unwrap();
800 assert!(serde_json::from_str::<Value>(&text).is_ok());
801 }
802 }
803
804 #[test]
805 fn a_read_only_token_sees_read_actions_only() {
806 let access = token(Preset::ReadOnly.scopes());
807 let gate = Gate::Token(&access);
808 for tool in TOOLS {
809 for action in tool.visible(&gate) {
810 assert!(reads_only(action.op), "{}.{}", tool.name, action.name);
811 }
812 }
813 let tools = listed(&gate);
814 for tool in &tools {
815 assert_eq!(tool["annotations"]["readOnlyHint"], true, "{}", tool["name"]);
816 assert_eq!(tool["annotations"]["destructiveHint"], false);
817 }
818 let issue = tools.iter().find(|tool| tool["name"] == "issue").unwrap();
819 assert_eq!(issue["inputSchema"]["properties"]["action"]["enum"], json!(["list", "get", "labels"]));
820 // Nothing of the agent tool is a read.
821 assert!(!tools.iter().any(|tool| tool["name"] == "agent"));
822 }
823
824 #[test]
825 fn a_narrow_token_sees_only_its_tools() {
826 let access = token(Some(vec![Scope::IssuesWrite]));
827 let names: Vec<Value> = listed(&Gate::Token(&access)).into_iter().map(|tool| tool["name"].clone()).collect();
828 // Labels and milestones are the repository's, managed with issues:write.
829 assert_eq!(names, vec![json!("repository"), json!("issue"), json!("plan"), json!("account")]);
830 // Notifications are a resource of their own: reading them lists
831 // only what reads.
832 let reader = token(Some(vec![Scope::NotificationsRead]));
833 let tools = listed(&Gate::Token(&reader));
834 let notifications = tools.iter().find(|tool| tool["name"] == "notifications").unwrap();
835 assert_eq!(
836 notifications["inputSchema"]["properties"]["action"]["enum"],
837 json!(["list", "get", "subscription", "watching", "watched"])
838 );
839 assert_eq!(notifications["annotations"]["readOnlyHint"], true);
840 let full = token(None);
841 assert_eq!(listed(&Gate::Token(&full)).len(), TOOLS.len());
842 assert_eq!(listed(&Gate::Everything).len(), TOOLS.len());
843 }
844
845 #[test]
846 fn a_tool_that_can_destroy_says_so() {
847 let tools = listed(&Gate::Everything);
848 let repository = tools.iter().find(|tool| tool["name"] == "repository").unwrap();
849 assert_eq!(repository["annotations"]["destructiveHint"], true);
850 assert_eq!(repository["annotations"]["readOnlyHint"], false);
851 let memory = tools.iter().find(|tool| tool["name"] == "memory").unwrap();
852 assert_eq!(memory["annotations"]["destructiveHint"], false);
853 }
854
855 #[test]
856 fn calls_resolve_to_their_operation_or_say_what_is_missing() {
857 let issue = Tool::by_name("issue").unwrap();
858 assert_eq!(resolve(issue, &json!({ "action": "get", "repo": "a/b", "number": 1 })), Ok(Op::GetIssue));
859 assert_eq!(resolve(issue, &json!({ "action": "get", "repo": "a/b" })), Err("issue.get needs number.".to_owned()));
860 assert!(resolve(issue, &json!({})).unwrap_err().starts_with("Give an action"));
861 assert!(resolve(issue, &json!({ "action": "explode" })).unwrap_err().contains("no action explode"));
862 let search = Tool::by_name("search").unwrap();
863 assert_eq!(resolve(search, &json!({ "query": "x" })), Ok(Op::Search));
864 let account = Tool::by_name("account").unwrap();
865 assert_eq!(resolve(account, &json!({})), Ok(Op::Whoami));
866 }
867
868 #[test]
869 fn teams_are_one_tool_and_a_workspace_reader_sees_only_its_reads() {
870 let team = Tool::by_name("team").unwrap();
871 let names: Vec<&str> = team.actions.iter().map(|action| action.name).collect();
872 assert_eq!(
873 names,
874 [
875 "list",
876 "get",
877 "create",
878 "update",
879 "delete",
880 "list_members",
881 "set_member",
882 "remove_member",
883 "list_child_teams",
884 "list_repos",
885 "set_repo",
886 "remove_repo",
887 "set_review_assignment",
888 "list_user_teams",
889 ]
890 );
891 let reader = token(Some(vec![Scope::WorkspaceRead]));
892 let tools = listed(&Gate::Token(&reader));
893 let listed_team = tools.iter().find(|tool| tool["name"] == "team").unwrap();
894 assert_eq!(
895 listed_team["inputSchema"]["properties"]["action"]["enum"],
896 json!(["list", "get", "list_members", "list_child_teams", "list_repos", "list_user_teams"])
897 );
898 assert_eq!(listed_team["annotations"]["readOnlyHint"], true);
899 // A team's role on a repository is who has access.
900 let admin = token(Some(vec![Scope::WorkspaceAdmin]));
901 let tools = listed(&Gate::Token(&admin));
902 let listed_team = tools.iter().find(|tool| tool["name"] == "team").unwrap();
903 let actions = listed_team["inputSchema"]["properties"]["action"]["enum"].as_array().unwrap();
904 assert!(actions.contains(&json!("set_review_assignment")) && !actions.contains(&json!("set_repo")));
905 let access = token(Some(vec![Scope::AccessAdmin]));
906 let tools = listed(&Gate::Token(&access));
907 let listed_team = tools.iter().find(|tool| tool["name"] == "team").unwrap();
908 assert_eq!(listed_team["inputSchema"]["properties"]["action"]["enum"], json!(["set_repo", "remove_repo"]));
909 // Both kinds of role a schema names are offered.
910 let roles = &listed(&Gate::Everything).into_iter().find(|tool| tool["name"] == "team").unwrap()["inputSchema"]
911 ["properties"]["role"]["enum"];
912 for role in ["member", "maintainer", "read", "admin"] {
913 assert!(roles.as_array().unwrap().contains(&json!(role)), "{role}");
914 }
915 assert_eq!(
916 resolve(team, &json!({ "action": "set_repo", "workspace": "acme", "team": "backend", "repo": "rocket" })),
917 Err("team.set_repo needs role.".to_owned())
918 );
919 }
920
921 #[test]
922 fn reviewers_and_code_owners_are_actions_of_their_tools() {
923 let pull = Tool::by_name("pull_request").unwrap();
924 assert_eq!(
925 resolve(pull, &json!({ "action": "request_reviewers", "repo": "a/b", "number": 1, "team_reviewers": ["backend"] })),
926 Ok(Op::RequestReviewers)
927 );
928 assert_eq!(pull.action("remove_requested_reviewers").map(|action| action.op), Some(Op::RemoveRequestedReviewers));
929 let repository = Tool::by_name("repository").unwrap();
930 assert_eq!(resolve(repository, &json!({ "action": "codeowners", "repo": "a/b" })), Ok(Op::GetCodeownersErrors));
931 assert!(reads_only(Op::GetCodeownersErrors));
932 assert!(!reads_only(Op::RequestReviewers));
933 }
934
935 /// How much smaller `tools/list` is than one tool per operation. Run
936 /// with `--nocapture` to see the numbers.
937 #[test]
938 fn the_tool_list_is_much_smaller_than_one_tool_per_operation() {
939 let before: Vec<Value> = Op::ALL
940 .into_iter()
941 .map(|op| json!({ "name": op.name(), "description": op.description(), "inputSchema": op.input() }))
942 .collect();
943 let after = listed(&Gate::Everything);
944 let before_bytes = serde_json::to_string(&json!({ "tools": before })).unwrap().len();
945 let after_bytes = serde_json::to_string(&json!({ "tools": after })).unwrap().len();
946 let agent = token(Preset::Agent.scopes());
947 let agent_bytes = serde_json::to_string(&json!({ "tools": listed(&Gate::Token(&agent)) })).unwrap().len();
948 let read = token(Preset::ReadOnly.scopes());
949 let read_bytes = serde_json::to_string(&json!({ "tools": listed(&Gate::Token(&read)) })).unwrap().len();
950 println!(
951 "tools/list: before {} tools, {before_bytes} bytes (~{} tokens); after {} tools, {after_bytes} bytes (~{} tokens); agent preset {agent_bytes} bytes (~{} tokens); read only {read_bytes} bytes (~{} tokens)",
952 before.len(),
953 before_bytes / 4,
954 after.len(),
955 after_bytes / 4,
956 agent_bytes / 4,
957 read_bytes / 4,
958 );
959 assert!(after_bytes * 2 < before_bytes, "{after_bytes} vs {before_bytes}");
960 }
961}