diff --git a/crates/collab/src/rpc.rs b/crates/collab/src/rpc.rs
index e19c59f9974f243a585b02baac8d87dc82e0d405..873aee54737966cb4761ca58d9b7a47b12177b50 100644
--- a/crates/collab/src/rpc.rs
+++ b/crates/collab/src/rpc.rs
@@ -33,7 +33,7 @@ pub use connection_pool::{ConnectionPool, ZedVersion};
 use core::fmt::{self, Debug, Formatter};
 use futures::TryFutureExt as _;
 use reqwest_client::ReqwestClient;
-use rpc::proto::{MultiLspQuery, split_repository_update};
+use rpc::proto::split_repository_update;
 use supermaven_api::{CreateExternalUserRequest, SupermavenAdminApi};
 use tracing::Span;
 
@@ -335,10 +335,6 @@ impl Server {
             .add_message_handler(update_language_server)
             .add_message_handler(update_diagnostic_summary)
             .add_message_handler(update_worktree_settings)
-            .add_request_handler(forward_read_only_project_request::<proto::GetHover>)
-            .add_request_handler(forward_read_only_project_request::<proto::GetDefinition>)
-            .add_request_handler(forward_read_only_project_request::<proto::GetTypeDefinition>)
-            .add_request_handler(forward_read_only_project_request::<proto::GetReferences>)
             .add_request_handler(forward_read_only_project_request::<proto::FindSearchCandidates>)
             .add_request_handler(forward_read_only_project_request::<proto::GetDocumentHighlights>)
             .add_request_handler(forward_read_only_project_request::<proto::GetDocumentSymbols>)
@@ -349,7 +345,6 @@ impl Server {
             .add_request_handler(forward_read_only_project_request::<proto::InlayHints>)
             .add_request_handler(forward_read_only_project_request::<proto::ResolveInlayHint>)
             .add_request_handler(forward_read_only_project_request::<proto::GetColorPresentation>)
-            .add_request_handler(forward_mutating_project_request::<proto::GetCodeLens>)
             .add_request_handler(forward_read_only_project_request::<proto::OpenBufferByPath>)
             .add_request_handler(forward_read_only_project_request::<proto::GitGetBranches>)
             .add_request_handler(forward_read_only_project_request::<proto::OpenUnstagedDiff>)
@@ -364,7 +359,6 @@ impl Server {
             .add_request_handler(forward_read_only_project_request::<proto::LspExtCancelFlycheck>)
             .add_request_handler(forward_read_only_project_request::<proto::LspExtRunFlycheck>)
             .add_request_handler(forward_read_only_project_request::<proto::LspExtClearFlycheck>)
-            .add_request_handler(forward_read_only_project_request::<proto::GetDocumentDiagnostics>)
             .add_request_handler(
                 forward_mutating_project_request::<proto::RegisterBufferWithLanguageServers>,
             )
@@ -377,7 +371,6 @@ impl Server {
             .add_request_handler(
                 forward_mutating_project_request::<proto::ResolveCompletionDocumentation>,
             )
-            .add_request_handler(forward_mutating_project_request::<proto::GetCodeActions>)
             .add_request_handler(forward_mutating_project_request::<proto::ApplyCodeAction>)
             .add_request_handler(forward_mutating_project_request::<proto::PrepareRename>)
             .add_request_handler(forward_mutating_project_request::<proto::PerformRename>)
@@ -395,7 +388,6 @@ impl Server {
             .add_request_handler(forward_mutating_project_request::<proto::OnTypeFormatting>)
             .add_request_handler(forward_mutating_project_request::<proto::SaveBuffer>)
             .add_request_handler(forward_mutating_project_request::<proto::BlameBuffer>)
-            .add_request_handler(multi_lsp_query)
             .add_request_handler(lsp_query)
             .add_message_handler(broadcast_project_message_from_host::<proto::LspQueryResponse>)
             .add_request_handler(forward_mutating_project_request::<proto::RestartLanguageServers>)
@@ -910,8 +902,6 @@ impl Server {
                                 user_id=field::Empty,
                                 login=field::Empty,
                                 impersonator=field::Empty,
-                                // todo(lsp) remove after Zed Stable hits v0.204.x
-                                multi_lsp_query_request=field::Empty,
                                 lsp_query_request=field::Empty,
                                 release_channel=field::Empty,
                                 { TOTAL_DURATION_MS }=field::Empty,
@@ -2358,17 +2348,6 @@ where
     Ok(())
 }
 
-// todo(lsp) remove after Zed Stable hits v0.204.x
-async fn multi_lsp_query(
-    request: MultiLspQuery,
-    response: Response<MultiLspQuery>,
-    session: MessageContext,
-) -> Result<()> {
-    tracing::Span::current().record("multi_lsp_query_request", request.request_str());
-    tracing::info!("multi_lsp_query message received");
-    forward_mutating_project_request(request, response, session).await
-}
-
 async fn lsp_query(
     request: proto::LspQuery,
     response: Response<proto::LspQuery>,
diff --git a/crates/project/src/lsp_store.rs b/crates/project/src/lsp_store.rs
index 7430aa016f029ef61186a1a02b4fb91fa67a1b1a..1ba5dc4f9001d577c9d4987bb7d01db117ded80b 100644
--- a/crates/project/src/lsp_store.rs
+++ b/crates/project/src/lsp_store.rs
@@ -3586,7 +3586,6 @@ impl LspStore {
     pub fn init(client: &AnyProtoClient) {
         client.add_entity_request_handler(Self::handle_lsp_query);
         client.add_entity_message_handler(Self::handle_lsp_query_response);
-        client.add_entity_request_handler(Self::handle_multi_lsp_query);
         client.add_entity_request_handler(Self::handle_restart_language_servers);
         client.add_entity_request_handler(Self::handle_stop_language_servers);
         client.add_entity_request_handler(Self::handle_cancel_language_server_work);
@@ -3610,9 +3609,7 @@ impl LspStore {
         client.add_entity_request_handler(Self::handle_register_buffer_with_language_servers);
         client.add_entity_request_handler(Self::handle_rename_project_entry);
         client.add_entity_request_handler(Self::handle_pull_workspace_diagnostics);
-        client.add_entity_request_handler(Self::handle_lsp_command::<GetCodeActions>);
         client.add_entity_request_handler(Self::handle_lsp_command::<GetCompletions>);
-        client.add_entity_request_handler(Self::handle_lsp_command::<GetHover>);
         client.add_entity_request_handler(Self::handle_lsp_command::<GetDocumentHighlights>);
         client.add_entity_request_handler(Self::handle_lsp_command::<GetDocumentSymbols>);
         client.add_entity_request_handler(Self::handle_lsp_command::<PrepareRename>);
@@ -3633,7 +3630,6 @@ impl LspStore {
         client.add_entity_request_handler(
             Self::handle_lsp_command::<lsp_ext_command::SwitchSourceHeader>,
         );
-        client.add_entity_request_handler(Self::handle_lsp_command::<GetDocumentDiagnostics>);
     }
 
     pub fn as_remote(&self) -> Option<&RemoteLspStore> {
@@ -8269,473 +8265,6 @@ impl LspStore {
         Ok(())
     }
 
-    // todo(lsp) remove after Zed Stable hits v0.204.x
-    async fn handle_multi_lsp_query(
-        lsp_store: Entity<Self>,
-        envelope: TypedEnvelope<proto::MultiLspQuery>,
-        mut cx: AsyncApp,
-    ) -> Result<proto::MultiLspQueryResponse> {
-        let response_from_ssh = lsp_store.read_with(&cx, |this, _| {
-            let (upstream_client, project_id) = this.upstream_client()?;
-            let mut payload = envelope.payload.clone();
-            payload.project_id = project_id;
-
-            Some(upstream_client.request(payload))
-        })?;
-        if let Some(response_from_ssh) = response_from_ssh {
-            return response_from_ssh.await;
-        }
-
-        let sender_id = envelope.original_sender_id().unwrap_or_default();
-        let buffer_id = BufferId::new(envelope.payload.buffer_id)?;
-        let version = deserialize_version(&envelope.payload.version);
-        let buffer = lsp_store.update(&mut cx, |this, cx| {
-            this.buffer_store.read(cx).get_existing(buffer_id)
-        })??;
-        buffer
-            .update(&mut cx, |buffer, _| {
-                buffer.wait_for_version(version.clone())
-            })?
-            .await?;
-        let buffer_version = buffer.read_with(&cx, |buffer, _| buffer.version())?;
-        match envelope
-            .payload
-            .strategy
-            .context("invalid request without the strategy")?
-        {
-            proto::multi_lsp_query::Strategy::All(_) => {
-                // currently, there's only one multiple language servers query strategy,
-                // so just ensure it's specified correctly
-            }
-        }
-        match envelope.payload.request {
-            Some(proto::multi_lsp_query::Request::GetHover(message)) => {
-                buffer
-                    .update(&mut cx, |buffer, _| {
-                        buffer.wait_for_version(deserialize_version(&message.version))
-                    })?
-                    .await?;
-                let get_hover =
-                    GetHover::from_proto(message, lsp_store.clone(), buffer.clone(), cx.clone())
-                        .await?;
-                let all_hovers = lsp_store
-                    .update(&mut cx, |this, cx| {
-                        this.request_multiple_lsp_locally(
-                            &buffer,
-                            Some(get_hover.position),
-                            get_hover,
-                            cx,
-                        )
-                    })?
-                    .await
-                    .into_iter()
-                    .filter_map(|(server_id, hover)| {
-                        Some((server_id, remove_empty_hover_blocks(hover?)?))
-                    });
-                lsp_store.update(&mut cx, |project, cx| proto::MultiLspQueryResponse {
-                    responses: all_hovers
-                        .map(|(server_id, hover)| proto::LspResponse {
-                            server_id: server_id.to_proto(),
-                            response: Some(proto::lsp_response::Response::GetHoverResponse(
-                                GetHover::response_to_proto(
-                                    Some(hover),
-                                    project,
-                                    sender_id,
-                                    &buffer_version,
-                                    cx,
-                                ),
-                            )),
-                        })
-                        .collect(),
-                })
-            }
-            Some(proto::multi_lsp_query::Request::GetCodeActions(message)) => {
-                buffer
-                    .update(&mut cx, |buffer, _| {
-                        buffer.wait_for_version(deserialize_version(&message.version))
-                    })?
-                    .await?;
-                let get_code_actions = GetCodeActions::from_proto(
-                    message,
-                    lsp_store.clone(),
-                    buffer.clone(),
-                    cx.clone(),
-                )
-                .await?;
-
-                let all_actions = lsp_store
-                    .update(&mut cx, |project, cx| {
-                        project.request_multiple_lsp_locally(
-                            &buffer,
-                            Some(get_code_actions.range.start),
-                            get_code_actions,
-                            cx,
-                        )
-                    })?
-                    .await
-                    .into_iter();
-
-                lsp_store.update(&mut cx, |project, cx| proto::MultiLspQueryResponse {
-                    responses: all_actions
-                        .map(|(server_id, code_actions)| proto::LspResponse {
-                            server_id: server_id.to_proto(),
-                            response: Some(proto::lsp_response::Response::GetCodeActionsResponse(
-                                GetCodeActions::response_to_proto(
-                                    code_actions,
-                                    project,
-                                    sender_id,
-                                    &buffer_version,
-                                    cx,
-                                ),
-                            )),
-                        })
-                        .collect(),
-                })
-            }
-            Some(proto::multi_lsp_query::Request::GetSignatureHelp(message)) => {
-                buffer
-                    .update(&mut cx, |buffer, _| {
-                        buffer.wait_for_version(deserialize_version(&message.version))
-                    })?
-                    .await?;
-                let get_signature_help = GetSignatureHelp::from_proto(
-                    message,
-                    lsp_store.clone(),
-                    buffer.clone(),
-                    cx.clone(),
-                )
-                .await?;
-
-                let all_signatures = lsp_store
-                    .update(&mut cx, |project, cx| {
-                        project.request_multiple_lsp_locally(
-                            &buffer,
-                            Some(get_signature_help.position),
-                            get_signature_help,
-                            cx,
-                        )
-                    })?
-                    .await
-                    .into_iter();
-
-                lsp_store.update(&mut cx, |project, cx| proto::MultiLspQueryResponse {
-                    responses: all_signatures
-                        .map(|(server_id, signature_help)| proto::LspResponse {
-                            server_id: server_id.to_proto(),
-                            response: Some(
-                                proto::lsp_response::Response::GetSignatureHelpResponse(
-                                    GetSignatureHelp::response_to_proto(
-                                        signature_help,
-                                        project,
-                                        sender_id,
-                                        &buffer_version,
-                                        cx,
-                                    ),
-                                ),
-                            ),
-                        })
-                        .collect(),
-                })
-            }
-            Some(proto::multi_lsp_query::Request::GetCodeLens(message)) => {
-                buffer
-                    .update(&mut cx, |buffer, _| {
-                        buffer.wait_for_version(deserialize_version(&message.version))
-                    })?
-                    .await?;
-                let get_code_lens =
-                    GetCodeLens::from_proto(message, lsp_store.clone(), buffer.clone(), cx.clone())
-                        .await?;
-
-                let code_lens_actions = lsp_store
-                    .update(&mut cx, |project, cx| {
-                        project.request_multiple_lsp_locally(
-                            &buffer,
-                            None::<usize>,
-                            get_code_lens,
-                            cx,
-                        )
-                    })?
-                    .await
-                    .into_iter();
-
-                lsp_store.update(&mut cx, |project, cx| proto::MultiLspQueryResponse {
-                    responses: code_lens_actions
-                        .map(|(server_id, actions)| proto::LspResponse {
-                            server_id: server_id.to_proto(),
-                            response: Some(proto::lsp_response::Response::GetCodeLensResponse(
-                                GetCodeLens::response_to_proto(
-                                    actions,
-                                    project,
-                                    sender_id,
-                                    &buffer_version,
-                                    cx,
-                                ),
-                            )),
-                        })
-                        .collect(),
-                })
-            }
-            Some(proto::multi_lsp_query::Request::GetDocumentDiagnostics(message)) => {
-                buffer
-                    .update(&mut cx, |buffer, _| {
-                        buffer.wait_for_version(deserialize_version(&message.version))
-                    })?
-                    .await?;
-                lsp_store
-                    .update(&mut cx, |lsp_store, cx| {
-                        lsp_store.pull_diagnostics_for_buffer(buffer, cx)
-                    })?
-                    .await?;
-                // `pull_diagnostics_for_buffer` will merge in the new diagnostics and send them to the client.
-                // The client cannot merge anything into its non-local LspStore, so we do not need to return anything.
-                Ok(proto::MultiLspQueryResponse {
-                    responses: Vec::new(),
-                })
-            }
-            Some(proto::multi_lsp_query::Request::GetDocumentColor(message)) => {
-                buffer
-                    .update(&mut cx, |buffer, _| {
-                        buffer.wait_for_version(deserialize_version(&message.version))
-                    })?
-                    .await?;
-                let get_document_color = GetDocumentColor::from_proto(
-                    message,
-                    lsp_store.clone(),
-                    buffer.clone(),
-                    cx.clone(),
-                )
-                .await?;
-
-                let all_colors = lsp_store
-                    .update(&mut cx, |project, cx| {
-                        project.request_multiple_lsp_locally(
-                            &buffer,
-                            None::<usize>,
-                            get_document_color,
-                            cx,
-                        )
-                    })?
-                    .await
-                    .into_iter();
-
-                lsp_store.update(&mut cx, |project, cx| proto::MultiLspQueryResponse {
-                    responses: all_colors
-                        .map(|(server_id, colors)| proto::LspResponse {
-                            server_id: server_id.to_proto(),
-                            response: Some(
-                                proto::lsp_response::Response::GetDocumentColorResponse(
-                                    GetDocumentColor::response_to_proto(
-                                        colors,
-                                        project,
-                                        sender_id,
-                                        &buffer_version,
-                                        cx,
-                                    ),
-                                ),
-                            ),
-                        })
-                        .collect(),
-                })
-            }
-            Some(proto::multi_lsp_query::Request::GetDefinition(message)) => {
-                let get_definitions = GetDefinitions::from_proto(
-                    message,
-                    lsp_store.clone(),
-                    buffer.clone(),
-                    cx.clone(),
-                )
-                .await?;
-
-                let definitions = lsp_store
-                    .update(&mut cx, |project, cx| {
-                        project.request_multiple_lsp_locally(
-                            &buffer,
-                            Some(get_definitions.position),
-                            get_definitions,
-                            cx,
-                        )
-                    })?
-                    .await
-                    .into_iter();
-
-                lsp_store.update(&mut cx, |project, cx| proto::MultiLspQueryResponse {
-                    responses: definitions
-                        .map(|(server_id, definitions)| proto::LspResponse {
-                            server_id: server_id.to_proto(),
-                            response: Some(proto::lsp_response::Response::GetDefinitionResponse(
-                                GetDefinitions::response_to_proto(
-                                    definitions,
-                                    project,
-                                    sender_id,
-                                    &buffer_version,
-                                    cx,
-                                ),
-                            )),
-                        })
-                        .collect(),
-                })
-            }
-            Some(proto::multi_lsp_query::Request::GetDeclaration(message)) => {
-                let get_declarations = GetDeclarations::from_proto(
-                    message,
-                    lsp_store.clone(),
-                    buffer.clone(),
-                    cx.clone(),
-                )
-                .await?;
-
-                let declarations = lsp_store
-                    .update(&mut cx, |project, cx| {
-                        project.request_multiple_lsp_locally(
-                            &buffer,
-                            Some(get_declarations.position),
-                            get_declarations,
-                            cx,
-                        )
-                    })?
-                    .await
-                    .into_iter();
-
-                lsp_store.update(&mut cx, |project, cx| proto::MultiLspQueryResponse {
-                    responses: declarations
-                        .map(|(server_id, declarations)| proto::LspResponse {
-                            server_id: server_id.to_proto(),
-                            response: Some(proto::lsp_response::Response::GetDeclarationResponse(
-                                GetDeclarations::response_to_proto(
-                                    declarations,
-                                    project,
-                                    sender_id,
-                                    &buffer_version,
-                                    cx,
-                                ),
-                            )),
-                        })
-                        .collect(),
-                })
-            }
-            Some(proto::multi_lsp_query::Request::GetTypeDefinition(message)) => {
-                let get_type_definitions = GetTypeDefinitions::from_proto(
-                    message,
-                    lsp_store.clone(),
-                    buffer.clone(),
-                    cx.clone(),
-                )
-                .await?;
-
-                let type_definitions = lsp_store
-                    .update(&mut cx, |project, cx| {
-                        project.request_multiple_lsp_locally(
-                            &buffer,
-                            Some(get_type_definitions.position),
-                            get_type_definitions,
-                            cx,
-                        )
-                    })?
-                    .await
-                    .into_iter();
-
-                lsp_store.update(&mut cx, |project, cx| proto::MultiLspQueryResponse {
-                    responses: type_definitions
-                        .map(|(server_id, type_definitions)| proto::LspResponse {
-                            server_id: server_id.to_proto(),
-                            response: Some(
-                                proto::lsp_response::Response::GetTypeDefinitionResponse(
-                                    GetTypeDefinitions::response_to_proto(
-                                        type_definitions,
-                                        project,
-                                        sender_id,
-                                        &buffer_version,
-                                        cx,
-                                    ),
-                                ),
-                            ),
-                        })
-                        .collect(),
-                })
-            }
-            Some(proto::multi_lsp_query::Request::GetImplementation(message)) => {
-                let get_implementations = GetImplementations::from_proto(
-                    message,
-                    lsp_store.clone(),
-                    buffer.clone(),
-                    cx.clone(),
-                )
-                .await?;
-
-                let implementations = lsp_store
-                    .update(&mut cx, |project, cx| {
-                        project.request_multiple_lsp_locally(
-                            &buffer,
-                            Some(get_implementations.position),
-                            get_implementations,
-                            cx,
-                        )
-                    })?
-                    .await
-                    .into_iter();
-
-                lsp_store.update(&mut cx, |project, cx| proto::MultiLspQueryResponse {
-                    responses: implementations
-                        .map(|(server_id, implementations)| proto::LspResponse {
-                            server_id: server_id.to_proto(),
-                            response: Some(
-                                proto::lsp_response::Response::GetImplementationResponse(
-                                    GetImplementations::response_to_proto(
-                                        implementations,
-                                        project,
-                                        sender_id,
-                                        &buffer_version,
-                                        cx,
-                                    ),
-                                ),
-                            ),
-                        })
-                        .collect(),
-                })
-            }
-            Some(proto::multi_lsp_query::Request::GetReferences(message)) => {
-                let get_references = GetReferences::from_proto(
-                    message,
-                    lsp_store.clone(),
-                    buffer.clone(),
-                    cx.clone(),
-                )
-                .await?;
-
-                let references = lsp_store
-                    .update(&mut cx, |project, cx| {
-                        project.request_multiple_lsp_locally(
-                            &buffer,
-                            Some(get_references.position),
-                            get_references,
-                            cx,
-                        )
-                    })?
-                    .await
-                    .into_iter();
-
-                lsp_store.update(&mut cx, |project, cx| proto::MultiLspQueryResponse {
-                    responses: references
-                        .map(|(server_id, references)| proto::LspResponse {
-                            server_id: server_id.to_proto(),
-                            response: Some(proto::lsp_response::Response::GetReferencesResponse(
-                                GetReferences::response_to_proto(
-                                    references,
-                                    project,
-                                    sender_id,
-                                    &buffer_version,
-                                    cx,
-                                ),
-                            )),
-                        })
-                        .collect(),
-                })
-            }
-            None => anyhow::bail!("empty multi lsp query request"),
-        }
-    }
-
     async fn handle_apply_code_action(
         this: Entity<Self>,
         envelope: TypedEnvelope<proto::ApplyCodeAction>,
diff --git a/crates/proto/proto/lsp.proto b/crates/proto/proto/lsp.proto
index 16f6217b29d50a4a2eb9198565f688335c218802..d50c1924cdf237d603b78062b3335354a6d6127f 100644
--- a/crates/proto/proto/lsp.proto
+++ b/crates/proto/proto/lsp.proto
@@ -931,33 +931,6 @@ message PullWorkspaceDiagnostics {
     uint64 server_id = 2;
 }
 
-// todo(lsp) remove after Zed Stable hits v0.204.x
-message MultiLspQuery {
-    uint64 project_id = 1;
-    uint64 buffer_id = 2;
-    repeated VectorClockEntry version = 3;
-    oneof strategy {
-        AllLanguageServers all = 4;
-    }
-    oneof request {
-        GetHover get_hover = 5;
-        GetCodeActions get_code_actions = 6;
-        GetSignatureHelp get_signature_help = 7;
-        GetCodeLens get_code_lens = 8;
-        GetDocumentDiagnostics get_document_diagnostics = 9;
-        GetDocumentColor get_document_color = 10;
-        GetDefinition get_definition = 11;
-        GetDeclaration get_declaration = 12;
-        GetTypeDefinition get_type_definition = 13;
-        GetImplementation get_implementation = 14;
-        GetReferences get_references = 15;
-    }
-}
-
-message MultiLspQueryResponse {
-    repeated LspResponse responses = 1;
-}
-
 message ToggleLspLogs {
     uint64 project_id = 1;
     LogType log_type = 2;
diff --git a/crates/proto/proto/zed.proto b/crates/proto/proto/zed.proto
index 3286b9e752597a56cf39f24557a869a3f6fb5ffe..7fdf108e122c705b0779bb5e20cf62460820bd3e 100644
--- a/crates/proto/proto/zed.proto
+++ b/crates/proto/proto/zed.proto
@@ -210,8 +210,6 @@ message Envelope {
 
         UpdateNotification update_notification = 174;
 
-        MultiLspQuery multi_lsp_query = 175;
-        MultiLspQueryResponse multi_lsp_query_response = 176;
         RestartLanguageServers restart_language_servers = 208;
 
         RejoinRemoteProjects rejoin_remote_projects = 186;
@@ -421,7 +419,7 @@ message Envelope {
     reserved 158 to 161;
     reserved 164;
     reserved 166 to 169;
-    reserved 177 to 185;
+    reserved 175 to 185;
     reserved 188;
     reserved 189 to 192;
     reserved 193 to 195;
diff --git a/crates/proto/src/proto.rs b/crates/proto/src/proto.rs
index 79e6b414ef516372eca3ec06b72de507ee2b8711..16bd86146c4bfb49ccf3e50a00900319661bcfa6 100644
--- a/crates/proto/src/proto.rs
+++ b/crates/proto/src/proto.rs
@@ -175,9 +175,6 @@ messages!(
     (ReorderChannel, Foreground),
     (LspQuery, Background),
     (LspQueryResponse, Background),
-    // todo(lsp) remove after Zed Stable hits v0.204.x
-    (MultiLspQuery, Background),
-    (MultiLspQueryResponse, Background),
     (OnTypeFormatting, Background),
     (OnTypeFormattingResponse, Background),
     (OpenBufferById, Background),
@@ -440,8 +437,6 @@ request_messages!(
     (SetRoomParticipantRole, Ack),
     (BlameBuffer, BlameBufferResponse),
     (RejoinRemoteProjects, RejoinRemoteProjectsResponse),
-    // todo(lsp) remove after Zed Stable hits v0.204.x
-    (MultiLspQuery, MultiLspQueryResponse),
     (LspQuery, Ack),
     (LspQueryResponse, Ack),
     (RestartLanguageServers, Ack),
@@ -557,8 +552,6 @@ entity_messages!(
     LoadCommitDiff,
     LspQuery,
     LspQueryResponse,
-    // todo(lsp) remove after Zed Stable hits v0.204.x
-    MultiLspQuery,
     RestartLanguageServers,
     StopLanguageServers,
     OnTypeFormatting,
@@ -844,26 +837,6 @@ impl LspQuery {
     }
 }
 
-// todo(lsp) remove after Zed Stable hits v0.204.x
-impl MultiLspQuery {
-    pub fn request_str(&self) -> &str {
-        match self.request {
-            Some(multi_lsp_query::Request::GetHover(_)) => "GetHover",
-            Some(multi_lsp_query::Request::GetCodeActions(_)) => "GetCodeActions",
-            Some(multi_lsp_query::Request::GetSignatureHelp(_)) => "GetSignatureHelp",
-            Some(multi_lsp_query::Request::GetCodeLens(_)) => "GetCodeLens",
-            Some(multi_lsp_query::Request::GetDocumentDiagnostics(_)) => "GetDocumentDiagnostics",
-            Some(multi_lsp_query::Request::GetDocumentColor(_)) => "GetDocumentColor",
-            Some(multi_lsp_query::Request::GetDefinition(_)) => "GetDefinition",
-            Some(multi_lsp_query::Request::GetDeclaration(_)) => "GetDeclaration",
-            Some(multi_lsp_query::Request::GetTypeDefinition(_)) => "GetTypeDefinition",
-            Some(multi_lsp_query::Request::GetImplementation(_)) => "GetImplementation",
-            Some(multi_lsp_query::Request::GetReferences(_)) => "GetReferences",
-            None => "<unknown>",
-        }
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;