fix: extract LangChain content-block text and apply model parameters after eval

examples/langchain_thinking.py

@@ -0,0 +1,69 @@
+"""
+Example: langchain_messages() against a Claude model with extended thinking turned on.
+
+With thinking on, Anthropic returns ``content`` as a list of blocks — a ``thinking`` block followed
+by a ``text`` block — instead of a plain string. A handler that only reads string content reports
+an empty response for these runs while the tokens are still spent, so this example fails loudly
+when no text comes back.
+
+Anthropic omits thinking from the turn that follows a tool result, so give this a prompt the model
+can answer on its own — a run that goes through the tool loop ends on a plain string and never
+reaches the block-shaped content this exercises.
+
+Usage (via main.py):
+    python main.py langchain-thinking <flag-key> "Reason it out yourself without any tools: what is 17 times 23?"
+"""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from examples.tools import (
+    fetch_launchdarkly_documentation,
+    get_preferences,
+    search_ld_documentation,
+)
+from examples.utils import new_context, write_output
+from launchdarkly_ai_langchain_messages import create_langchain_messages_handler
+from launchdarkly_ai_server import config
+
+# Anthropic requires max_tokens to exceed the thinking budget.
+_THINKING_BUDGET_TOKENS = 1024
+_MAX_TOKENS = 4096
+
+
+async def run(key: str, user_input: str) -> None:
+    from langchain_anthropic import ChatAnthropic
+
+    def build_model(ai_config: Any) -> Any:
+        model = ai_config.get("model") or {}
+        raw = model.get("parameters")
+        parameters: dict[str, Any] = dict(raw) if isinstance(raw, dict) else {}
+        return ChatAnthropic(
+            timeout=None,
+            stop=None,
+            **parameters,
+            model_name=str(model.get("name") or "claude-sonnet-4-5"),
+            thinking={"type": "enabled", "budget_tokens": _THINKING_BUDGET_TOKENS},
+            max_tokens_to_sample=_MAX_TOKENS,
+        )
+
+    response = await config(
+        key=key,
+        handler=create_langchain_messages_handler(llm=build_model),
+        tool_handlers={
+            "get-user-preferences": get_preferences,
+            "search-ld-documentation": search_ld_documentation,
+            "fetch-launchdarkly-documentation": fetch_launchdarkly_documentation,
+        },
+    ).invoke(user_input, new_context(), variables={"user_input": user_input})
+
+    if not (response.response or "").strip():
+        raise RuntimeError(
+            "Model returned no text. A thinking-enabled model returns content as a list of "
+            "blocks, and the handler dropped it."
+        )
+
+    print(json.dumps(response, indent=2, default=str))
+    write_output(response)

main.py

@@ -14,6 +14,7 @@
     python main.py claude-agents            launch-darkly-documentation-summarizer "What is the LaunchDarkly AI SDK?"
     python main.py openai-agents            launch-darkly-documentation-summarizer-open-ai-only "What is the LaunchDarkly AI SDK?"
     python main.py langchain-agents         launch-darkly-documentation-summarizer "What is the LaunchDarkly AI SDK?"
+    python main.py langchain-thinking       launch-darkly-documentation-summarizer-messages-claude "Reason it out yourself without any tools: what is 17 times 23?"
     python main.py native-graph             travel-agent-flow "Book me a flight to Paris"
     python main.py native-graph-langchain   travel-agent-flow "Book me a flight to Paris"
 """
@@ -54,6 +55,7 @@
     "langchain": "examples.langchain_example",
     "langchain-agents": "examples.langchain_agents_example",
     "langchain-messages": "examples.langchain_messages_example",
+    "langchain-thinking": "examples.langchain_thinking",
     "native-graph": "examples.native_graph",
     "native-graph-langchain": "examples.native_graph_langchain",
 }

packages/client/src/launchdarkly_ai_server/__init__.py

@@ -10,6 +10,7 @@
     SpanMessage,
     SpanMessagePart,
     ToolDefinitionInput,
+    lang_chain_content_text,
     lang_chain_finish_reasons,
     lang_chain_span_messages,
     set_input_content_attributes,
@@ -153,6 +154,7 @@
     "create_run_usage",
     "end_span_once",
     "end_unfinished_spans",
+    "lang_chain_content_text",
     "lang_chain_finish_reasons",
     "lang_chain_span_messages",
     "lang_chain_span_usage",

packages/client/src/launchdarkly_ai_server/content.py

@@ -302,7 +302,7 @@ def lang_chain_span_messages(
         msg_type = (
             str(get_type()) if callable(get_type) else str(_get(raw, "type") or "")
         )
-        text = _lang_chain_content_text(_get(raw, "content"))
+        text = lang_chain_content_text(_get(raw, "content"))
 
         if msg_type in ("system", "developer"):
             if text:
@@ -358,7 +358,7 @@ def lang_chain_span_messages(
     return ("\n".join(system) if system else None, converted)
 
 
-def _lang_chain_content_text(content: Any) -> str:
+def lang_chain_content_text(content: Any) -> str:
     """LangChain message content is a string, or a list holding typed blocks and bare strings.
 
     LangChain types it as ``str | list[str | dict]``, so a bare string inside the list is what the

packages/langchain-agents/README.md

@@ -46,6 +46,18 @@ from launchdarkly_ai_langchain_agents import create_langchain_agents_handler
 handler = create_langchain_agents_handler(ChatAnthropic(model="claude-opus-4-5"))
 ```
 
+A constructed instance cannot see flag parameters. Pass a function instead if the model should
+be built after evaluation:
+
+```python
+handler = create_langchain_agents_handler(
+    lambda config: ChatAnthropic(
+        model=config["model"]["name"],
+        **(config["model"].get("parameters") or {}),
+    )
+)
+```
+
 ### Convenience wrapper
 
 ```python

packages/langchain-agents/src/launchdarkly_ai_langchain_agents/handler.py

@@ -21,6 +21,7 @@
     create_run_usage,
     end_span_once,
     end_unfinished_spans,
+    lang_chain_content_text,
     lang_chain_span_messages,
     lang_chain_span_usage,
     parse_template,
@@ -133,23 +134,48 @@ def _build_initial_messages(
     return messages
 
 
+def _model_constructor_kwargs(
+    config: AiConfigRep, fallback_name: str
+) -> dict[str, Any]:
+    raw = (config.get("model") or {}).get("parameters")
+    parameters = dict(raw) if isinstance(raw, dict) else {}
+    parameters["model"] = (config.get("model") or {}).get("name") or fallback_name
+    return parameters
+
+
+def _is_model_factory(llm: Any) -> bool:
+    """LangChain models are callable, so ``callable`` is not enough to spot a factory."""
+    return callable(llm) and not hasattr(llm, "invoke") and not hasattr(llm, "ainvoke")
+
+
 def _make_default_chat_model(config: AiConfigRep) -> Any:
     """
     Instantiate the appropriate LangChain chat model based on ``config.provider.name``.
     Falls back to ``ChatOpenAI`` when the provider is not recognised.
     Requires the matching ``langchain-<provider>`` integration package to be installed.
+    ``model.parameters`` are passed through unchanged.
     """
     import importlib
 
     provider = ((config.get("provider") or {}).get("name") or "openai").lower()
-    model_name = (config.get("model") or {}).get("name", "")
     if provider == "anthropic":
         lc_anthropic = importlib.import_module("langchain_anthropic")
         return lc_anthropic.ChatAnthropic(
-            model=model_name or "claude-3-5-sonnet-20241022"
+            **_model_constructor_kwargs(config, "claude-3-5-sonnet-20241022")
         )
     lc_openai = importlib.import_module("langchain_openai")
-    return lc_openai.ChatOpenAI(model=model_name or "gpt-4o")
+    return lc_openai.ChatOpenAI(**_model_constructor_kwargs(config, "gpt-4o"))
+
+
+async def _resolve_base_model(config: AiConfigRep, llm: Any) -> Any:
+    if llm is None:
+        return _make_default_chat_model(config)
+    if _is_model_factory(llm):
+        model = llm(config)
+        if asyncio.iscoroutine(model):
+            return await model
+        return model
+    return llm
 
 
 def _run_usage_from_messages(messages: list[Any]) -> Any:
@@ -178,6 +204,9 @@ def create_langchain_agents_handler(
 ) -> ProviderHandler:
     """Creates a ``ProviderHandler`` for LangChain via ``create_react_agent``.
 
+    Pass *llm* as a chat model instance, or as a function ``(config) -> model`` that is
+    called after flag evaluation so ``model.parameters`` can be applied unchanged.
+
     Set *capture_content* to put prompts, model output, tool arguments and tool results on the
     emitted spans. It defaults to off. Conversation content is PII, so a run emits only metadata,
     meaning models, token counts, timings and tool names, until a caller asks for more.
@@ -229,9 +258,7 @@ async def _call_impl(
                     system_instructions=system_prompt,
                     messages=lang_chain_span_messages(initial_messages)[1],
                 )
-            base_model = llm
-            if base_model is None:
-                base_model = _make_default_chat_model(config)
+            base_model = await _resolve_base_model(config, llm)
 
             langgraph_prebuilt = importlib.import_module("langgraph.prebuilt")
             create_react_agent = langgraph_prebuilt.create_react_agent
@@ -261,20 +288,11 @@ async def _call_impl(
                 run_usage = span_callbacks.run_usage
 
             last_msg = msgs[-1] if msgs else None
-            output = (
-                (last_msg.content if isinstance(last_msg.content, str) else "")
-                if last_msg
-                else ""
-            )
+            output = lang_chain_content_text(last_msg.content) if last_msg else ""
 
             # Built through the same conversion the chat span uses, not from `output`. A chat model
-            # may return content as a list of blocks, and `output` is deliberately blank for that
-            # case because it is also what this function returns to the caller. Reading it here made
-            # the root record an empty completion while its own chat child held the real text, so the
-            # two spans described the same reply differently.
-            #
-            # The blank return value is a separate question. It predates this work and is not
-            # telemetry, so it stays as it is.
+            # may return content as a list of blocks. Keeping that conversion here preserves
+            # non-text parts in telemetry while the caller-facing output contains visible text.
             set_output_content_attributes(
                 span,
                 capture_content,
@@ -396,9 +414,7 @@ async def _stream_gen(
                 system_instructions=system_prompt,
                 messages=lang_chain_span_messages(initial_messages)[1],
             )
-        base_model = llm
-        if base_model is None:
-            base_model = _make_default_chat_model(config)
+        base_model = await _resolve_base_model(config, llm)
 
         langgraph_prebuilt = importlib.import_module("langgraph.prebuilt")
         create_react_agent = langgraph_prebuilt.create_react_agent
@@ -430,7 +446,7 @@ async def _stream_gen(
                     if usage:
                         run_usage.add(lang_chain_span_usage(usage))
                     if getattr(msg, "type", None) == "ai":
-                        text = msg.content if isinstance(msg.content, str) else ""
+                        text = lang_chain_content_text(msg.content)
                         if text:
                             yield {"type": "chunk", "text": text}
                             full_output = text

packages/langchain-agents/src/launchdarkly_ai_langchain_agents/native_graph.py

@@ -196,9 +196,11 @@ async def _traverse_node(node: GraphNode) -> None:
                 chat_model = model_factory(node)
             else:
                 lc_openai = importlib.import_module("langchain_openai")
-                chat_model = lc_openai.ChatOpenAI(
-                    model=node.config.get("model", {}).get("name", "gpt-4o")
-                )
+                model_cfg = node.config.get("model") or {}
+                raw = model_cfg.get("parameters")
+                kwargs = dict(raw) if isinstance(raw, dict) else {}
+                kwargs["model"] = model_cfg.get("name") or "gpt-4o"
+                chat_model = lc_openai.ChatOpenAI(**kwargs)
 
             regular_tools = _build_node_tools(node, tool_handlers)