simplifying tool configuration

Author: jsonbailey

packages/ai-providers/server-ai-langchain/src/ldai_langchain/langchain_agent_runner.py

@@ -1,6 +1,6 @@
 """LangChain agent runner for LaunchDarkly AI SDK."""
 
-from typing import Any, Dict, List
+from typing import Any, List
 
 from langchain_core.messages import (
     AIMessage,
@@ -21,19 +21,18 @@ class LangChainAgentRunner(AgentRunner):
     AgentRunner implementation for LangChain.
 
     Executes a single-agent loop using a LangChain BaseChatModel with tool calling.
+    The model is expected to have tools already bound to it.
     Returned by LangChainRunnerFactory.create_agent(config, tools).
     """
 
     def __init__(
         self,
         llm: Any,
         instructions: str,
-        tool_definitions: List[Dict[str, Any]],
         tools: ToolRegistry,
     ):
         self._llm = llm
         self._instructions = instructions
-        self._tool_definitions = tool_definitions
         self._tools = tools
 
     async def run(self, input: Any) -> AgentResult:
@@ -51,14 +50,11 @@ async def run(self, input: Any) -> AgentResult:
             messages.append(SystemMessage(content=self._instructions))
         messages.append(HumanMessage(content=str(input)))
 
-        openai_tools = self._build_openai_tools()
-        model = self._llm.bind_tools(openai_tools) if openai_tools else self._llm
-
         raw_response = None
 
         try:
             while True:
-                response: AIMessage = await model.ainvoke(messages)
+                response: AIMessage = await self._llm.ainvoke(messages)
                 raw_response = response
                 messages.append(response)
 
@@ -103,25 +99,6 @@ async def run(self, input: Any) -> AgentResult:
                 metrics=LDAIMetrics(success=False, usage=None),
             )
 
-    def _build_openai_tools(self) -> List[Dict[str, Any]]:
-        """Convert LD tool definitions to OpenAI function-calling format for bind_tools."""
-        tools = []
-        for td in self._tool_definitions:
-            if not isinstance(td, dict):
-                continue
-            if "type" in td:
-                tools.append(td)
-            elif "name" in td:
-                tools.append({
-                    "type": "function",
-                    "function": {
-                        "name": td["name"],
-                        "description": td.get("description", ""),
-                        "parameters": td.get("parameters", {"type": "object", "properties": {}}),
-                    },
-                })
-        return tools
-
     def get_llm(self) -> Any:
         """Return the underlying LangChain LLM."""
         return self._llm

packages/ai-providers/server-ai-langchain/src/ldai_langchain/langchain_helper.py

@@ -2,8 +2,9 @@
 
 from langchain_core.language_models.chat_models import BaseChatModel
 from langchain_core.messages import AIMessage, BaseMessage, HumanMessage, SystemMessage
-from ldai import LDMessage
+from ldai import LDMessage, log
 from ldai.models import AIConfigKind
+from ldai.providers import ToolRegistry
 from ldai.providers.types import LDAIMetrics
 from ldai.tracker import TokenUsage
 
@@ -50,12 +51,18 @@ def convert_messages_to_langchain(
     return result
 
 
-def create_langchain_model(ai_config: AIConfigKind) -> BaseChatModel:
+def create_langchain_model(ai_config: AIConfigKind, tool_registry: Optional[ToolRegistry] = None) -> BaseChatModel:
     """
     Create a LangChain BaseChatModel from a LaunchDarkly AI configuration.
 
+    If the config includes tool definitions and a tool_registry is provided, tools found
+    in the registry are bound to the model. Tools not found in the registry are skipped
+    with a warning. Built-in provider tools (e.g. code_interpreter) are not supported
+    via LangChain's bind_tools abstraction and are skipped with a warning.
+
     :param ai_config: The LaunchDarkly AI configuration
-    :return: A configured LangChain BaseChatModel
+    :param tool_registry: Optional registry mapping tool names to callable implementations
+    :return: A configured LangChain BaseChatModel, with tools bound if applicable
     """
     from langchain.chat_models import init_chat_model
 
@@ -66,19 +73,70 @@ def create_langchain_model(ai_config: AIConfigKind) -> BaseChatModel:
     model_name = model_dict.get('name', '')
     provider = provider_dict.get('name', '')
     parameters = dict(model_dict.get('parameters') or {})
+    tool_definitions = parameters.pop('tools', []) or []
     mapped_provider = map_provider(provider)
 
     # Bedrock requires the foundation provider (e.g. Bedrock:Anthropic) passed in
     # parameters separately from model_provider, which is used for LangChain routing.
     if mapped_provider == 'bedrock_converse' and 'provider' not in parameters:
         parameters['provider'] = provider.removeprefix('bedrock:')
 
-    return init_chat_model(
+    model = init_chat_model(
         model_name,
         model_provider=mapped_provider,
         **parameters,
     )
 
+    if tool_definitions:
+        bindable = _resolve_tools_for_langchain(tool_definitions, tool_registry or {})
+        if bindable:
+            model = model.bind_tools(bindable)
+
+    return model
+
+
+def _resolve_tools_for_langchain(
+    tool_definitions: List[Dict[str, Any]],
+    tool_registry: ToolRegistry,
+) -> List[Dict[str, Any]]:
+    """
+    Match LD tool definitions against a registry, returning function-calling tool dicts
+    for tools that have a callable implementation. Built-in provider tools and tools
+    missing from the registry are skipped with a warning.
+    """
+    bindable = []
+    for td in tool_definitions:
+        if not isinstance(td, dict):
+            continue
+
+        tool_type = td.get('type')
+        if tool_type and tool_type != 'function':
+            log.warning(
+                f"Built-in tool '{tool_type}' is not reliably supported via LangChain's "
+                "bind_tools abstraction and will be skipped. Use a provider-specific runner "
+                "to use built-in provider tools."
+            )
+            continue
+
+        name = td.get('name')
+        if not name:
+            continue
+
+        if name not in tool_registry:
+            log.warning(f"Tool '{name}' is defined in the AI config but was not found in the tool registry; skipping.")
+            continue
+
+        bindable.append({
+            'type': 'function',
+            'function': {
+                'name': name,
+                'description': td.get('description', ''),
+                'parameters': td.get('parameters', {'type': 'object', 'properties': {}}),
+            },
+        })
+
+    return bindable
+
 
 def get_ai_usage_from_response(response: Any) -> Optional[TokenUsage]:
     """

packages/ai-providers/server-ai-langchain/src/ldai_langchain/langchain_runner_factory.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, Optional
 
 from ldai.models import AIConfigKind
 from ldai.providers import AIProvider, ToolRegistry
@@ -36,7 +36,7 @@ def create_model(self, config: AIConfigKind) -> LangChainModelRunner:
         llm = create_langchain_model(config)
         return LangChainModelRunner(llm)
 
-    def create_agent(self, config: Any, tools: Any) -> 'LangChainAgentRunner':
+    def create_agent(self, config: Any, tools: Optional[ToolRegistry] = None) -> 'LangChainAgentRunner':
         """
         Create a configured LangChainAgentRunner for the given AI agent config.
 
@@ -46,11 +46,6 @@ def create_agent(self, config: Any, tools: Any) -> 'LangChainAgentRunner':
         """
         from ldai_langchain.langchain_agent_runner import LangChainAgentRunner
 
-        config_dict = config.to_dict()
-        model_dict = config_dict.get('model') or {}
-        parameters = dict(model_dict.get('parameters') or {})
-        tool_definitions = parameters.pop('tools', []) or []
-        instructions = config.instructions or '' if hasattr(config, 'instructions') else ''
-
-        llm = create_langchain_model(config)
-        return LangChainAgentRunner(llm, instructions, tool_definitions, tools or {})
+        instructions = (config.instructions or '') if hasattr(config, 'instructions') else ''
+        llm = create_langchain_model(config, tool_registry=tools or {})
+        return LangChainAgentRunner(llm, instructions, tools or {})

packages/ai-providers/server-ai-langchain/tests/test_langchain_provider.py

@@ -429,7 +429,6 @@ def test_creates_agent_runner_with_instructions_and_tool_definitions(self):
 
             assert isinstance(result, LangChainAgentRunner)
             assert result._instructions == "You are a helpful assistant."
-            assert len(result._tool_definitions) == 1
 
     def test_creates_agent_runner_with_no_tools(self):
         """Should create LangChainAgentRunner with no tool definitions."""
@@ -450,7 +449,7 @@ def test_creates_agent_runner_with_no_tools(self):
             result = factory.create_agent(mock_ai_config, {})
 
             assert isinstance(result, LangChainAgentRunner)
-            assert result._tool_definitions == []
+            assert result._tools == {}
 
 
 class TestLangChainAgentRunner:
@@ -464,10 +463,9 @@ async def test_runs_agent_and_returns_result_with_no_tool_calls(self):
 
         mock_llm = MagicMock()
         mock_response = AIMessage(content="The answer is 42.")
-        mock_llm.bind_tools = MagicMock(return_value=mock_llm)
         mock_llm.ainvoke = AsyncMock(return_value=mock_response)
 
-        runner = LangChainAgentRunner(mock_llm, "You are helpful.", [], {})
+        runner = LangChainAgentRunner(mock_llm, "You are helpful.", {})
         result = await runner.run("What is the answer?")
 
         assert result.output == "The answer is 42."
@@ -489,13 +487,11 @@ async def test_executes_tool_calls_and_returns_final_response(self):
         second_response = AIMessage(content="It is sunny in Paris.")
 
         mock_llm = MagicMock()
-        mock_llm.bind_tools = MagicMock(return_value=mock_llm)
         mock_llm.ainvoke = AsyncMock(side_effect=[first_response, second_response])
 
         weather_fn = MagicMock(return_value="Sunny, 25°C")
         runner = LangChainAgentRunner(
             mock_llm, "You are helpful.",
-            [{'name': 'get-weather', 'description': 'Get weather', 'parameters': {}}],
             {'get-weather': weather_fn},
         )
         result = await runner.run("What is the weather in Paris?")
@@ -510,10 +506,9 @@ async def test_returns_failure_when_exception_thrown(self):
         from ldai_langchain import LangChainAgentRunner
 
         mock_llm = MagicMock()
-        mock_llm.bind_tools = MagicMock(return_value=mock_llm)
         mock_llm.ainvoke = AsyncMock(side_effect=Exception("LLM Error"))
 
-        runner = LangChainAgentRunner(mock_llm, "", [], {})
+        runner = LangChainAgentRunner(mock_llm, "", {})
         result = await runner.run("Hello")
 
         assert result.output == ""

packages/ai-providers/server-ai-openai/src/ldai_openai/openai_runner_factory.py

@@ -50,6 +50,7 @@ def create_agent_graph(self, graph_def: Any, tools: ToolRegistry) -> Any:
         from ldai_openai.openai_agent_graph_runner import OpenAIAgentGraphRunner
         return OpenAIAgentGraphRunner(graph_def, tools)
 
+
     def create_agent(self, config: Any, tools: Optional[ToolRegistry] = None) -> 'OpenAIAgentRunner':
         """
         Create a configured OpenAIAgentRunner for the given AI agent config.

packages/sdk/server-ai/src/ldai/providers/ai_provider.py

@@ -3,7 +3,7 @@
 
 from ldai import log
 from ldai.models import LDMessage
-from ldai.providers.types import ModelResponse, StructuredResponse
+from ldai.providers.types import ModelResponse, StructuredResponse, ToolRegistry
 
 
 class AIProvider(ABC):
@@ -73,7 +73,7 @@ def create_model(self, config: Any) -> Optional[Any]:
         log.warning('create_model not implemented by this provider')
         return None
 
-    def create_agent(self, config: Any, tools: Any) -> Optional[Any]:
+    def create_agent(self, config: Any, tools: Optional[ToolRegistry] = None) -> Optional[Any]:
         """
         Create a configured agent executor for the given AI config and tool registry.