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/db/queries/rate_buckets.rs

@@ -0,0 +1,58 @@
+use super::*;
+use crate::db::tables::rate_buckets;
+use sea_orm::{ColumnTrait, EntityTrait, QueryFilter};
+
+impl Database {
+    /// Saves the rate limit for the given user and rate limit name if the last_refill is later
+    /// than the currently saved timestamp.
+    pub async fn save_rate_buckets(&self, buckets: &[rate_buckets::Model]) -> Result<()> {
+        if buckets.is_empty() {
+            return Ok(());
+        }
+
+        self.transaction(|tx| async move {
+            rate_buckets::Entity::insert_many(buckets.iter().map(|bucket| {
+                rate_buckets::ActiveModel {
+                    user_id: ActiveValue::Set(bucket.user_id),
+                    rate_limit_name: ActiveValue::Set(bucket.rate_limit_name.clone()),
+                    token_count: ActiveValue::Set(bucket.token_count),
+                    last_refill: ActiveValue::Set(bucket.last_refill),
+                }
+            }))
+            .on_conflict(
+                OnConflict::columns([
+                    rate_buckets::Column::UserId,
+                    rate_buckets::Column::RateLimitName,
+                ])
+                .update_columns([
+                    rate_buckets::Column::TokenCount,
+                    rate_buckets::Column::LastRefill,
+                ])
+                .to_owned(),
+            )
+            .exec(&*tx)
+            .await?;
+
+            Ok(())
+        })
+        .await
+    }
+
+    /// Retrieves the rate limit for the given user and rate limit name.
+    pub async fn get_rate_bucket(
+        &self,
+        user_id: UserId,
+        rate_limit_name: &str,
+    ) -> Result<Option<rate_buckets::Model>> {
+        self.transaction(|tx| async move {
+            let rate_limit = rate_buckets::Entity::find()
+                .filter(rate_buckets::Column::UserId.eq(user_id))
+                .filter(rate_buckets::Column::RateLimitName.eq(rate_limit_name))
+                .one(&*tx)
+                .await?;
+
+            Ok(rate_limit)
+        })
+        .await
+    }
+}