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