BeyondSWE: Can Current Code Agent Survive Beyond Single-Repo Bug Fixing?

Server ignores `host` argument in `start()` and `TRAME_DEFAULT_HOST` environment variable

Description

We are encountering an issue where the `host` parameter passed to `trame_server.Server.start()` is ignored, causing the server to always bind to `localhost` (127.0.0.1). This prevents external connections and is blocking downstream integrations that require binding to specific interfaces (e.g., `0.0.0.0` for containerized environments), such as the ongoing work in PyVista (see pyvista/pyvista#3385).

The server persists with the CLI default (`localhost`) even when an explicit override is provided in Python. Furthermore, the `TRAME_DEFAULT_HOST` environment variable, which is expected to define the host when no argument is provided, is currently not respected.

Steps to Reproduce

The following script attempts to bind the server to `0.0.0.0`, but the server continues to listen on `127.0.0.1`:

import os
from trame_server import Server

# Scenario 1: Attempt to start server on all interfaces via argument
# Expected: Binds to 0.0.0.0
# Actual: Binds to 127.0.0.1
print("--- Testing host argument ---")
server = Server()
try:
    # This host argument is currently ignored
    server.start(port=8080, host='0.0.0.0', open_browser=False)
except Exception as e:
    print(f"Error: {e}")
finally:
    server.stop()

# Scenario 2: Attempt using environment variable
# Expected: Binds to 0.0.0.0
# Actual: Binds to 127.0.0.1 (default)
print("\n--- Testing environment variable ---")
os.environ['TRAME_DEFAULT_HOST'] = '0.0.0.0'
server2 = Server()
try:
    server2.start(port=8081, open_browser=False)
except Exception as e:
    print(f"Error: {e}")
finally:
    server2.stop()

Expected Behavior

1. Argument Priority: When server.start(host='0.0.0.0') is called, the server should respect the host argument and bind to that address.
2. Environment Variable: If no host argument is provided to start(), the server should use the value of TRAME_DEFAULT_HOST if it is set.

Implement sparse Cholesky decomposition

Description

Currently, `cvxpy` decomposes positive definite matrices into a Gram matrix format using eigendecomposition followed by scaling the eigenvectors by the square roots of the eigenvalues. This process is inefficient for sparse positive definite matrices, as it doesn't take advantage of sparsity.

It would be beneficial to expose a sparse Cholesky decomposition functionality to handle these decompositions more efficiently. This would improve performance for operations involving large sparse positive definite matrices.

Example Usage

import scipy.sparse as sp
import numpy as np
# This function doesn't exist yet
from cvxpy.utilities.linalg import sparse_cholesky 

n = 100
A = sp.rand(n, n, density=0.05)
A = A.T @ A + sp.eye(n) # Make it positive definite

# Should return lower triangular matrix L and permutation p
L, p = sparse_cholesky(A)

Expected Behavior

The sparse_cholesky function should return a sparse lower triangular matrix $L$ and a permutation vector $p$ such that $P A P^T = L L^T$, where $P$ is the permutation matrix associated with $p$.

Support OpenAI v1 SDK and fix Azure configuration issues

Description

We are upgrading the external `openai` dependency to version 1.0+. This upgrade has caused regressions in our Language Model (LM) client, specifically for **Azure OpenAI** configurations.

Users attempting to run the application with the new SDK version are encountering errors related to argument handling. The current implementation's approach to mapping `model`, `engine`, and `deployment_id` appears to be incompatible with the updated library. Additionally, the logic used to infer model types (chat vs. text) is failing for Azure deployments with custom names.

Current Behavior

1. Upgrade Failure: The codebase is currently incompatible with `openai>=1.0`.
2. Azure Parameter Errors: When `api_provider="azure"` is used, initializing the client results in `AssertionError`s or parameter validation failures. The application struggles to reconcile the `model` argument with the parameters expected by the Azure endpoint (e.g., `deployment_id`, `engine`).
3. Inference Issues: The system attempts to deduce the model type based on the model name. This fails for Azure users with custom deployment names (e.g., names that do not contain "gpt" or "instruct"), causing the client to misbehave.

Expected Behavior

• The library must support `openai>=1.0`.
• Azure-backed clients must initialize successfully without raising errors regarding `model`, `engine`, or `deployment_id` ambiguity.
• Azure model type inference should be robust enough to handle custom deployment names.
• Constraint: The refactor must ensure that existing caches for standard OpenAI users remain valid.

Specification: target_repo

1. Overview

The `target_repo` library is a unified document processing tool designed to convert various document formats (PDF, Office files, Images, HTML, etc.) into clean Markdown. It emphasizes high-fidelity conversion by preserving layout, tables, and extracting images. A key feature is its integration with AI-powered OCR (specifically OpenAI's Vision API and Tesseract) to handle scanned documents and complex layouts that traditional extractors miss.

The library provides a simple, unified API for processing single files or batch-processing entire directories. It abstracts away the complexity of handling different file formats, providing a consistent `ProcessedDocument` output containing the content, metadata, and extracted assets.

2. API Reference

Component: `UnifiedDocumentLoader`

Import Path: from target_repo import UnifiedDocumentLoader

class UnifiedDocumentLoader:
    def __init__(
        self,
        ocr_provider: Union[str, OCRProvider, BaseOCR] = 'openai',
        api_key: Optional[str] = None,
        ocr_config: Optional[OCRConfig] = None,
        cache_dir: Optional[str] = None,
        # Enhanced OCR configuration for OpenAI
        model: str = "gpt-4.1",
        temperature: float = 0,
        max_tokens: int = 4096,
        max_workers: int = 5,
        prompt_template: Union[str, PromptTemplate] = PromptTemplate.DEFAULT,
        timeout: int = 30,
        max_retries: int = 3,
        # Additional OpenAI parameters
        top_p: float = 1.0,
        frequency_penalty: float = 0.0,
        presence_penalty: float = 0.0,
        base_url: Optional[str] = None,
        # General OCR parameters
        default_prompt: Optional[str] = None,
        # Table output configuration
        table_style: Optional[str] = None
    ): ...

    @property
    def supported_formats(self) -> List[str]: ...

    @property
    def ocr(self) -> BaseOCR: ...

    @property
    def cache_dir(self) -> Optional[Path]: ...

    def load(
        self,
        file_path: Union[str, Path],
        output_format: Union[str, OutputFormat] = OutputFormat.MARKDOWN,
        extract_images: bool = False,
        ocr_images: bool = False,
        show_progress: bool = False,
        # Format-specific parameters
        encoding: str = 'utf-8',
        delimiter: Optional[str] = None
    ) -> ProcessedDocument: ...

    def batch_process(
        self,
        input_dir: Union[str, Path],
        output_dir: Optional[Union[str, Path]] = None,
        output_format: Union[str, OutputFormat] = OutputFormat.MARKDOWN,
        extract_images: bool = False,
        ocr_images: bool = False,
        recursive: bool = True,
        show_progress: bool = True,
        save_files: bool = True,
        **kwargs
    ) -> Dict[str, Any]: ...

Description: The main entry point for loading and processing documents. It manages format detection, processor selection, and OCR configuration. It supports caching processed results to avoid redundant computation.

Component: Convenience Functions

Import Path: from target_repo import load, batch_process_documents

def load(
    file_path: Union[str, Path],
    output_format: Union[str, OutputFormat] = OutputFormat.MARKDOWN,
    extract_images: bool = False,
    ocr_images: bool = False,
    ocr_provider: str = 'openai',
    api_key: Optional[str] = None,
    **kwargs
) -> ProcessedDocument: ...

def batch_process_documents(
    input_dir: Union[str, Path],
    output_dir: Optional[Union[str, Path]] = None,
    output_format: Union[str, OutputFormat] = OutputFormat.MARKDOWN,
    extract_images: bool = False,
    ocr_images: bool = False,
    recursive: bool = True,
    ocr_provider: str = 'openai',
    api_key: Optional[str] = None,
    show_progress: bool = True,
    save_files: bool = True,
    **kwargs
) -> Dict[str, Any]: ...