Skip to content
Sign in

flagon-io/g1t

public
0

g1t/apps/api/src/tools.rs

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