feat: add Codex-compatible GET v1/models and WebSocket session bug fixes (vllm-project#79)

## Summary

`handler.rs` had grown to 630 lines mixing WebSocket logic, HTTP
handlers, proxy utilities, and model transformation code in a single
file. This PR splits it into a focused module tree and adds a Codex
CLI-compatible `/v1/models` endpoint.

**`GET /v1/models`: Codex CLI compatibility**

- Added `proxy_get(path, headers, state)` to `agentic-core/proxy.rs`: a
GET variant of `proxy_request` that applies the same header filtering
and auth injection.
- Codex CLI is detected via `?client_version=<ver>` query param (typed
`ModelsParams` extractor).
- Non-Codex clients: upstream vLLM response streamed back unchanged via
`proxy_get`.
- Codex clients: vLLM `{ "object": "list", "data": [...] }` transformed
to `{ "models": [...] }` with the full `ModelInfo` shape Codex expects
(`slug`, `context_window`, `auto_review_model_override`,
`apply_patch_tool_type`, capabilities, etc.).
- Static `ModelInfo` fields built once via `OnceLock` and cloned per
model; only the five per-model fields are patched at response time.

**WebSocket session bug fixes**

Identified and fixed two bugs in `websocket/responses.rs` that prevented
Codex CLI from persisting history to the database:

- **Pipelined requests caused connection resets**: Codex sends the next
`response.create` on the same WebSocket connection while the current
stream is still active. The old handler returned a `ConcurrentMessage`
error and closed the connection, forcing Codex to reconnect on every
turn. Fixed by introducing a `VecDeque` queue: incoming requests that
arrive mid-stream are enqueued and processed in order after the current
stream completes. The `ConcurrentMessage` error variant was removed as
it is no longer reachable.

- **`store: false` bypassed the database**: Codex CLI explicitly sends
`"store": false` in every request body, which caused the gateway to skip
persistence entirely and proxy straight to vLLM. Fixed by forcing
`payload.store = true` on the WebSocket path; the gateway is the
stateful layer and should always persist regardless of what the client
sends.

Together these fixes ensure every completed Codex turn is written to the
DB with its full SSE history, and that multi-turn conversations chain
correctly via `previous_response_id`.

**Handler reorganization**

- `handler.rs` deleted. Replaced by `handler/` module tree:
- `common.rs`: shared utilities used across handlers:
`convert_response`, `executor_error_response`, `read_bytes`,
`resolve_exec_ctx`, `sse_response`
  - `http/conversations.rs`: `POST /v1/conversations`
- `http/models.rs`: `GET /health`, `GET /ready`, `GET /v1/models` +
Codex model transform logic
  - `http/responses.rs`: `POST /v1/responses` (proxy and stateful paths)
- `websocket/responses.rs`: WebSocket `/v1/responses` handler and
streaming loop
  - `websocket/error.rs`: `WsError` enum with status/code/frame helpers
- `handler/mod.rs` re-exports all public handlers; no import paths in
`app.rs` changed.


## Codex CLI setup

Create `$CODEX_HOME/config.toml` (e.g. `~/.codex/config.toml`) pointing
at agentic-api:

```toml
model_provider = "agentic-api"

[model_providers.agentic-api]
name = "agentic-api"
base_url = "http://localhost:9000/v1"
wire_api = "responses"
requires_openai_auth = false
supports_websockets = true
```

Run with:
```bash
codex --disable image_generation -c model_provider=agentic-api -m "model_name"
```

## Test Plan

- `cargo clippy --all-targets -- -D warnings` clean
- `cargo test`: all tests pass, 0 failed

---------

Signed-off-by: maral <maralbahari.98@gmail.com>
Co-authored-by: Claude Sonnet 4.6 (1M context) <noreply@anthropic.com>

Author: maralbahari

crates/agentic-core/src/proxy.rs

@@ -153,6 +153,48 @@ pub fn error_response(status: StatusCode, code: &str, message: &str) -> ProxyRes
     }
 }
 
+/// Proxy a GET request to an arbitrary upstream path.
+///
+/// Applies the same header filtering and auth injection as [`proxy_request`].
+/// Uses the non-streaming client; the response body is returned as a full
+/// [`ProxyBody::Full`] payload.
+pub async fn proxy_get(path: &str, request_headers: &HeaderMap, state: &ProxyState) -> ProxyResponse {
+    let llm_headers = filter_request_headers(request_headers, &state.config);
+    let base = state.config.llm_api_base.trim_end_matches('/');
+    let url = format!("{base}/{}", path.trim_start_matches('/'));
+
+    let llm_resp = match state.non_stream_client.get(&url).headers(llm_headers).send().await {
+        Ok(r) => r,
+        Err(e) if e.is_timeout() => {
+            warn!("upstream GET {path} timed out: {e}");
+            return error_response(StatusCode::GATEWAY_TIMEOUT, "upstream_timeout", "upstream timeout");
+        }
+        Err(e) => {
+            warn!("upstream GET {path} failed: {e}");
+            return error_response(StatusCode::BAD_GATEWAY, "upstream_unavailable", "upstream unavailable");
+        }
+    };
+
+    let status = StatusCode::from_u16(llm_resp.status().as_u16()).unwrap_or(StatusCode::BAD_GATEWAY);
+    let response_headers = filter_response_headers(llm_resp.headers());
+
+    match llm_resp.bytes().await {
+        Ok(payload) => ProxyResponse {
+            status,
+            headers: response_headers,
+            body: ProxyBody::Full(payload),
+        },
+        Err(e) => {
+            warn!("failed to read upstream GET {path} body: {e}");
+            error_response(
+                StatusCode::BAD_GATEWAY,
+                "upstream_unavailable",
+                "failed to read upstream response",
+            )
+        }
+    }
+}
+
 pub async fn proxy_request(request: ProxyRequest, state: &ProxyState) -> ProxyResponse {
     let is_streaming = serde_json::from_slice::<Value>(&request.body)
         .ok()

crates/agentic-server/src/app.rs

@@ -9,7 +9,7 @@ use tower_http::cors::{AllowOrigin, Any, CorsLayer};
 use agentic_core::executor::ExecutionContext;
 use agentic_core::proxy::ProxyState;
 
-use crate::handler::{conversations, health, ready, responses, responses_ws};
+use crate::handler::{conversations, health, models, ready, responses, responses_ws};
 
 /// Server-level configuration read from environment variables.
 pub struct ServerConfig {
@@ -71,6 +71,7 @@ pub fn build_router(state: AppState, server_config: &ServerConfig) -> Router {
         .route("/health", get(health))
         .route("/ready", get(ready))
         .route("/v1/conversations", post(conversations))
+        .route("/v1/models", get(models))
         .route("/v1/responses", post(responses).get(responses_ws))
         .layer(server_config.cors_layer())
         .with_state(state)