Put in a recent project picker

server/src/http/anthropic.rs

@@ -1,9 +1,42 @@
 use crate::http::context::{AppContext, OpenApiResult, bad_request};
 use crate::llm::chat;
+use crate::store::StoreOps;
 use poem_openapi::{Object, OpenApi, Tags, payload::Json};
+use reqwest::header::{HeaderMap, HeaderValue};
 use serde::Deserialize;
 use std::sync::Arc;
 
+const ANTHROPIC_MODELS_URL: &str = "https://api.anthropic.com/v1/models";
+const ANTHROPIC_VERSION: &str = "2023-06-01";
+const KEY_ANTHROPIC_API_KEY: &str = "anthropic_api_key";
+
+#[derive(Deserialize)]
+struct AnthropicModelsResponse {
+    data: Vec<AnthropicModelInfo>,
+}
+
+#[derive(Deserialize)]
+struct AnthropicModelInfo {
+    id: String,
+}
+
+fn get_anthropic_api_key(ctx: &AppContext) -> Result<String, String> {
+    match ctx.store.get(KEY_ANTHROPIC_API_KEY) {
+        Some(value) => {
+            if let Some(key) = value.as_str() {
+                if key.is_empty() {
+                    Err("Anthropic API key is empty. Please set your API key.".to_string())
+                } else {
+                    Ok(key.to_string())
+                }
+            } else {
+                Err("Stored API key is not a string".to_string())
+            }
+        }
+        None => Err("Anthropic API key not found. Please set your API key.".to_string()),
+    }
+}
+
 #[derive(Deserialize, Object)]
 struct ApiKeyPayload {
     api_key: String,
@@ -48,4 +81,46 @@ impl AnthropicApi {
             .map_err(bad_request)?;
         Ok(Json(true))
     }
+
+    /// List available Anthropic models.
+    #[oai(path = "/anthropic/models", method = "get")]
+    async fn list_anthropic_models(&self) -> OpenApiResult<Json<Vec<String>>> {
+        let api_key = get_anthropic_api_key(self.ctx.as_ref()).map_err(bad_request)?;
+        let client = reqwest::Client::new();
+        let mut headers = HeaderMap::new();
+        headers.insert(
+            "x-api-key",
+            HeaderValue::from_str(&api_key).map_err(|e| bad_request(e.to_string()))?,
+        );
+        headers.insert(
+            "anthropic-version",
+            HeaderValue::from_static(ANTHROPIC_VERSION),
+        );
+
+        let response = client
+            .get(ANTHROPIC_MODELS_URL)
+            .headers(headers)
+            .send()
+            .await
+            .map_err(|e| bad_request(e.to_string()))?;
+
+        if !response.status().is_success() {
+            let status = response.status();
+            let error_text = response
+                .text()
+                .await
+                .unwrap_or_else(|_| "Unknown error".to_string());
+            return Err(bad_request(format!(
+                "Anthropic API error {status}: {error_text}"
+            )));
+        }
+
+        let body = response
+            .json::<AnthropicModelsResponse>()
+            .await
+            .map_err(|e| bad_request(e.to_string()))?;
+        let models = body.data.into_iter().map(|m| m.id).collect();
+
+        Ok(Json(models))
+    }
 }

server/src/http/project.rs

@@ -47,4 +47,11 @@ impl ProjectApi {
         fs::close_project(&self.ctx.state, self.ctx.store.as_ref()).map_err(bad_request)?;
         Ok(Json(true))
     }
+
+    /// List known projects from the store.
+    #[oai(path = "/projects", method = "get")]
+    async fn list_known_projects(&self) -> OpenApiResult<Json<Vec<String>>> {
+        let projects = fs::get_known_projects(self.ctx.store.as_ref()).map_err(bad_request)?;
+        Ok(Json(projects))
+    }
 }

server/src/http/ws.rs

@@ -6,6 +6,7 @@ use poem::handler;
 use poem::web::Data;
 use poem::web::websocket::{Message as WsMessage, WebSocket};
 use serde::{Deserialize, Serialize};
+use std::sync::Arc;
 use tokio::sync::mpsc;
 
 #[derive(Deserialize)]
@@ -39,7 +40,7 @@ enum WsResponse {
 /// WebSocket endpoint for streaming chat responses and cancellation.
 ///
 /// Accepts JSON `WsRequest` messages and streams `WsResponse` messages.
-pub async fn ws_handler(ws: WebSocket, ctx: Data<&AppContext>) -> impl poem::IntoResponse {
+pub async fn ws_handler(ws: WebSocket, ctx: Data<&Arc<AppContext>>) -> impl poem::IntoResponse {
     let ctx = ctx.0.clone();
     ws.on_upgrade(move |socket| async move {
         let (mut sink, mut stream) = socket.split();