Allow AI interactions to be proxied through Zed's server so you don't need an API key (#7367)

Co-authored-by: Antonio <antonio@zed.dev>

Resurrected this from some assistant work I did in Spring of 2023.
- [x] Resurrect streaming responses
- [x] Use streaming responses to enable AI via Zed's servers by default
(but preserve API key option for now)
- [x] Simplify protobuf
- [x] Proxy to OpenAI on zed.dev
- [x] Proxy to Gemini on zed.dev
- [x] Improve UX for switching between openAI and google models
- We current disallow cycling when setting a custom model, but we need a
better solution to keep OpenAI models available while testing the google
ones
- [x] Show remaining tokens correctly for Google models
- [x] Remove semantic index
- [x] Delete `ai` crate
- [x] Cloud front so we can ban abuse
- [x] Rate-limiting
- [x] Fix panic when using inline assistant
- [x] Double check the upgraded `AssistantSettings` are
backwards-compatible
- [x] Add hosted LLM interaction behind a `language-models` feature
flag.

Release Notes:

- We are temporarily removing the semantic index in order to redesign it
from scratch.

---------

Co-authored-by: Antonio <antonio@zed.dev>
Co-authored-by: Antonio Scandurra <me@as-cii.com>
Co-authored-by: Thorsten <thorsten@zed.dev>
Co-authored-by: Max <max@zed.dev>

crates/collab/src/ai.rs

@@ -0,0 +1,75 @@
+use anyhow::{anyhow, Result};
+use rpc::proto;
+
+pub fn language_model_request_to_open_ai(
+    request: proto::CompleteWithLanguageModel,
+) -> Result<open_ai::Request> {
+    Ok(open_ai::Request {
+        model: open_ai::Model::from_id(&request.model).unwrap_or(open_ai::Model::FourTurbo),
+        messages: request
+            .messages
+            .into_iter()
+            .map(|message| {
+                let role = proto::LanguageModelRole::from_i32(message.role)
+                    .ok_or_else(|| anyhow!("invalid role {}", message.role))?;
+                Ok(open_ai::RequestMessage {
+                    role: match role {
+                        proto::LanguageModelRole::LanguageModelUser => open_ai::Role::User,
+                        proto::LanguageModelRole::LanguageModelAssistant => {
+                            open_ai::Role::Assistant
+                        }
+                        proto::LanguageModelRole::LanguageModelSystem => open_ai::Role::System,
+                    },
+                    content: message.content,
+                })
+            })
+            .collect::<Result<Vec<open_ai::RequestMessage>>>()?,
+        stream: true,
+        stop: request.stop,
+        temperature: request.temperature,
+    })
+}
+
+pub fn language_model_request_to_google_ai(
+    request: proto::CompleteWithLanguageModel,
+) -> Result<google_ai::GenerateContentRequest> {
+    Ok(google_ai::GenerateContentRequest {
+        contents: request
+            .messages
+            .into_iter()
+            .map(language_model_request_message_to_google_ai)
+            .collect::<Result<Vec<_>>>()?,
+        generation_config: None,
+        safety_settings: None,
+    })
+}
+
+pub fn language_model_request_message_to_google_ai(
+    message: proto::LanguageModelRequestMessage,
+) -> Result<google_ai::Content> {
+    let role = proto::LanguageModelRole::from_i32(message.role)
+        .ok_or_else(|| anyhow!("invalid role {}", message.role))?;
+
+    Ok(google_ai::Content {
+        parts: vec![google_ai::Part::TextPart(google_ai::TextPart {
+            text: message.content,
+        })],
+        role: match role {
+            proto::LanguageModelRole::LanguageModelUser => google_ai::Role::User,
+            proto::LanguageModelRole::LanguageModelAssistant => google_ai::Role::Model,
+            proto::LanguageModelRole::LanguageModelSystem => google_ai::Role::User,
+        },
+    })
+}
+
+pub fn count_tokens_request_to_google_ai(
+    request: proto::CountTokensWithLanguageModel,
+) -> Result<google_ai::CountTokensRequest> {
+    Ok(google_ai::CountTokensRequest {
+        contents: request
+            .messages
+            .into_iter()
+            .map(language_model_request_message_to_google_ai)
+            .collect::<Result<Vec<_>>>()?,
+    })
+}