fix(agent): stream LLM completions to avoid gateway idle-timeout

[sebastianbraun25]

Problem

openkb's wiki compiler (openkb/agent/compiler.py) calls litellm.completion() /
litellm.acompletion() in buffered (non-streaming) mode. On a long-running compile
step (large documents, many concepts, verbose models), some corporate LLM gateways
sitting in front of the actual provider enforce an idle timeout on buffered
requests: if no bytes are sent back to the client for N seconds while the gateway
waits for the upstream provider to finish generating the full response, the
gateway kills the connection with a Gateway Timeout, even though the underlying
provider call would have eventually succeeded.

This was observed against a corporate AI.proxy gateway (OpenAI-compatible,
deployed at AWS): any step whose completion took longer than the gateway's idle
window failed with a timeout purely because of buffering, not because the model
was slow to start responding.

Root Cause

_llm_call() and _llm_call_async() in openkb/agent/compiler.py call
litellm.completion() / litellm.acompletion() without stream=True. A buffered
request produces zero bytes on the wire until the entire response is ready, so an
idle-timeout gateway watching for connection activity can't distinguish "still
generating" from "connection died" and kills it.

Solution / Changes

• openkb/agent/compiler.py:
  • _llm_call() and _llm_call_async() now call litellm.completion() /
    litellm.acompletion() with stream=True, so bytes keep flowing over the
    connection as tokens arrive.
  • New _merge_stream_chunks() helper merges the streamed chunks back into the
    same non-streaming response shape the rest of the compiler already expects
    (response.choices[0].message.content, response.usage,
    response.choices[0].finish_reason), using LiteLLM's own
    litellm.stream_chunk_builder() for genuine multi-chunk streams.
  • An exception raised mid-stream (e.g. a dropped connection) propagates as a
    complete failure — list(stream) never returns a partial buffer, matching
    the prior all-or-nothing behavior of a failed litellm.completion() call.
  • This is a straight swap to streaming-only; there is no stream=True/False
    config toggle.
• tests/test_compiler.py: _mock_completion()/_mock_acompletion() (and the
  handful of inline mocks that built their own fake response) now return a
  single-chunk fake stream ([mock_resp]) instead of a bare response object,
  matching the new stream=True call signature.
• tests/test_llm_timeout.py: same adjustment for its litellm.completion/
  acompletion mocks.

Backward compatible: no config/CLI surface changes, callers of _llm_call/
_llm_call_async see the same return type and response shape as before.

Issues

Resolves #235.