fix: Handle finish_reason 'length' to prevent hang when hitting max_tokens

When the response hits the max_tokens limit, the API returns finish_reason="length".
Previously, this fell into the catch-all case which didn't emit pending items,
causing llmx to hang with "working" status.

Now:
- Handle "length" the same as "stop" - emit assistant_item and reasoning_item
- Also made catch-all case defensive: emit pending items for any unknown finish_reason

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

llmx-rs/core/src/chat_completions.rs

@@ -645,7 +645,14 @@ async fn process_chat_sse<S>(
                 return;
             }
             Ok(None) => {
-                // Stream closed gracefully – emit Completed with dummy id.
+                // Stream closed gracefully – emit any pending items first, then Completed
+                debug!("Stream closed gracefully (Ok(None)), emitting pending items");
+                if let Some(item) = assistant_item.take() {
+                    let _ = tx_event.send(Ok(ResponseEvent::OutputItemDone(item))).await;
+                }
+                if let Some(item) = reasoning_item.take() {
+                    let _ = tx_event.send(Ok(ResponseEvent::OutputItemDone(item))).await;
+                }
                 let _ = tx_event
                     .send(Ok(ResponseEvent::Completed {
                         response_id: String::new(),
@@ -860,9 +867,9 @@ async fn process_chat_sse<S>(
 
                         let _ = tx_event.send(Ok(ResponseEvent::OutputItemDone(item))).await;
                     }
-                    "stop" => {
-                        // Regular turn without tool-call. Emit the final assistant message
-                        // as a single OutputItemDone so non-delta consumers see the result.
+                    "stop" | "length" => {
+                        // Regular turn without tool-call, or hit max_tokens limit.
+                        // Emit the final assistant message as a single OutputItemDone so non-delta consumers see the result.
                         if let Some(item) = assistant_item.take() {
                             let _ = tx_event.send(Ok(ResponseEvent::OutputItemDone(item))).await;
                         }
@@ -871,7 +878,16 @@ async fn process_chat_sse<S>(
                             let _ = tx_event.send(Ok(ResponseEvent::OutputItemDone(item))).await;
                         }
                     }
-                    _ => {}
+                    _ => {
+                        // Unknown finish_reason - still emit pending items to avoid hanging
+                        debug!("Unknown finish_reason: {}, emitting pending items", finish_reason);
+                        if let Some(item) = assistant_item.take() {
+                            let _ = tx_event.send(Ok(ResponseEvent::OutputItemDone(item))).await;
+                        }
+                        if let Some(item) = reasoning_item.take() {
+                            let _ = tx_event.send(Ok(ResponseEvent::OutputItemDone(item))).await;
+                        }
+                    }
                 }
 
                 // Emit Completed regardless of reason so the agent can advance.