feat: Make timeouts configurable in semantic LLM operations (#270)

### TL;DR

Added configurable request timeout for all semantic operators in Fenic.

### What changed?

- Added an optional `request_timeout` parameter to all semantic
operators and extensions (map, extract, predicate, reduce, classify,
analyze_sentiment, summarize, parse_pdf, join, sim_join)
- Added verification for request_timeout to be more than 0 and not more
than system maximum
- Updated all LLM provider clients to use http clients with large 10
minute timeout
- Modified the inference layer to respect this timeout parameter when
making LLM requests
- Updated the model client to use the request-specific timeout, or
default to old 120-second value
- Propagated the timeout parameter through all relevant classes in the
execution path
- Added tool for testing long llm requests 
- Embedding request objects do not have a timeout

### How to test?

1. Test with a standard request:
```python
import fenic as fn
df = fn.DataFrame({"text": ["This is a long document..."]})
result = df.select(fn.semantic.map("Summarize this text", text=fn.col("text")))
```

2. Test with a custom timeout:
```python
# Set a longer timeout for complex operations
result = df.select(fn.semantic.map("Summarize this text", 
                                   text=fn.col("text"), 
                                   request_timeout=300.0))

# Set a shorter timeout for quick operations
result = df.select(fn.semantic.analyze_sentiment(fn.col("text"), 
                                                request_timeout=30.0))
```

3. Verify timeout behavior by intentionally setting a very short
timeout:
```python
# This should trigger a timeout and retry
result = df.select(fn.semantic.extract(fn.col("text"), 
                                      MySchema, 
                                      request_timeout=0.1))
```

### Why make this change?

Different semantic operations may require different timeout thresholds:
- Complex operations like parsing large PDFs or extracting structured
data from long documents may need longer timeouts
- Simple operations like sentiment analysis might benefit from shorter
timeouts
- Users with specific latency requirements can now customize timeouts to
match their needs

This change improves flexibility and user control over request handling,
especially for workloads with varying complexity and time sensitivity.

Author: YoungVor

src/fenic/_backends/local/semantic_operators/analyze_sentiment.py

@@ -134,6 +134,7 @@ def __init__(
         model: LanguageModel,
         temperature: float,
         model_alias: Optional[ResolvedModelAlias] = None,
+        request_timeout: Optional[float] = None,
     ):
         super().__init__(
             input,
@@ -145,6 +146,7 @@ def __init__(
                     temperature=temperature,
                     response_format=SENTIMENT_ANALYSIS_FORMAT,
                     model_profile=model_alias.profile if model_alias else None,
+                    request_timeout=request_timeout,
                 ),
             ),
             EXAMPLES,

src/fenic/_backends/local/semantic_operators/base.py

@@ -78,6 +78,7 @@ def send_requests(
             response_format=self.inference_config.response_format,
             top_logprobs=self.inference_config.top_logprobs,
             model_profile=self.inference_config.model_profile,
+            request_timeout=self.inference_config.request_timeout,
         )
 
         completions = [

src/fenic/_backends/local/semantic_operators/classify.py

@@ -43,6 +43,7 @@ def __init__(
         temperature: float,
         examples: Optional[ClassifyExampleCollection] = None,
         model_alias: Optional[ResolvedModelAlias] = None,
+        request_timeout: Optional[float] = None,
     ):
         self.classes = classes
         self.valid_labels = {class_def.label for class_def in classes}
@@ -59,6 +60,7 @@ def __init__(
                     temperature=temperature,
                     response_format=ResolvedResponseFormat.from_pydantic_model(self.output_model, generate_struct_type=False),
                     model_profile=model_alias.profile if model_alias else None,
+                    request_timeout=request_timeout,
                 ),
             ),
             examples,

src/fenic/_backends/local/semantic_operators/extract.py

@@ -50,6 +50,7 @@ def __init__(
         max_output_tokens: int,
         temperature: float,
         model_alias: Optional[ResolvedModelAlias] = None,
+        request_timeout: Optional[float] = None,
     ):
         self.resolved_format = response_format
         super().__init__(
@@ -61,6 +62,7 @@ def __init__(
                     temperature=temperature,
                     response_format=response_format,
                     model_profile=model_alias.profile if model_alias else None,
+                    request_timeout=request_timeout,
                 ),
                 model=model,
             ),

src/fenic/_backends/local/semantic_operators/map.py

@@ -53,6 +53,7 @@ def __init__(
         model_alias: Optional[ResolvedModelAlias] = None,
         response_format: Optional[ResolvedResponseFormat] = None,
         examples: Optional[MapExampleCollection] = None,
+        request_timeout: Optional[float] = None,
     ):
         super().__init__(
             input,
@@ -64,6 +65,7 @@ def __init__(
                     response_format=response_format,
                     temperature=temperature,
                     model_profile=model_alias.profile if model_alias else None,
+                    request_timeout=request_timeout,
                 ),
             ),
             jinja_template=jinja2.Template(jinja_template),

src/fenic/_backends/local/semantic_operators/parse_pdf.py

@@ -50,6 +50,7 @@ def __init__(
         describe_images: bool = False,
         model_alias: Optional[ResolvedModelAlias] = None,
         max_output_tokens: Optional[int] = None,
+        request_timeout: Optional[float] = None,
     ):
         self.page_separator = page_separator
         self.describe_images = describe_images
@@ -68,6 +69,7 @@ def __init__(
                     max_output_tokens=max_output_tokens,
                     temperature=1.0,  # Use a higher temperature so gemini flash models can handle complex table formatting.  For more info see the conversation here: https://discuss.ai.google.dev/t/gemini-2-0-flash-has-a-weird-bug/65119/26
                     model_profile=model_alias.profile if model_alias else None,
+                    request_timeout=request_timeout,
                 ),
             ),
             examples=None,  # PDF parsing doesn't use examples

src/fenic/_backends/local/semantic_operators/predicate.py

@@ -46,6 +46,7 @@ def __init__(
         temperature: float,
         examples: Optional[PredicateExampleCollection] = None,
         model_alias: Optional[ResolvedModelAlias] = None,
+        request_timeout: Optional[float] = None,
     ):
         super().__init__(
             input,
@@ -56,6 +57,7 @@ def __init__(
                   response_format=PREDICATE_FORMAT,
                   temperature=temperature,
                   model_profile=model_alias.profile if model_alias else None,
+                  request_timeout=request_timeout,
                 ),
                 model=model,
             ),

src/fenic/_backends/local/semantic_operators/summarize.py

@@ -45,6 +45,7 @@ def __init__(
         temperature: float,
         model: LanguageModel,
         model_alias: Optional[ResolvedModelAlias] = None,
+        request_timeout: Optional[float] = None,
     ):
         self.format = format
 
@@ -56,6 +57,7 @@ def __init__(
                     max_output_tokens=self.get_max_tokens(),
                     temperature=temperature,
                     model_profile=model_alias.profile if model_alias else None,
+                    request_timeout=request_timeout,
                 ),
                 model=model,
             ),

src/fenic/_backends/local/transpiler/expr_converter.py

@@ -581,6 +581,7 @@ def sem_map_fn(batch: pl.Series) -> pl.Series:
                 temperature=logical.temperature,
                 response_format=logical.response_format,
                 model_alias=logical.model_alias,
+                request_timeout=logical.request_timeout,
             ).execute()
 
         column_exprs = [self._convert_expr(expr) for expr in logical.exprs]
@@ -680,6 +681,7 @@ def sem_ext_fn(batch: pl.Series) -> pl.Series:
                 max_output_tokens=logical.max_tokens,
                 temperature=logical.temperature,
                 model_alias=logical.model_alias,
+                request_timeout=logical.request_timeout,
             ).execute()
 
         return self._convert_expr(logical.expr).map_batches(
@@ -700,6 +702,7 @@ def sem_pred_fn(batch: pl.Series) -> pl.Series:
                 examples=logical.examples,
                 temperature=logical.temperature,
                 model_alias=logical.model_alias,
+                request_timeout=logical.request_timeout,
             ).execute()
 
         column_exprs = [self._convert_expr(expr) for expr in logical.exprs]
@@ -722,6 +725,7 @@ def sem_classify_fn(batch: pl.Series) -> pl.Series:
                 temperature=logical.temperature,
                 examples=logical.examples,
                 model_alias=logical.model_alias,
+                request_timeout=logical.request_timeout,
             ).execute()
 
         return self._convert_expr(logical.expr).map_batches(
@@ -737,6 +741,7 @@ def sem_sentiment_fn(batch: pl.Series) -> pl.Series:
                 model=self.session_state.get_language_model(logical.model_alias),
                 temperature=logical.temperature,
                 model_alias=logical.model_alias,
+                request_timeout=logical.request_timeout,
             ).execute()
 
         return self._convert_expr(logical.expr).map_batches(
@@ -753,7 +758,7 @@ def sem_summarize_fn(batch: pl.Series) -> pl.Series:
                 format=logical.format,
                 temperature=logical.temperature,
                 model=self.session_state.get_language_model(logical.model_alias),
-
+                request_timeout=logical.request_timeout,
             ).execute()
 
         return self._convert_expr(logical.expr).map_batches(
@@ -770,6 +775,7 @@ def parse_pdf_fn(batch: pl.Series) -> pl.Series:
                 describe_images=logical.describe_images,
                 model_alias=logical.model_alias,
                 max_output_tokens=logical.max_output_tokens,
+                request_timeout=logical.request_timeout,
             ).execute()
 
         return self._convert_expr(logical.expr).map_batches(

src/fenic/_constants.py

@@ -20,6 +20,10 @@
 DEFAULT_MAX_TOKENS = 512
 DEFAULT_TEMPERATURE: float = 0
 
+# Model client timeout constants
+MAX_MODEL_CLIENT_TIMEOUT = 600  # 10 minutes
+DEFAULT_MODEL_CLIENT_TIMEOUT = 120  # 2 minutes
+
 # If the output type is known to us before runtime, this is a rough upper bound.
 # Higher than expected because Anthropic estimates output tokens differently than other providers
 # during tool use.