Type Server Protocol (TSP) Overview

What is the Type Server Protocol?

The Type Server Protocol (TSP) is a specialized JSON-RPC protocol designed to facilitate communication between a type server and a client (such as an IDE). Unlike the Language Server Protocol (LSP), which is primarily intended for human-readable editor features like hover text and diagnostics, TSP provides structured, machine-readable type analysis data. This allows tools to programmatically consume type information—such as computed, declared, and expected types—without relying on fragile parsing of Markdown strings.

Why TSP Exists

Existing protocols like LSP are optimized for editor interaction rather than deep type-system integration. LSP's hover information is typically delivered as Markdown, which is excellent for display but difficult for automated refactoring tools, linters, or AI agents to parse reliably. TSP addresses this by returning structured, tagged type objects that represent the actual type graph, including classes, functions, unions, and modules. By standardizing this data, Microsoft aims to allow developers to swap out different type checkers (like Pylance or Pyrefly) while maintaining consistent behavior across various IDEs.

Core Architecture and Features

TSP functions as a companion to LSP, often running over the same connection. It introduces several key concepts to manage performance and state:

  • Snapshot-Based Analysis: A snapshot is a non-negative integer representing a point-in-time view of the workspace. Because type analysis is computationally expensive, results are bound to a specific snapshot. If a file changes, the server advances the snapshot, and the client must request updated information.
  • Multi-Connection Mode: To prevent high-volume type queries from blocking the main LSP connection, TSP supports optional secondary IPC channels. This allows for concurrent, read-only type queries while the main connection handles mutable workspace state and lifecycle events.
  • Capability Handshake: Clients and servers negotiate support for TSP features during the standard LSP initialization process, ensuring backward compatibility and graceful degradation if a server does not support the protocol.

Protocol Surface

TSP is intentionally lightweight, focusing on a small set of queries that provide deep insight into Python code:

  • typeServer/getComputedType: Returns the type inferred from code flow (e.g., after narrowing).
  • typeServer/getDeclaredType: Returns the type explicitly defined in the source code.
  • typeServer/getExpectedType: Returns the type required by the surrounding context.
  • typeServer/resolveImport: Provides resolution data for module imports.

Community Perspectives

The introduction of TSP has generated significant discussion regarding the fragmentation of the Python tooling ecosystem. While some developers appreciate the move toward structured data, others have raised concerns about the proliferation of Microsoft-led protocols.

"The real value of this protocol lies in moving from string-based information to structured data. LSP hover info is for humans; if a tool wants to use type info, it shouldn't have to guess the format. The key challenge is balancing the cost of computing full type graphs with the need for low-latency IDE responsiveness." — Hacker News user coindef

Critics have pointed out that the protocol is currently highly specific to Python's type system, leading to questions about whether it will remain a niche tool or evolve into a broader standard. Additionally, some maintainers of alternative Python tools, such as basedpyright, have expressed skepticism regarding the necessity of a separate protocol, while teams like Astral (the creators of Ruff) have indicated they intend to support it to ensure interoperability.

Sources

Related

  • Project
    chigwell/telegram-mcp

    Telegram MCP Server is a Python bridge that exposes Telegram operations (messaging, groups, contacts, media, voice transcription, etc.) as Model Context Protocol (MCP) tools, letting LLM agents like Claude or Cursor interact with Telegram accounts programmatically. It supports rich formatting, custom emoji, multi‑account setups, Docker deployment, and secure caching of voice‑to‑text transcripts.

  • Project
    unicity-sphere/sphere-sdk

    Sphere SDK is a modular TypeScript library for building apps that interact with Unicity wallets. It handles BIP‑39 key derivation, server‑side token custody, certified token transfers, payment requests, market intents, and Nostr‑based messaging. Developers compose a base provider (storage, Nostr transport, oracle) and a wallet‑API provider (the money rail), then initialise a `Sphere` instance to create or restore a wallet, send payments, receive transfers, and embed a wallet UI via the Connect protocol. The SDK is focused on web and Node.js environments and includes detailed error handling to avoid double‑spending.

  • Dispatch
    Jev-like Python Wrapper for LLMs and Vision Models Using Token Logprobs

    A single‑function Python wrapper lets you query LLMs (including multimodal models) for token‑level log probabilities, enabling fast, deterministic classification of webcam images.

  • Project
    openclaw/mcporter

    MCPorter is a TypeScript library and CLI that lets developers discover, call, and work with Model Context Protocol (MCP) servers. It provides commands for listing tools, invoking them, handling OAuth, generating typed clients or dedicated CLIs, and recording sessions. It also offers a runtime API (`createRuntime`, `callOnce`, `createServerProxy`) for programmatic use, supports multiple transport types (HTTP, stdio, SSE), and integrates with IDEs and Chrome DevTools via an OpenClaw relay.

  • Project
    TanStack/ai

    TanStack AI is a TypeScript‑first, provider‑agnostic SDK that lets you build streaming chat, tool‑calling agents, structured‑output flows, multimodal generation (image, audio, video), realtime voice, and sandboxed code‑execution agents. It offers composable activities, type‑safe contracts (via Zod/Valibot/JSON Schema), adapters for many LLM providers (OpenAI, Anthropic, Gemini, Ollama, etc.), and framework‑native hooks for React, Vue, Solid, Svelte, and Preact. Tree‑shakable and observable, it’s aimed at developers who want a unified, type‑safe way to integrate generative AI into web and server apps.