polyllmkit 0.1.0__py3-none-any.whl

llmkit/__init__.py

@@ -0,0 +1,20 @@
+"""llmkit — a streaming LLM bridge + markdown rendering toolkit.
+
+Two independent subpackages, disjoint dependency graphs:
+
+  :mod:`llmkit.bridge`  streaming chat/complete over an OpenAI-compatible
+                        endpoint (or the Claude Agent SDK), with a
+                        reasoning/content stream splitter, output sinks,
+                        and a typed provider/profile config parser. Install
+                        with ``llmkit[bridge]`` (+ ``[claude]`` for the
+                        claude_code adapter).
+  :mod:`llmkit.md`      render markdown to a terminal: one-shot, live
+                        streaming (rich), or a scrollable modal (textual).
+                        Install with ``llmkit[md]``.
+
+Extracted from the zsh-ai plugin; nothing here knows about zsh, zle, or
+any host shell — the surface is plain argv/stdin in, streamed bytes out,
+plus a dataclass API underneath.
+"""
+
+__version__ = "0.1.0"

llmkit/bridge/__init__.py

@@ -0,0 +1,52 @@
+"""llmkit.bridge — streaming chat/complete bridge + typed config.
+
+Talks to any OpenAI-compatible HTTP endpoint (via the openai SDK), natively to
+the Anthropic Messages API / Google Gemini API, or the Claude Agent SDK. A
+stream splitter separates reasoning ("thinking") from content so callers can
+route them to different consumers.
+
+The reusable surface is the dataclass API: build a :class:`Provider`, then
+call :func:`chat` / :func:`complete`. The flag CLI (``python -m
+llmkit.bridge``) is one adapter over it. Adapter capabilities are queryable —
+:func:`adapter_supports_complete` / :func:`provider_supports_complete` /
+:func:`profile_supports_complete` answer "is FIM available here?" up front, so
+a consumer can disable a FIM widget for chat-only adapters rather than failing
+at call time.
+"""
+
+from .bridge import (
+    ADAPTERS,
+    ChatRequest,
+    CompleteRequest,
+    adapter_supports_complete,
+    chat,
+    chat_structured,
+    chat_to_str,
+    complete,
+    profile_supports_complete,
+    provider_supports_complete,
+    with_defaults,
+)
+from .config import Config, ConfigParser, Provider, TomlValue, load
+
+__all__ = [
+    # config
+    "Config",
+    "ConfigParser",
+    "Provider",
+    "TomlValue",
+    "load",
+    # runtime
+    "ChatRequest",
+    "CompleteRequest",
+    "chat",
+    "chat_to_str",
+    "chat_structured",
+    "complete",
+    "with_defaults",
+    # adapter capabilities (queryable up front)
+    "ADAPTERS",
+    "adapter_supports_complete",
+    "provider_supports_complete",
+    "profile_supports_complete",
+]

llmkit/bridge/__main__.py

@@ -0,0 +1,11 @@
+"""``python -m llmkit.bridge`` → :func:`.cli.main`."""
+
+import sys
+
+from .cli import main
+
+if __name__ == "__main__":
+    try:
+        sys.exit(main())
+    except BrokenPipeError:
+        sys.exit(0)

llmkit/bridge/adapters/__init__.py

@@ -0,0 +1,14 @@
+"""Chat producers — one per transport backend.
+
+Each exposes a ``stream_*(provider, request, emitter)`` callable matching
+:data:`llmkit.bridge.bridge.Producer`, translating the bridge's generic
+request into that backend's native message/streaming format. Imported lazily
+by :func:`llmkit.bridge.bridge.chat` so the default openai path never pays for
+an optional dependency (anthropic / google-genai / claude-agent-sdk).
+
+Backends: ``openai`` (openai-compatible HTTP), ``anthropic`` (native Messages
+API), ``google`` (native Gemini API), ``claude_code`` (Claude Agent SDK). The
+native HTTP adapters take a custom ``endpoint``, so any provider reachable over
+one of these protocols — e.g. an OpenCode Zen gateway — is supported by
+pointing the provider's endpoint at it.
+"""

llmkit/bridge/adapters/anthropic.py

@@ -0,0 +1,154 @@
+"""``anthropic`` chat producer — native Anthropic Messages API, streamed.
+
+Distinct from ``claude_code`` (which routes through the Claude Agent SDK / the
+``claude`` CLI's auth): this talks straight to the Messages API via the
+``anthropic`` Python SDK, so it honours the provider's ``api_key`` /
+``api_key_env`` and ``max_tokens`` directly.
+
+Format differences from the openai-compatible path this copes with:
+
+* ``system`` is a top-level request field, not a ``role: system`` message.
+* Reasoning arrives as ``thinking`` content-block deltas, not a
+  ``reasoning_content`` field on the chat delta.
+* Sampling params are NOT forwarded — current Anthropic models (Opus 4.8/4.7,
+  Sonnet 5, Fable 5) reject ``temperature`` / ``top_p`` with a 400, and govern
+  sampling internally. Steer behaviour through the prompt instead.
+* Thinking is configured via the ``thinking`` request param (adaptive only on
+  current models — ``budget_tokens`` is removed), not ``chat_template_kwargs``.
+* ``endpoint`` follows the SAME ``/v1``-style convention as the openai adapter
+  (e.g. ``https://opencode.ai/zen/v1/messages`` from a gateway's docs, or
+  ``http://host/v1``), but the SDK owns the ``/v1/messages`` suffix — it appends
+  it to ``base_url``. So the ``/v1...`` tail is stripped here before handing the
+  host base to the SDK (else it would double to ``.../v1/v1/messages``). See
+  :func:`_base_url`.
+
+The SDK is an OPTIONAL dependency, imported here so the default
+openai-compatible path never requires it.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+from typing import Any, Optional
+from urllib.parse import urlsplit, urlunsplit
+
+from ..bridge import DEFAULT_ENDPOINT, ChatRequest, _Emitter
+from ..client import resolved_headers
+from ..config import Provider
+
+
+def _base_url(endpoint: str) -> str:
+    """Derive the anthropic SDK ``base_url`` from a configured endpoint.
+
+    The SDK appends ``/v1/messages`` to ``base_url``, so a ``/v1``-style
+    endpoint — the openai-adapter convention, and what gateway docs list (e.g.
+    OpenCode Zen's ``https://opencode.ai/zen/v1/messages``) — must have its
+    ``/v1...`` tail dropped or the request URL doubles to ``.../v1/v1/messages``.
+    Keep scheme, host, and any path prefix *before* the first ``v1`` path
+    segment; an endpoint with no ``v1`` segment (``https://api.anthropic.com``)
+    is returned unchanged. ``v1`` in the host (``https://v1.example.com``) is
+    untouched — only path segments are considered.
+    """
+    parts = urlsplit(endpoint)
+    segs = parts.path.split("/")
+    path = "/".join(segs[: segs.index("v1")]) if "v1" in segs else parts.path.rstrip("/")
+    return urlunsplit((parts.scheme, parts.netloc, path, "", ""))
+
+
+def _require_sdk() -> Any:
+    """Import the SDK or exit(2) with an actionable install hint."""
+    try:
+        import anthropic  # type: ignore[import-not-found]
+    except ImportError:
+        print(
+            "llmkit: the anthropic adapter needs the Anthropic SDK. "
+            "Install it with `pip install llmkit[anthropic]` (or `pip install "
+            "anthropic`).",
+            file=sys.stderr,
+        )
+        raise SystemExit(2)
+    return anthropic
+
+
+def _resolve_api_key(provider: Provider) -> Optional[str]:
+    """Resolve an explicit key, or None to let the SDK read its own env
+    (``ANTHROPIC_API_KEY`` / an ``ant auth login`` profile)."""
+    if provider.api_key_env:
+        return os.environ.get(provider.api_key_env) or None
+    return provider.api_key or None
+
+
+def _thinking_config(flag: Optional[str]) -> dict[str, Any]:
+    """Map the bridge's auto|true|false onto the Messages API ``thinking`` param.
+
+    Matches ``claude_code``'s mapping rather than the openai adapter's: the
+    native API's only on-mode is adaptive, so both ``auto`` and ``true`` enable
+    adaptive thinking — ``auto`` does NOT collapse to off. ``display`` is
+    ``summarized`` so reasoning actually streams (current models default it to
+    ``omitted`` — empty thinking text). ``false`` disables it.
+
+    NB: adaptive requires a 4.6+ model — don't pair it with an older one.
+    """
+    if flag == "false":
+        return {"type": "disabled"}
+    return {"type": "adaptive", "display": "summarized"}
+
+
+def stream_anthropic(
+    provider: Provider, request: ChatRequest, emitter: _Emitter
+) -> None:
+    anthropic = _require_sdk()
+
+    kwargs: dict[str, Any] = dict(
+        api_key=_resolve_api_key(provider),
+    )
+    # The bridge fills endpoint with the openai/ollama default; only forward an
+    # endpoint the user actually customised (an Anthropic-compatible gateway),
+    # normalised to the host base the SDK wants (see _base_url).
+    if provider.endpoint and provider.endpoint != DEFAULT_ENDPOINT:
+        kwargs["base_url"] = _base_url(provider.endpoint)
+    headers = resolved_headers(provider)
+    if headers:
+        kwargs["default_headers"] = headers
+    client = anthropic.Anthropic(**kwargs)
+
+    create: dict[str, Any] = dict(
+        model=provider.model,
+        max_tokens=provider.max_tokens,
+        messages=[{"role": "user", "content": request.user}],
+    )
+    if request.system:
+        create["system"] = request.system
+    # Structured output → a single forced tool whose input_schema IS the caller's
+    # schema; the model must fill it. Its ``input_json_delta`` stream is routed to
+    # the content sink, so downstream capture (chat_to_str/chat_structured) sees the
+    # conformant JSON where free-form text would otherwise be. Forced tool-use and
+    # extended thinking are mutually exclusive, so thinking is disabled here.
+    structured = request.schema is not None
+    if structured:
+        create["tools"] = [{
+            "name": request.schema_name,
+            "description": request.schema_description or "Return the result.",
+            "input_schema": request.schema,
+        }]
+        create["tool_choice"] = {"type": "tool", "name": request.schema_name}
+        create["thinking"] = {"type": "disabled"}
+    else:
+        create["thinking"] = _thinking_config(provider.enable_thinking)
+
+    with client.messages.stream(**create) as stream:
+        for event in stream:
+            # Any event is a sign of life — fire TTFT before the first non-empty
+            # delta (mirrors the openai adapter's explicit signal).
+            emitter.signal_streaming()
+            if event.type != "content_block_delta":
+                continue
+            delta = event.delta
+            dt = getattr(delta, "type", None)
+            if dt == "text_delta":
+                emitter.feed_content(getattr(delta, "text", "") or "")
+            elif dt == "input_json_delta":   # forced-tool structured output
+                emitter.feed_content(getattr(delta, "partial_json", "") or "")
+            elif dt == "thinking_delta":
+                emitter.feed_reasoning(getattr(delta, "thinking", "") or "")

llmkit/bridge/adapters/claude_code.py

@@ -0,0 +1,166 @@
+"""``claude_code`` chat producer — routes the query through the Claude Agent
+SDK instead of an OpenAI-compatible endpoint.
+
+Plain-chat only: every built-in tool is disabled and the agent runs a single
+turn, so it behaves like an ordinary chat completion (no file or shell
+access). Authentication piggybacks on the Claude Code CLI — the user's
+existing ``claude`` login (subscription) or ``ANTHROPIC_API_KEY``, exactly as
+the CLI resolves it. There is no FIM equivalent, so ``complete`` rejects this
+adapter.
+
+The SDK is an OPTIONAL dependency, imported here so the default
+openai-compatible path never requires it. The provider's ``endpoint`` /
+``api_key`` / ``max_tokens`` / ``temperature`` are ignored — the Claude Code
+CLI governs those itself. Only ``model``, the request's ``system``, and
+``enable_thinking`` carry over.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+from typing import Any
+
+from ..bridge import ChatRequest, _Emitter
+from ..config import Provider
+
+
+def _require_sdk() -> Any:
+    """Import the SDK or exit(2) with an actionable install hint."""
+    try:
+        import claude_agent_sdk as sdk  # type: ignore[import-not-found]
+    except ImportError:
+        print(
+            "llmkit: the claude_code adapter needs the Claude Agent SDK. "
+            "Install it with `pip install llmkit[claude]` (or `pip install "
+            "claude-agent-sdk`), and make sure the `claude` CLI is on PATH.",
+            file=sys.stderr,
+        )
+        raise SystemExit(2)
+    return sdk
+
+
+def _thinking_budget() -> int:
+    """Token budget for ``enable_thinking = true`` → the SDK's
+    ``--max-thinking-tokens``. A CAP on extended thinking, not a floor — the
+    model still thinks only as much as the question needs. Decoupled from
+    max_tokens (claude_code ignores that for output). Override via
+    ``$LLMKIT_CLAUDE_THINKING_BUDGET``; floored at the API minimum 1024."""
+    try:
+        n = int(os.environ.get("LLMKIT_CLAUDE_THINKING_BUDGET", "") or 0)
+    except ValueError:
+        n = 0
+    return n if n >= 1024 else 8192
+
+
+def _build_options(sdk: Any, provider: Provider, request: ChatRequest) -> Any:
+    """Assemble ClaudeAgentOptions for a tool-free single-turn chat."""
+    opts: dict[str, Any] = dict(
+        tools=[],  # no built-in tools — plain chat, no file/shell access
+        allowed_tools=[],
+        disallowed_tools=[],
+        max_turns=1,
+        permission_mode="bypassPermissions",
+        include_partial_messages=True,  # token-level streaming deltas
+        setting_sources=[],  # ignore project/user CLAUDE.md, settings, etc.
+    )
+    if provider.model:
+        opts["model"] = provider.model
+    if request.system:
+        opts["system_prompt"] = request.system
+
+    # Map the bridge's auto|true|false onto the SDK thinking config:
+    #   false → disabled (truly off — never "forced on")
+    #   true  → enabled with an explicit budget cap (see _thinking_budget)
+    #   auto  → adaptive: the model scales thinking to the question's difficulty
+    # NB: Claude Code returns SUMMARISED thinking (no raw chain-of-thought),
+    # so expect it terser than a local reasoning model. It does stream token
+    # by token via the partial-message events.
+    # Structured output (a JSON Schema request): use the SDK's NATIVE output_format
+    # (Messages-API shape); the result lands in ResultMessage.structured_output. Force
+    # thinking off — structured output and thinking don't mix (as with forced tool-use).
+    if getattr(request, "schema", None):
+        opts["output_format"] = {"type": "json_schema", "schema": request.schema}
+        opts["thinking"] = {"type": "disabled"}
+        return sdk.ClaudeAgentOptions(**opts)
+
+    flag = provider.enable_thinking or "auto"
+    if flag == "false":
+        opts["thinking"] = {"type": "disabled"}
+    elif flag == "true":
+        opts["thinking"] = {"type": "enabled", "budget_tokens": _thinking_budget()}
+    else:
+        opts["thinking"] = {"type": "adaptive"}
+
+    return sdk.ClaudeAgentOptions(**opts)
+
+
+def _handle_event(ev: Any, emitter: _Emitter) -> bool:
+    """Translate one raw Anthropic stream event into emitter deltas. Returns
+    True if it carried any text/thinking."""
+    if not isinstance(ev, dict) or ev.get("type") != "content_block_delta":
+        return False
+    delta = ev.get("delta") or {}
+    dt = delta.get("type")
+    if dt == "text_delta":
+        emitter.feed_content(delta.get("text", ""))
+        return True
+    if dt == "thinking_delta":
+        emitter.feed_reasoning(delta.get("thinking", ""))
+        return True
+    return False
+
+
+def stream_claude_code(
+    provider: Provider, request: ChatRequest, emitter: _Emitter
+) -> None:
+    """Synchronous producer entry point — runs the async query to completion,
+    raising on any SDK/CLI error for :func:`_run_chat` to report."""
+    sdk = _require_sdk()
+    import anyio  # bundled with the SDK
+
+    anyio.run(_run, sdk, provider, request, emitter)
+
+
+async def _run(
+    sdk: Any, provider: Provider, request: ChatRequest, emitter: _Emitter
+) -> None:
+    options = _build_options(sdk, provider, request)
+    saw_delta = False
+    async for message in sdk.query(prompt=request.user, options=options):
+        if isinstance(message, sdk.StreamEvent):
+            if _handle_event(message.event, emitter):
+                saw_delta = True
+        elif isinstance(message, sdk.AssistantMessage) and not saw_delta:
+            # Fallback for a CLI that doesn't emit partial-message stream
+            # events: emit the assembled blocks once, non-incrementally.
+            for block in message.content:
+                if isinstance(block, sdk.ThinkingBlock):
+                    emitter.feed_reasoning(getattr(block, "thinking", "") or "")
+                elif isinstance(block, sdk.TextBlock):
+                    emitter.feed_content(getattr(block, "text", "") or "")
+
+
+def structured_claude_code(
+    provider: Provider, request: ChatRequest
+) -> "tuple[int, Any]":
+    """Structured output via the SDK's native ``output_format`` (set in
+    ``_build_options`` when the request carries a schema). Runs the single-turn
+    query and returns ``(exit_code, structured_output)`` from the ResultMessage —
+    the parsed object matching the schema, or ``(0, None)`` if the model produced
+    none, or ``(1, None)`` on an SDK-reported error. No text parsing: the CLI does
+    the schema enforcement + JSON parse and hands back a Python object."""
+    sdk = _require_sdk()
+    import anyio  # bundled with the SDK
+
+    out: dict[str, Any] = {"data": None, "error": False}
+
+    async def _run_structured() -> None:
+        options = _build_options(sdk, provider, request)
+        async for message in sdk.query(prompt=request.user, options=options):
+            if isinstance(message, sdk.ResultMessage):
+                out["data"] = getattr(message, "structured_output", None)
+                out["error"] = bool(getattr(message, "is_error", False))
+
+    anyio.run(_run_structured)
+    return (1 if out["error"] else 0), out["data"]

llmkit/bridge/adapters/google.py

@@ -0,0 +1,106 @@
+"""``google`` chat producer — native Google Gemini API, streamed, via the
+official ``google-genai`` SDK.
+
+Format differences from the openai-compatible path this copes with:
+
+* ``system`` is the ``system_instruction`` config field, not a message.
+* The user turn is ``contents``; tuning lives in a ``GenerateContentConfig``.
+* Reasoning ("thought summaries") arrives as content parts flagged
+  ``thought=True``, interleaved with answer parts — not a separate field.
+* ``max_tokens`` is ``max_output_tokens``; thinking is a ``thinking_config``.
+  Unlike current Anthropic models, Gemini accepts ``temperature``, so it IS
+  forwarded here.
+
+Point ``endpoint`` at a Gemini-compatible gateway (e.g. an OpenCode Zen base
+URL) to route through it; leave it at the bridge default to hit Google directly.
+The SDK is an OPTIONAL dependency, imported here so the default
+openai-compatible path never requires it.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+from typing import Any, Optional
+
+from ..bridge import DEFAULT_ENDPOINT, ChatRequest, _Emitter
+from ..client import resolved_headers
+from ..config import Provider
+
+
+def _require_sdk() -> Any:
+    """Import the SDK or exit(2) with an actionable install hint."""
+    try:
+        from google import genai  # type: ignore[import-untyped,import-not-found]
+        from google.genai import types  # type: ignore[import-untyped,import-not-found]
+    except ImportError:
+        print(
+            "llmkit: the google adapter needs the Google GenAI SDK. "
+            "Install it with `pip install llmkit[google]` (or `pip install "
+            "google-genai`).",
+            file=sys.stderr,
+        )
+        raise SystemExit(2)
+    return genai, types
+
+
+def _resolve_api_key(provider: Provider) -> Optional[str]:
+    """Resolve an explicit key, or None to let the SDK read its own env
+    (``GOOGLE_API_KEY`` / ``GEMINI_API_KEY``)."""
+    if provider.api_key_env:
+        return os.environ.get(provider.api_key_env) or None
+    return provider.api_key or None
+
+
+def _thinking_config(types: Any, flag: Optional[str]) -> Optional[Any]:
+    """Map the bridge's auto|true|false onto a ``ThinkingConfig``.
+
+    ``auto`` omits it (model default), matching the openai adapter. ``true``
+    requests dynamic thinking (``thinking_budget=-1``) with thought summaries so
+    reasoning streams. ``false`` disables it (``thinking_budget=0`` — honoured by
+    Flash/Flash-Lite; Pro clamps to its minimum)."""
+    if flag == "false":
+        return types.ThinkingConfig(thinking_budget=0)
+    if flag == "true":
+        return types.ThinkingConfig(include_thoughts=True, thinking_budget=-1)
+    return None  # auto → let the model decide
+
+
+def stream_google(provider: Provider, request: ChatRequest, emitter: _Emitter) -> None:
+    genai, types = _require_sdk()
+
+    client_kwargs: dict[str, Any] = dict(api_key=_resolve_api_key(provider))
+    # The bridge fills endpoint with the openai/ollama default; only forward an
+    # endpoint the user actually customised (a Gemini-compatible gateway).
+    # Custom headers (e.g. a gateway routing key) ride on the same HttpOptions.
+    http_opts: dict[str, Any] = {}
+    if provider.endpoint and provider.endpoint != DEFAULT_ENDPOINT:
+        http_opts["base_url"] = provider.endpoint
+    headers = resolved_headers(provider)
+    if headers:
+        http_opts["headers"] = headers
+    if http_opts:
+        client_kwargs["http_options"] = types.HttpOptions(**http_opts)
+    client = genai.Client(**client_kwargs)
+
+    config = types.GenerateContentConfig(
+        system_instruction=request.system or None,
+        max_output_tokens=provider.max_tokens,
+        temperature=provider.temperature,
+        thinking_config=_thinking_config(types, provider.enable_thinking),
+    )
+
+    for chunk in client.models.generate_content_stream(
+        model=provider.model, contents=request.user, config=config
+    ):
+        emitter.signal_streaming()
+        for candidate in getattr(chunk, "candidates", None) or []:
+            content = getattr(candidate, "content", None)
+            for part in getattr(content, "parts", None) or []:
+                text = getattr(part, "text", None) or ""
+                if not text:
+                    continue
+                if getattr(part, "thought", False):
+                    emitter.feed_reasoning(text)
+                else:
+                    emitter.feed_content(text)

llmkit/bridge/adapters/openai.py

@@ -0,0 +1,60 @@
+"""Default chat producer: OpenAI-compatible chat-completions, streamed."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from ..client import build_client, enable_thinking_extra
+from ..config import Provider
+
+# Imported under TYPE_CHECKING-free runtime: bridge imports this lazily, so a
+# direct import here is fine and avoids a cycle (bridge → adapters, not back).
+from ..bridge import ChatRequest, _Emitter
+
+
+def stream_openai(provider: Provider, request: ChatRequest, emitter: _Emitter) -> None:
+    client = build_client(provider)
+
+    messages = []
+    if request.system:
+        messages.append({"role": "system", "content": request.system})
+    messages.append({"role": "user", "content": request.user})
+
+    # Any-typed so the conditional appends + the **kwargs unpack into openai's
+    # heavily-overloaded create() don't trigger a wall of variance complaints.
+    kwargs: dict[str, Any] = dict(
+        model=provider.model,
+        messages=messages,
+        max_tokens=provider.max_tokens,
+        temperature=provider.temperature,
+    )
+    extra = enable_thinking_extra(provider.enable_thinking)
+    if extra:
+        kwargs["extra_body"] = extra
+    # Structured output → constrain decoding to the caller's JSON Schema; the
+    # filled JSON streams as ordinary content (feed_content below), so capture is
+    # unchanged. Thinking is dropped when structured (mirrors the anthropic path).
+    if request.schema is not None:
+        kwargs["response_format"] = {
+            "type": "json_schema",
+            "json_schema": {"name": request.schema_name, "schema": request.schema},
+        }
+        kwargs.pop("extra_body", None)
+    kwargs["stream"] = True
+
+    for chunk in client.chat.completions.create(**kwargs):
+        if not chunk.choices:
+            continue
+        # Fire "streaming" on the FIRST chunk that has choices — even a
+        # role-only/empty delta: TTFT mitigation cares about *any* sign of
+        # life. feed_content / feed_reasoning ALSO signal, but relying on
+        # them alone would defer this to the first NON-empty delta. So this
+        # explicit call is load-bearing, not redundant.
+        emitter.signal_streaming()
+        delta = chunk.choices[0].delta
+        r = getattr(delta, "reasoning_content", None) or ""
+        c = getattr(delta, "content", None) or ""
+        if r:
+            emitter.feed_reasoning(r)
+        if c:
+            emitter.feed_content(c)