update docs after changes in profiles

Author: thushan

docs/content/api-reference/overview.md

@@ -98,10 +98,10 @@ When available, provider-specific performance metrics are extracted from respons
 
 | Metric | Description | Providers |
 |--------|-------------|-----------|
-| `provider_total_ms` | Total processing time | Ollama, LM Studio |
-| `provider_prompt_tokens` | Tokens in prompt | All |
-| `provider_completion_tokens` | Tokens generated | All |
-| `provider_tokens_per_second` | Generation speed | Ollama, LM Studio |
+| `provider_total_ms` | Total processing time (ms) | Ollama, LM Studio |
+| `provider_prompt_tokens` | Tokens in prompt (count) | All |
+| `provider_completion_tokens` | Tokens generated (count) | All |
+| `provider_tokens_per_second` | Generation speed (tokens/s) | Ollama, LM Studio |
 | `provider_model` | Actual model used | All |
 
 See [Provider Metrics](../concepts/provider-metrics.md) for detailed information.

docs/content/concepts/provider-metrics.md

@@ -124,7 +124,9 @@ metrics:
 
 ### Key Components
 
-1. **`paths`**: Maps field names to JSONPath expressions for extracting values from the provider's response
+1. **`paths`**: Maps field names to JSON path expressions for extracting values from the provider's response
+   - Supports both JSONPath notation (`$.field.subfield`) and gjson notation (`field.subfield`)
+   - JSONPath prefixes are automatically normalized: `$.` is trimmed, `$` becomes empty string
 2. **`calculations`**: Defines derived metrics using mathematical expressions that reference extracted fields
 3. **Expression variables**: Any field defined in `paths` can be used as a variable in `calculations`
 4. **Pre-compilation**: Expressions are compiled at startup for performance
@@ -146,12 +148,13 @@ metrics:
     format: "json"           # Expected format
     
     # JSONPath expressions for extracting values from provider response
+    # Note: Both JSONPath ($.field) and gjson (field) notation are supported
     paths:
-      model: "$.model"
-      done: "$.done"
+      model: "$.model"                    # JSONPath notation (normalized to "model")
+      is_complete: "done"                 # gjson notation (used as-is)
       # Token counts
       input_tokens: "$.prompt_eval_count"
-      output_tokens: "$.eval_count"
+      output_tokens: "eval_count"         # Both formats work identically
       # Timing data (in nanoseconds from Ollama)
       total_duration_ns: "$.total_duration"
       load_duration_ns: "$.load_duration"
@@ -260,9 +263,16 @@ Response includes provider metrics when available:
 
 ### Extraction Implementation
 Olla uses high-performance libraries for metrics extraction:
-- **[gjson](https://github.com/tidwall/gjson)**: For JSONPath parsing (7.6x faster than encoding/json)
+- **[gjson](https://github.com/tidwall/gjson)**: For JSON path parsing (7.6x faster than encoding/json)
 - **[expr](https://github.com/expr-lang/expr)**: For pre-compiled mathematical expressions
 
+**JSONPath Normalization**: Olla automatically normalizes JSONPath-style prefixes for gjson compatibility:
+- `$.foo.bar` → `foo.bar` (leading `$.` is trimmed)
+- `$` → `` (root selector is converted to empty string)
+- `foo.bar` → `foo.bar` (already normalized paths are unchanged)
+
+This means you can use either JSONPath notation (`$.model`) or gjson notation (`model`) in your configurations - both work identically.
+
 ### Extraction Overhead
 - Metrics extraction runs with a 10ms timeout to prevent blocking
 - Extraction is best-effort - failures don't affect request processing
@@ -316,7 +326,7 @@ alerts:
 
 ### Metrics Not Appearing
 1. Check provider supports metrics in responses
-2. Verify profile configuration includes `metrics_extraction`
+2. Verify profile configuration includes `metrics.extraction` section
 3. Enable debug logging to see extraction attempts
 4. Ensure response format matches expected structure
 

docs/content/development/architecture.md

@@ -210,7 +210,25 @@ func (s *SherpaProxy) ProxyRequest(ctx context.Context,
     }
     defer resp.Body.Close()
 
-    return s.streamResponse(w, resp)
+    // Stream response with new signature
+    // Returns: 
+    //   - bytesWritten: total bytes successfully written to client
+    //   - lastChunk: final bytes of response (up to 8KB) for metrics extraction
+    //   - err: streaming error if any
+    buffer := make([]byte, 32*1024)
+    bytesWritten, lastChunk, err := s.streamResponse(ctx, ctx, w, resp, buffer, logger)
+    if err != nil {
+        return fmt.Errorf("streaming failed after %d bytes: %w", bytesWritten, err)
+    }
+    
+    // lastChunk contains the tail of the response (for extracting provider metrics)
+    // This avoids buffering the entire response while still capturing completion stats
+    if len(lastChunk) > 0 {
+        // Extract provider metrics from the last chunk of response
+        s.extractMetrics(lastChunk, stats)
+    }
+    
+    return nil
 }
 ```
 
@@ -226,11 +244,37 @@ type OllaProxy struct {
 func (o *OllaProxy) ProxyRequest(ctx context.Context,
     w http.ResponseWriter, r *http.Request,
     stats *RequestStats, logger StyledLogger) error {
+    endpoint := o.selectEndpoint()
     pool := o.getPool(endpoint)
-    conn := pool.Get()
-    defer pool.Put(conn)
 
-    return o.streamWithBackpressure(w, conn)
+    resp, err := pool.RoundTrip(r)
+    if err != nil {
+        return err
+    }
+    defer resp.Body.Close()
+    
+    // Get buffer from pool for zero-allocation streaming
+    buffer := o.bufferPool.Get()
+    defer o.bufferPool.Put(buffer)
+    
+    // Stream with optimized backpressure handling
+    // Returns: bytes written, last chunk for metrics, error
+    bytesWritten, lastChunk, err := o.streamResponse(
+        r.Context(),           // client context
+        resp.Request.Context(), // upstream context
+        w, resp, *buffer, logger)
+    
+    if err != nil && !errors.Is(err, context.Canceled) {
+        return fmt.Errorf("stream failed: %w", err)
+    }
+    
+    // Extract metrics from last chunk (Olla buffers only final bytes)
+    if len(lastChunk) > 0 {
+        o.extractProviderMetrics(lastChunk, endpoint, stats)
+    }
+    
+    stats.TotalBytes = bytesWritten
+    return nil
 }
 ```