fix(gateway): remove implicit model request timeout

CHANGELOG.md

@@ -20,6 +20,9 @@ and this project uses [Semantic Versioning](https://semver.org/spec/v2.0.0.html)
 
 ### Fixed
 
+- Model, Agent, gateway, and structured-output repair requests now default to
+  no application timeout. Explicit probe, discovery, benchmark, and operator
+  limits remain bounded.
 - Workflow workers now preserve the caller message array exactly once, while
   the added envelope carries only the subtask and Conductor-style prior-step
   access list instead of duplicating the task or source attachments.

contextual_orchestrator/cost_router.py

@@ -232,7 +232,10 @@ def _run_embedding_shard(
 
     def _provider_embedding_backend(self) -> ProviderEmbeddingBatchBackend:
         client = getattr(self.orchestrator, "client", None)
-        client_timeout = float(getattr(client, "timeout", 0))
+        configured_timeout = getattr(client, "timeout", None)
+        client_timeout = (
+            float(configured_timeout) if configured_timeout is not None else 0.0
+        )
         return ProviderEmbeddingBatchBackend(
             self._run_provider_embeddings,
             job_registry=self.job_registry,

contextual_orchestrator/endpoint_race.py

@@ -79,7 +79,7 @@ def race_first_valid(
     attempts: list[EndpointAttempt[T]],
     *,
     validate: Callable[[T], bool],
-    deadline_seconds: float,
+    deadline_seconds: float | None,
     max_concurrency: int,
     on_attempt_complete: Callable[[str, T | None, BaseException | None], None] | None = None,
 ) -> RaceOutcome[T]:
@@ -94,7 +94,7 @@ def race_first_valid(
         raise ValueError("immediate_race requires concurrency capacity of at least two")
     if max_concurrency < len(attempts):
         raise ValueError("immediate_race capacity must cover every declared endpoint")
-    if deadline_seconds <= 0:
+    if deadline_seconds is not None and deadline_seconds <= 0:
         raise ValueError("deadline_seconds must be positive")
     contract = attempts[0].contract
     if any(attempt.contract != contract for attempt in attempts[1:]):
@@ -128,8 +128,12 @@ def execute(attempt: EndpointAttempt[T]) -> T:
     last_error: BaseException | None = None
     try:
         while pending:
-            remaining = deadline_seconds - (time.monotonic() - started)
-            if remaining <= 0:
+            remaining = (
+                None
+                if deadline_seconds is None
+                else deadline_seconds - (time.monotonic() - started)
+            )
+            if remaining is not None and remaining <= 0:
                 raise TimeoutError("equivalent endpoint race exceeded its deadline")
             done, pending = wait(pending, timeout=remaining, return_when=FIRST_COMPLETED)
             if not done:

contextual_orchestrator/orchestrator.py

@@ -1030,15 +1030,15 @@ def _local_provider_state(base_url: str) -> _LocalProviderState:
 def _local_provider_slot(
     agent: ModelAgent,
     capacity: int,
-    timeout: float,
+    timeout: float | None,
 ):
     """Bound local requests and serialize model switches on a shared endpoint."""
     if not _is_local_provider_url(agent.base_url):
         yield
         return
 
     state = _local_provider_state(agent.base_url)
-    deadline = time.monotonic() + max(float(timeout), 0.0)
+    deadline = None if timeout is None else time.monotonic() + max(float(timeout), 0.0)
     with state.condition:
         while True:
             if state.active == 0:
@@ -1051,8 +1051,8 @@ def _local_provider_slot(
                 state.active += 1
                 break
 
-            remaining = deadline - time.monotonic()
-            if remaining <= 0:
+            remaining = None if deadline is None else deadline - time.monotonic()
+            if remaining is not None and remaining <= 0:
                 raise TimeoutError("local provider endpoint is busy past its request deadline")
             state.condition.wait(remaining)
 
@@ -1693,7 +1693,7 @@ class ModelClient:
 
     def __init__(
         self,
-        timeout: int = 90,
+        timeout: float | None = None,
         max_output_tokens: int = 2048,
         max_retries: int = 2,
         local_max_retries: int = 0,

contextual_orchestrator/server.py

@@ -7286,25 +7286,32 @@ def register_video_job(agent: ModelAgent, provider_result: dict[str, Any]) -> di
                     if not attribution.get("service"):
                         attribution["service"] = "embeddings_api"
                     started_at = time.perf_counter()
-                    embedding_deadline = time.monotonic() + float(
-                        orchestrator.client.timeout
+                    configured_timeout = orchestrator.client.timeout
+                    embedding_deadline = (
+                        None
+                        if configured_timeout is None
+                        else time.monotonic() + float(configured_timeout)
                     )
                     document = None
                     last_embedding_error: Exception | None = None
                     for embedding_agent in embedding_agents:
-                        remaining_timeout = embedding_deadline - time.monotonic()
-                        if remaining_timeout <= 0:
+                        remaining_timeout = (
+                            None
+                            if embedding_deadline is None
+                            else embedding_deadline - time.monotonic()
+                        )
+                        if remaining_timeout is not None and remaining_timeout <= 0:
                             break
                         attempt_started_at = time.perf_counter()
                         try:
-                            document = self._run(lambda agent=embedding_agent: coordinator.complete_embeddings_batch(
+                            document = self._run(lambda agent=embedding_agent, wait_timeout=remaining_timeout: coordinator.complete_embeddings_batch(
                                 inputs,
                                 model=agent.model,
                                 attribution=attribution,
                                 metadata={"actor_scope": "inference", "endpoint_alias": "embeddings"},
                                 zdr_only=zdr_only,
                                 agent_id=agent.id,
-                                wait_timeout=remaining_timeout,
+                                wait_timeout=wait_timeout,
                                 owner_id=security.principal_id(self.headers),
                             ))
                         except Exception as exc:  # noqa: BLE001 - measured member failover

tests/test_orchestrator_client_boundaries.py

@@ -236,6 +236,22 @@ def test_batch_results_must_be_a_mapping() -> None:
 # -- local provider slot concurrency ------------------------------------------
 
 
+def test_default_model_timeout_is_unbounded() -> None:
+    """Model and repair requests inherit no application wall-clock cap."""
+    assert ModelClient().timeout is None
+
+
+def test_local_slot_accepts_unbounded_waits() -> None:
+    """The local-agent coordinator preserves the shared unbounded default."""
+    agent = ModelAgent(
+        id="unbounded_slot_agent",
+        model="unbounded-slot-model",
+        base_url="local://127.0.0.1:59343/v1",
+    )
+    with _local_provider_slot(agent, 1, None):
+        pass
+
+
 def test_slot_shrinks_capacity_for_same_model_and_resets_when_empty() -> None:
     """Concurrent same-model holders shrink capacity; last release resets."""
     url = "local://127.0.0.1:59341/v1"

tests/test_provider_embedding_batch_backend.py

@@ -46,6 +46,20 @@ def count_text(self, text, model):
         return len(text.split())
 
 
+def test_default_client_keeps_batch_lifecycle_separate_from_model_timeout() -> None:
+    """A null model timeout does not break the existing batch-retention boundary."""
+    coordinator = CostRoutingCoordinator(
+        TaskOrchestrator([], allow_empty_agents=True),
+        embedding_token_counter=_SyntheticExactCounter(),
+    )
+
+    backend = coordinator._provider_embedding_backend()
+
+    assert backend._execution_timeout_seconds == 604_800
+    assert backend._claim_lease_seconds is None
+    backend.close()
+
+
 def test_unknown_tokenizer_uses_authoritative_provider_usage() -> None:
     """A byte-safe request completes only after the provider supplies exact usage."""
     agent = ModelAgent(