A note on this analysis. In March 2026, Claude Code's full TypeScript source was extracted from publicly available npm source maps. All code referenced here remains the intellectual property of Anthropic. This article is published for educational and research purposes. We do not host or distribute the source code. Our interest is narrow: understanding how a major AI coding agent treats the developer tool ecosystem, so that vendors building for this ecosystem can make informed decisions.
Claude Code's full TypeScript source leaked on GitHub in March 2026. We searched it for vendor names to see if any companies receive special handling. They do. We found hardcoded vendor references in seven different parts of the codebase:
Why does this matter?
Each system gives included providers a concrete advantage. Your MCP output renders cleanly while competitors dump raw JSON. Your docs are readable by the agent without user intervention. Your platform shows up by name in Anthropic's analytics. None of these change which tools Claude recommends. But they change how your product is treated in the terminal millions of developers use daily.
What we found: The collapse allowlist contains 495 typed entries across two Sets, which become 489 unique normalized tool names at runtime. The source comments organize them into 40 label blocks. classifyForCollapse.ts explicitly tags 6 claude.ai-hosted labels, while a separate main.tsx comment suggests Datadog may be an ambiguous seventh. WebFetch contains 89 preapproved host entries (88 unique host/path scopes). env.ts returns 29 explicit deployment labels before unknown fallbacks. The secret scanner ships 36 high-confidence rules across 23 credential families. The API logging layer fingerprints 7 gateways. The tip registry contains 2 plugin tips, only 1 for a third-party vendor.
1. MCP UI allowlist: 489 unique tool names across 40 grouped labels
This is the most explicit UI-specific integration layer in the leaked client. classifyForCollapse.ts contains two hardcoded Set objects, SEARCH_TOOLS and READ_TOOLS. There are 495 typed entries across those two literals, but because a few names repeat, the runtime allowlist resolves to 489 unique normalized tool names. When Claude Code calls a listed tool, the output collapses into a compact summary. When it calls an unlisted tool, you get the generic MCP renderer.
// classifyForCollapse.ts
function classifyMcpToolForCollapse(
_serverName: string, // ignored — tool names are stable
toolName: string,
): { isSearch: boolean; isRead: boolean } {
const normalized = normalize(toolName) // camelCase → snake_case
return {
isSearch: SEARCH_TOOLS.has(normalized),
isRead: READ_TOOLS.has(normalized),
}
}
// Unknown tools don't collapse (conservative default)The function keys on tool name alone, not server name. The source comment: “Tool names are stable across installs (even when the server name varies, e.g., ‘slack’ vs ‘claude_ai_Slack’).” Unknown tools do not collapse. The allowlist is opt-in, not opt-out.
The file comments group those tool names into 40 label blocks. That is not a clean vendor census: some labels explicitly combine multiple implementations, such as hosted + SDK Slack or hosted + community PubMed. The badge counts below are typed entries within each comment block, not globally unique tools.
Explicitly tagged claude.ai-hosted labels
These six labels are explicitly annotated as claude.ai-hosted inside classifyForCollapse.ts. The transport path itself goes through mcp-proxy.anthropic.com. Users connect through OAuth on claude.ai rather than local MCP configuration. More on the transport in section 2.

PubMed
24 entries
PubMed
24 entries

Slack
13 entries · hosted + SDK label
Slack
13 entries · hosted + SDK label

Gmail
6 tools
Gmail
6 tools

Google Calendar
6 tools
Google Calendar
6 tools

BigQuery
6 tools
BigQuery
6 tools

Google Drive
3 tools
Google Drive
3 tools
A separate comment in main.tsxalso lists Datadog among “claude.ai proxy servers.” Because classifyForCollapse.ts does not tag Datadog that way, we treat Datadog as an explicit source conflict rather than a confirmed hosted label.
Vendor-operated or vendor-associated labels
These are the larger vendor-operated or vendor-associated comment blocks in the file, sorted roughly by typed entry count.

GitHub
56 tools · github/github-mcp-server
GitHub
56 tools · github/github-mcp-server

Grafana
38 entries · grafana/mcp-grafana
Grafana
38 entries · grafana/mcp-grafana

Datadog
30 tools · mcp.datadoghq.com
Datadog
30 tools · mcp.datadoghq.com

Asana
29 tools · mcp.asana.com
Asana
29 tools · mcp.asana.com

PagerDuty
28 entries · PagerDuty/pagerduty-mcp-server
PagerDuty
28 entries · PagerDuty/pagerduty-mcp-server

Community Atlassian
20 entries · sooperset/mcp-atlassian
Community Atlassian
20 entries · sooperset/mcp-atlassian

Sentry
18 entries · getsentry/sentry-mcp
Sentry
18 entries · getsentry/sentry-mcp

Atlassian / Jira
17 entries · mcp.atlassian.com
Atlassian / Jira
17 entries · mcp.atlassian.com

Kubernetes
16 tools
Kubernetes
16 tools

Supabase
15 tools · supabase-community
Supabase
15 tools · supabase-community

Linear
16 entries · mcp.linear.app
Linear
16 entries · mcp.linear.app

Todoist
16 entries · Doist
Todoist
16 entries · Doist

MongoDB
13 entries
MongoDB
13 entries

AWS
13 entries · awslabs/mcp
AWS
13 entries · awslabs/mcp

Stripe
13 entries · stripe/agent-toolkit
Stripe
13 entries · stripe/agent-toolkit

Playwright
13 tools · microsoft
Playwright
13 tools · microsoft

Notion
5 tools · mcp.notion.com
Notion
5 tools · mcp.notion.com

Elasticsearch
4 tools · elastic
Elasticsearch
4 tools · elastic
MCP SDK reference labels
These ship under the @modelcontextprotocol namespace. Slack and Google Drive already appear above because the source comments join their hosted and SDK variants under one tool family.

Slack
13 entries · shared hosted + SDK label
Slack
13 entries · shared hosted + SDK label

Filesystem
10 tools · @mcp/server-filesystem
Filesystem
10 tools · @mcp/server-filesystem

Git
7 tools · mcp-server-git
Git
7 tools · mcp-server-git

Memory
3 tools · @mcp/server-memory
Memory
3 tools · @mcp/server-memory

Google Drive
3 tools · @mcp/server-gdrive
Google Drive
3 tools · @mcp/server-gdrive

SQLite
3 tools · @mcp/server-sqlite
SQLite
3 tools · @mcp/server-sqlite

Postgres
1 tool · @mcp/server-postgres
Postgres
1 tool · @mcp/server-postgres

Puppeteer
1 tool · @mcp/server-puppeteer
Puppeteer
1 tool · @mcp/server-puppeteer
Search & crawl labels
In the leaked build, the hardcoded search-provider labels are Exa, Firecrawl, Perplexity, Tavily, and Brave Search.

Exa
9 tools
Exa
9 tools

Firecrawl
6 tools
Firecrawl
6 tools

Perplexity
5 tools
Perplexity
5 tools

Tavily
5 tools
Tavily
5 tools

Brave Search
2 tools
Brave Search
2 tools
Other / community labels

Obsidian
9 tools · MarkusPfundstein
Obsidian
9 tools · MarkusPfundstein

Neo4j
5 tools
Neo4j
5 tools

Airtable
4 tools
Airtable
4 tools

Terraform
3 tools
Terraform
3 tools

Figma
2 tools · GLips/Figma-Context-MCP
Figma
2 tools · GLips/Figma-Context-MCP
Figma's entry is a community server, not an official Figma product. Atlassian is split into two distinct comment blocks (official and community), not one merged total. GitHub's 56 typed entries make it the largest single block in the file.
If you are included
Your tool output collapses into clean one-liners. In a multi-step debugging session, your results read as a narrative while unlisted competitors dump walls of raw JSON. That UX gap compounds over dozens of tool calls. Developers gravitate toward the tools that keep their terminal readable.
If you are not
Your MCP server still works. But the output is uncollapsed: every field, every nested object, rendered in full. Functional but visually noisy. Developers are more likely to disconnect a server that clutters their workflow.
2. claude.ai proxy connectors: 6 explicit labels, Datadog ambiguous
The leaked source directly shows a claude.ai-managed MCP path. It fetches org-configured connectors, converts them to transport type claudeai-proxy, and routes calls through a dedicated proxy at mcp-proxy.anthropic.com, rather than a user-managed local MCP process.
The architecture, visible across three source files:
// oauth.ts — proxy infrastructure
MCP_PROXY_URL: 'https://mcp-proxy.anthropic.com'
MCP_PROXY_PATH: '/v1/mcp/{server_id}'
// claudeai.ts — fetches org-configured servers
const url = `${baseUrl}/v1/mcp_servers?limit=1000`
// requires OAuth scope: 'user:mcp_servers'
// Each server becomes:
configs[name] = {
type: 'claudeai-proxy',
url: server.url,
id: server.id,
scope: 'claudeai',
}When a Claude.ai subscriber connects a claude.ai MCP connector, the flow is:
- User authenticates via OAuth on claude.ai with the scope user:mcp_servers
- Claude Code fetches the org's server list from api.anthropic.com/v1/mcp_servers
- Tool calls route through mcp-proxy.anthropic.com/v1/mcp/{server_id}
What the code proves: six label blocks in classifyForCollapse.ts are explicitly marked claude.ai-hosted: Slack, Gmail, Google Drive, Google Calendar, PubMed, and BigQuery. A separate main.tsx comment about skipping claude.ai proxy servers also lists Datadog. Because those two sources disagree, Datadog is ambiguous in the leaked build rather than counted as confirmed hosted.
Slack receives unusually specific treatment in the leaked build. Beyond the proxy transport, Claude Code has three Slack-specific code paths:
1. Compact UI rendering
trySlackSendCompact() in UI.tsx renders message sends as one-liners with #channel names and archive links instead of verbose JSON.
2. Custom OAuth error handling
Slack returns HTTP 200 for error responses, violating RFC 6749. Claude Code normalizes non-standard codes like invalid_refresh_token and token_expired to standard invalid_grant in auth.ts.
3. Deduplication logic
If both a local Slack MCP server and the Claude.ai-hosted version are configured, the local server takes precedence. Handled in config.ts.
PubMed is the outlier in the explicit hosted set. Its label covers 24 typed entries across hosted and community implementations. That does not prove Anthropic's selection criteria, but it does show the proxy path is not limited to workplace chat and calendar tools.
If you are included
Zero-config for users. OAuth managed by Anthropic, server fetched automatically, calls proxied through their infrastructure. No local MCP process, no API keys to rotate, no token refresh to debug. Users click “Connect” and it works. Only 6 vendors have this.
If you are not
Users must configure your MCP server locally: install a package, set environment variables, manage API keys, handle token refresh. Every step is a drop-off point. For enterprise teams, hosted servers win by default because they require no IT support.
3. WebFetch preapproval: 89 host entries, 88 unique scopes
Claude Code's WebFetch tool normally requires the user to provide a URL. But tools/WebFetchTool/preapproved.ts lists 89 preapproved host entries Claude Code can fetch on its own. That resolves to 88 unique host/path scopes because learn.microsoft.com appears twice, and some entries are path-scoped rather than whole-domain allowlists (for example github.com/anthropics and vercel.com/docs). This is a security allowlist for GET requests only. the source warns that it is deliberately not inherited by the sandbox system because some domains allow file uploads.
The list is broad and organized by category. The badges below normalize a few www. prefixes for readability, but the exact allowlist entries come from preapproved.ts.
Anthropic

Claude Platform
platform.claude.com
Claude Platform
platform.claude.com

Claude Code
code.claude.com
Claude Code
code.claude.com

MCP Protocol
modelcontextprotocol.io
MCP Protocol
modelcontextprotocol.io

Agent Skills
agentskills.io
Agent Skills
agentskills.io

Anthropic GitHub
github.com/anthropics
Anthropic GitHub
github.com/anthropics
Programming languages

Python
Python
C/C++

Java
Java
C# / .NET

MDN
MDN

Go
Go

Go Packages
Go Packages

PHP
PHP

Swift
Swift

Kotlin
Kotlin

Ruby
Ruby

Rust
Rust

TypeScript
TypeScript
Web frameworks & libraries

React
React

Angular
Angular

Vue.js
Vue.js

Next.js
Next.js

Express
Express

Node.js
Node.js

Bun
Bun

jQuery
jQuery

Bootstrap
Bootstrap

Tailwind
Tailwind

D3.js
D3.js

Three.js
Three.js

Redux
Redux

Webpack
Webpack

Jest
Jest

React Router
React Router
Python ecosystem

Django
Django

Flask
Flask

FastAPI
FastAPI

Pandas
Pandas

NumPy
NumPy

TensorFlow
TensorFlow

PyTorch
PyTorch

scikit-learn
scikit-learn

Matplotlib
Matplotlib

Requests
Requests

Jupyter
Jupyter
PHP, Java, .NET

Laravel
Laravel

Symfony
Symfony

WordPress
WordPress

Spring
Spring

Hibernate
Hibernate

Tomcat
Tomcat

Gradle
Gradle

Maven
Maven

ASP.NET
ASP.NET

.NET
.NET

NuGet
NuGet

Blazor
Blazor
Mobile

React Native
React Native

Flutter
Flutter

Apple Dev
Apple Dev

Android Dev
Android Dev
ML & data science

Keras
Keras

Spark
Spark

Hugging Face
Hugging Face

Kaggle
Kaggle
Databases

MongoDB
MongoDB

Redis
Redis

PostgreSQL
PostgreSQL

MySQL
MySQL

SQLite
SQLite

GraphQL
GraphQL

Prisma
Prisma
Cloud & DevOps

AWS
AWS

Google Cloud
Google Cloud

Azure
Azure

Kubernetes
Kubernetes

Docker
Docker

Terraform
Terraform

Ansible
Ansible

Vercel
Vercel

Netlify
Netlify

Heroku
Heroku
Testing, game dev, and other tools

Cypress
Cypress

Selenium
Selenium

Unity
Unity

Unreal
Unreal

Git
Git

Nginx
Nginx

Apache
Apache
If you are included
Claude Code can pull your docs on its own while reasoning about which tool to recommend. Your product is more legible to the agent during real-time decision-making. When Claude is comparing options, your documentation is one fetch away.
If you are not
Claude Code can still read your docs, but only when the user explicitly pastes a URL. The agent will not proactively visit your site to check compatibility or read your API reference. Your docs are less likely to be visited opportunistically. Your visibility depends on model memory and web search alone.
4. Deployment environment detection: 29 explicit labels
utils/env.ts returns 29 explicit deployment labels before falling back to unknown-darwin, unknown-linux, unknown-win32, or unknown. This is telemetry, not a user-facing feature.
Cloud dev environments

Codespaces
CODESPACES
Codespaces
CODESPACES

Gitpod
GITPOD_WORKSPACE_ID
Gitpod
GITPOD_WORKSPACE_ID

Replit
REPL_ID
Replit
REPL_ID

Glitch
PROJECT_DOMAIN
Glitch
PROJECT_DOMAIN
Cloud platforms

Vercel
VERCEL
Vercel
VERCEL

Railway
RAILWAY_ENVIRONMENT_NAME
Railway
RAILWAY_ENVIRONMENT_NAME

Render
RENDER
Render
RENDER

Netlify
NETLIFY
Netlify
NETLIFY

Heroku
DYNO
Heroku
DYNO

Fly.io
FLY_APP_NAME
Fly.io
FLY_APP_NAME

Cloudflare Pages
CF_PAGES
Cloudflare Pages
CF_PAGES

Deno Deploy
DENO_DEPLOYMENT_ID
Deno Deploy
DENO_DEPLOYMENT_ID

AWS Lambda
AWS_LAMBDA_FUNCTION_NAME
AWS Lambda
AWS_LAMBDA_FUNCTION_NAME

AWS Fargate
AWS_ECS_FARGATE
AWS Fargate
AWS_ECS_FARGATE

AWS ECS
AWS_ECS_EC2
AWS ECS
AWS_ECS_EC2

AWS EC2
/sys/hypervisor/uuid
AWS EC2
/sys/hypervisor/uuid

GCP Cloud Run
K_SERVICE
GCP Cloud Run
K_SERVICE

GCP
GOOGLE_CLOUD_PROJECT
GCP
GOOGLE_CLOUD_PROJECT

Azure App Service
WEBSITE_SITE_NAME
Azure App Service
WEBSITE_SITE_NAME

Azure Functions
AZURE_FUNCTIONS_ENVIRONMENT
Azure Functions
AZURE_FUNCTIONS_ENVIRONMENT

DigitalOcean
ondigitalocean.app
DigitalOcean
ondigitalocean.app

Hugging Face Spaces
SPACE_CREATOR_USER_ID
Hugging Face Spaces
SPACE_CREATOR_USER_ID
CI/CD

GitHub Actions
GITHUB_ACTIONS
GitHub Actions
GITHUB_ACTIONS

GitLab CI
GITLAB_CI
GitLab CI
GITLAB_CI

CircleCI
CIRCLECI
CircleCI
CIRCLECI

Buildkite
BUILDKITE
Buildkite
BUILDKITE
Generic CI
CI
Container / orchestration

Kubernetes
KUBERNETES_SERVICE_HOST
Kubernetes
KUBERNETES_SERVICE_HOST

Docker
/.dockerenv
Docker
/.dockerenv
If you are included
Anthropic knows how many Claude Code sessions run on your platform. That data could shape future integration priorities. If 40% of sessions run on your infra, that is a strong argument for deeper partnership. Detection is not a feature for users. It is a signal that feeds Anthropic's product roadmap.
If you are not
Your usage shows up as “unknown-linux” in Anthropic's telemetry. You are invisible in the data that could drive their partnership and integration roadmap. If you want Anthropic to invest in your platform, they first need to see you in their numbers.
5. Secret scanner: 36 rules across 23 credential families
services/teamMemorySync/secretScanner.ts scans content client-side before upload to keep secrets out of team memory. The file says it uses a curated subset of high-confidence Gitleaks rules. In the leaked build that is 36 explicit rules, including multi-rule vendors and a private-key catchall.
The badges below show representative credential families covered by the rules. They are not a one-rule-per-vendor list.

AWS
AKIA / aws_secret
AWS
AKIA / aws_secret

GCP
service account JSON
GCP
service account JSON

Azure
client secret
Azure
client secret

Anthropic
sk-ant-*
Anthropic
sk-ant-*

OpenAI
sk-* key
OpenAI
sk-* key

Hugging Face
hf_* token
Hugging Face
hf_* token

GitHub
ghp_ / gho_ / ghs_
GitHub
ghp_ / gho_ / ghs_

GitLab
glpat-* / deploy token
GitLab
glpat-* / deploy token

Slack
xoxb- / xoxp-
Slack
xoxb- / xoxp-

Twilio
auth token
Twilio
auth token

SendGrid
SG.* key
SendGrid
SG.* key

Stripe
sk_live / sk_test
Stripe
sk_live / sk_test

Shopify
shpat_ / shpca_
Shopify
shpat_ / shpca_

NPM
npm_* token
NPM
npm_* token

PyPI
pypi-* token
PyPI
pypi-* token

Databricks
dapi* token
Databricks
dapi* token

Terraform
atlasv1.* token
Terraform
atlasv1.* token

Pulumi
pul-* token
Pulumi
pul-* token

Postman
PMAK-* key
Postman
PMAK-* key

Grafana
glsa_ / glc_ token
Grafana
glsa_ / glc_ token

Sentry
sntrys_ DSN
Sentry
sntrys_ DSN

DigitalOcean
dop_v1_ / doo_v1_
DigitalOcean
dop_v1_ / doo_v1_

HashiCorp TF
atlasv1.* token
HashiCorp TF
atlasv1.* token

Private Key
BEGIN PRIVATE KEY
Private Key
BEGIN PRIVATE KEY
If you are included
Claude Code actively prevents your API keys from leaking into team memory. A safety feature, not a partnership, but it means Anthropic considers your credentials common enough to warrant dedicated regex patterns. Your users are protected by default.
If you are not
Your API keys could end up in team memory if a developer accidentally shares them. Generic detection may still catch them, but there is no vendor-specific regex for your key format. Actionable tip: if your keys have a distinctive prefix, submit a pattern to the public Gitleaks rule set. Claude Code's scanner derives from it, so accepted rules flow downstream.
6. API gateway detection: 7 gateways
services/api/logging.ts detects third-party AI API gateways via response headers or hostnames. Purely observational for analytics. no behavior change.

LiteLLM
LiteLLM

Helicone
Helicone

Portkey
Portkey

Cloudflare AI
cf-aig-* headers
Cloudflare AI
cf-aig-* headers

Kong
Kong

Braintrust
Braintrust

Databricks
Databricks
If you are included
Anthropic can see how much traffic flows through your proxy. That visibility matters for pricing, rate-limiting, and partnership conversations. If a large share of traffic routes through your gateway, you have leverage.
If you are not
Your proxy traffic is invisible to Anthropic's analytics. You can operate without scrutiny, but you also have no visibility signal when Anthropic evaluates which gateways to formally support. Being known is the prerequisite for partnership conversations.
7. Plugin tips and special integrations
tipRegistry.ts contains two plugin tips. contextual suggestions to install official plugins from claude-plugins-official:
Vercel
triggered by vercel.json / vercel CLI
Frontend Design
triggered by .html / .css files
Vercel is the only third-party vendor with a dedicated plugin tip. When Claude Code detects a vercel.json or the vercel CLI, it suggests /plugin install vercel@claude-plugins-official. The other tip is Anthropic's own frontend-design plugin, triggered by HTML and CSS files.
Anthropic also maintains a commercial MCP registry at api.anthropic.com/mcp-registry/v0/servers. Servers on this registry have their tool names logged for analytics (rather than being redacted as PII). In practice,inclusion on this registry likely acts as a trust or approval signal.
And Claude Code supports two MCP extension metadata fields any server can use: anthropic/alwaysLoad (tool appears in prompt without deferred loading) and anthropic/searchHint (custom description for tool discovery). These are available to everyone; In practice,servers that populate them are easier for Claude Code to surface and describe cleanly.
If you are included
Claude Code proactively suggests your plugin when it detects relevant project signals. You are part of the install flow, not something the developer has to discover. Vercel is the only third-party vendor with this treatment today. Your tool is recommended before the developer even starts working.
If you are not
Your plugin must be manually discovered and installed. Claude Code will never suggest it. The developer must already know about you, find your server on npm or GitHub, and configure it themselves. Anthropic controls who gets a tip.
8. The complete vendor map
Vendors that appear in at least two systems. The Hosted column marks only explicitly tagged claude.ai-hosted labels; Datadog's hosting ambiguity is noted below instead of encoded as a yes/no.
| Vendor | MCP UIMCP | HostedHost | FetchFtch | Env | SecretsSec | OtherOth |
|---|---|---|---|---|---|---|
| • | – | • | • | • | ||
| • | – | – | • | • | ||
| • | • | – | – | • | ||
| • | • | • | • | • | ||
| • | – | – | – | • | ||
| • | – | – | – | • | ||
| • | – | – | – | • | ||
| • | – | • | – | • | ||
| • | – | • | • | – | ||
| • | – | • | – | – | ||
| – | – | – | – | • | gateway | |
| – | – | • | • | – | plugin | |
| – | – | • | • | – | ||
| – | – | • | • | – | ||
| – | – | • | • | – | ||
| – | – | – | • | • | ||
| – | – | – | • | • | ||
| – | – | – | • | – | gateway | |
| – | – | • | • | • | ||
| – | – | – | – | • | ||
| – | – | – | – | • | ||
| – | – | – | – | • | ||
| – | – | – | – | • | ||
| – | – | – | – | • | ||
| – | – | – | – | • |
Showing vendors that appear in 2+ systems. Datadog is omitted here because the leaked build contains a hosted-connector conflict rather than a clean second confirmed system.
9. Conclusion
AI coding agents are becoming real distribution infrastructure. The vendors hardcoded in Claude Code today have a head start that compounds with every session: cleaner output, easier onboarding, docs the agent can read on its own, visibility in telemetry. These advantages are small individually but they stack.
The MCP allowlist is entirely manual. Someone typed each tool name into a Set object by hand. That does not scale. Either Anthropic moves to convention-based classification, or the current list hardens into a de facto ranking of which integrations they consider worth maintaining. For vendors not yet on it, the window to get added narrows as the file grows.
Vercel shows there is more than one path in. It has no MCP UI support but it has a plugin tip, preapproved docs, and environment detection. Different distribution channel, same destination: being recognized by name inside the product.
If you ship developer tools, the question is no longer whether your product works with Claude Code. It is whether Claude Code knows your product exists.
Where does your tool show up?
If you ship developer tools and want to understand your position in the AI agent stack, we can help.