💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: 2f60526a16

Additional findings (outside current diff — PR may have been updated during review):

• 🟣 langfuse/_client/observe.py:721-734 — This is a pre-existing bug in _ContextPreservedAsyncGeneratorWrapper.__anext__: the inner except TypeError block, intended to detect Python < 3.10 where asyncio.create_task() rejects the context keyword, will also catch any TypeError raised inside the user's async generator body on Python 3.10+. When that happens the exception is silently swallowed, the fallback await self.generator.__anext__() is called on an already-closed generator, which raises StopAsyncIteration, causing the outer handler to call _finalize() and mark the span as successful — so the caller sees a false end-of-stream instead of the actual error. A narrower fix is to probe the Python version once at module level (_ASYNCIO_TASK_CONTEXT_SUPPORTED = sys.version_info >= (3, 10)) and branch on that flag instead of catching TypeError from the task call.

  Extended reasoning...

  What the bug is and how it manifests

  In _ContextPreservedAsyncGeneratorWrapper.__anext__ (observe.py ~721-734) the code uses a try/except pattern to detect whether the running Python version supports the context keyword of asyncio.create_task():

  try:
      item = await asyncio.create_task(
          self.generator.__anext__(), context=self.context
      )
  except TypeError:
      # Python < 3.10 fallback
      item = await self.generator.__anext__()

  On Python 3.10+, asyncio.create_task() fully accepts the context keyword, so any TypeError reaching the except clause can only have come from inside the user's async generator body. That user-facing error is silently swallowed and treated as a compatibility probe failure.

  The specific code path that triggers it

  1. Python >= 3.10 is in use (so create_task(context=...) never raises TypeError itself).
  2. The user's async generator body executes inside the task and raises TypeError (e.g. a type-check failure, bad arithmetic, missing attribute that returns the wrong type, etc.).
  3. The exception propagates from the awaited task to await asyncio.create_task(...).
  4. The inner except TypeError: catches it — incorrectly treating it as the Python < 3.10 compatibility signal.
  5. The fallback await self.generator.__anext__() is called. Because the generator's frame was already unwound by the TypeError, this immediately raises StopAsyncIteration.
  6. The outer except StopAsyncIteration: fires, calls _finalize(), marks the span as successful, and re-raises StopAsyncIteration.
  7. The caller receives StopAsyncIteration — a false end-of-stream signal — and never sees the original TypeError.

  Why existing code does not prevent it

  The except TypeError guard was written for a legitimate purpose (runtime Python version detection) but is too broad. It has no way to distinguish a TypeError that came from create_task's own argument validation versus one that bubbled up from inside the generator coroutine. The outer except (Exception, asyncio.CancelledError) handler that would have correctly called _finalize_with_error() is never reached because the inner handler consumes the exception first.

  What the impact is

  • Any TypeError raised in user generator code is silently lost on Python 3.10+.
  • The associated Langfuse span is recorded as a successful completion rather than an error, so observability data is incorrect and debugging is made significantly harder.
  • The caller receives StopAsyncIteration and may believe the stream ended normally, potentially masking data-integrity issues.

  How to fix it

  Determine Python version support once at module level and branch on that flag instead of catching TypeError:

  _ASYNCIO_TASK_CONTEXT_SUPPORTED = sys.version_info >= (3, 10)
  
  async def __anext__(self) -> Any:
      try:
          if _ASYNCIO_TASK_CONTEXT_SUPPORTED:
              item = await asyncio.create_task(
                  self.generator.__anext__(), context=self.context
              )
          else:
              item = await self.generator.__anext__()
          ...

  This eliminates the ambiguous except TypeError entirely so any exception from the generator body propagates naturally to the outer handlers.

  Step-by-step proof

  async def gen():
      yield 1
      raise TypeError('internal error')   # user code raises TypeError
      yield 2
  
  wrapper = _ContextPreservedAsyncGeneratorWrapper(gen(), ctx, span, True, None)
  
  # Call 1: returns 1 — OK
  item = await wrapper.__anext__()   # → 1
  
  # Call 2 (Python 3.10+):
  #   create_task runs gen.__anext__(), generator raises TypeError('internal error')
  #   → propagates to 'await create_task(...)'
  #   → caught by inner 'except TypeError:'   ← BUG: wrong handler
  #   fallback: await self.generator.__anext__()
  #   → generator is closed, raises StopAsyncIteration
  #   → caught by outer 'except StopAsyncIteration:'
  #   → _finalize() called, span.end() called with no error
  #   → StopAsyncIteration re-raised
  item = await wrapper.__anext__()   # raises StopAsyncIteration  (expected: TypeError)
  # span shows SUCCESS  (expected: ERROR with 'internal error')

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: 9ee80d33d6

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: 03ba99d3a7