agentensemble 0.4.0__tar.gz → 0.5.0__tar.gz

{agentensemble-0.4.0 → agentensemble-0.5.0}/CHANGELOG.md

@@ -7,6 +7,29 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.5.0] - 2026-10-31
+
+### Added
+- **OpenAI support.** New `OpenAILLMProvider` (LangChain `ChatOpenAI`, native tool calling).
+  Default model `gpt-4.1-mini`, configurable via `OPENAI_MODEL`; `OPENAI_BASE_URL` for
+  OpenAI-compatible endpoints. Temperature is omitted for reasoning models (o-series, gpt-5).
+- `get_default_provider()` / `resolve_provider_name()`: agents now pick OpenAI when
+  `OPENAI_API_KEY` is set, otherwise Mistral; `AGENTENSEMBLE_LLM_PROVIDER` forces one.
+- `agentensemble.utils.get_chat_model()` and `get_openai_model()`; `StructuredAgent` uses the
+  same OpenAI-or-Mistral selection.
+- `langchain-openai` is now a core dependency.
+
+### Fixed
+- Calling a sync agent API twice (e.g. `agent.run()` then `agent.run()`, or `run()` followed by
+  `asyncio.run(agent.arun())`) failed with `RuntimeError: Event loop is closed`. Each sync call
+  uses `asyncio.run()`, and the LLM's async HTTP client stayed bound to the first, closed loop.
+  Providers now rebuild their chat model when used on a new event loop, and each OpenAI model
+  gets its own async HTTP client instead of the process-wide cached one.
+
+### Changed
+- Shared LangChain conversion logic moved to `agentensemble.llm.langchain_base`
+  (`LangChainChatProvider`); `MistralLLMProvider` keeps its public API.
+
 ## [0.4.0] - 2026-10-31
 
 ### Fixed

{agentensemble-0.4.0/agentensemble.egg-info → agentensemble-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentensemble
-Version: 0.4.0
+Version: 0.5.0
 Summary: Build, orchestrate, trace, and test multi-agent LLM systems in Python: ReAct, RAG, router, planner, workflow graphs, swarms, debates, and pipelines.
 Author-email: Irfan Ali <irfanali29@hotmail.com>
 Maintainer-email: Irfan Ali <irfanali29@hotmail.com>
@@ -10,7 +10,7 @@ Project-URL: Documentation, https://github.com/irfanalidv/AgentEnsemble#readme
 Project-URL: Repository, https://github.com/irfanalidv/AgentEnsemble
 Project-URL: Issues, https://github.com/irfanalidv/AgentEnsemble/issues
 Project-URL: Changelog, https://github.com/irfanalidv/AgentEnsemble/blob/main/CHANGELOG.md
-Keywords: ai-agents,multi-agent,multi-agent-systems,agent-orchestration,orchestration,llm,langchain,langgraph,mistral,rag,react-agent,tool-calling,function-calling,agent-testing,agentic-ai,state-graph,workflow,tracing
+Keywords: ai-agents,multi-agent,multi-agent-systems,agent-orchestration,orchestration,llm,langchain,langgraph,mistral,openai,rag,react-agent,tool-calling,function-calling,agent-testing,agentic-ai,state-graph,workflow,tracing
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Science/Research
@@ -31,6 +31,7 @@ Requires-Dist: langchain>=1.1.0
 Requires-Dist: langchain-core>=1.0.0
 Requires-Dist: langchain-community>=0.3.0
 Requires-Dist: langchain-mistralai>=0.2.0
+Requires-Dist: langchain-openai>=1.0.0
 Requires-Dist: pydantic>=2.0.0
 Requires-Dist: typing-extensions>=4.5.0
 Requires-Dist: python-dotenv>=1.0.0
@@ -121,15 +122,29 @@ print(graph.run("What is multi-agent AI?")["result"])
 # Summary for: What is multi-agent AI?
 ```
 
-LLM-powered agents (`ReActAgent`, `HybridAgent`, `RouterAgent`, `StructuredAgent`) use Mistral by
-default. Set `MISTRAL_API_KEY`, or pass any `LLMProvider` implementation via `llm=...`.
+LLM-powered agents (`ReActAgent`, `HybridAgent`, `RouterAgent`, `StructuredAgent`) work with
+**OpenAI** or **Mistral**. The provider is picked from your environment: OpenAI if
+`OPENAI_API_KEY` is set, otherwise Mistral if `MISTRAL_API_KEY` is set. You can also pass any
+`LLMProvider` explicitly via `llm=...`:
+
+```python
+from agentensemble import ReActAgent
+from agentensemble.llm import OpenAILLMProvider, MistralLLMProvider
+
+agent = ReActAgent(tools=[...], llm=OpenAILLMProvider(model="gpt-4.1-mini"))
+agent = ReActAgent(tools=[...], llm=MistralLLMProvider(model="mistral-small-latest"))
+```
 
 ## Configuration
 
 | Variable | Purpose |
 | --- | --- |
-| `MISTRAL_API_KEY` | Required for the default Mistral LLM provider (ReAct, Hybrid, Router, Structured agents). |
+| `OPENAI_API_KEY` | Enables the OpenAI provider (preferred when set). |
+| `OPENAI_MODEL` | Optional default model for `OpenAILLMProvider` (default: `gpt-4.1-mini`). Reasoning models such as `gpt-5-mini` work too; temperature is left at the API default for them. |
+| `OPENAI_BASE_URL` | Optional OpenAI-compatible endpoint (Azure OpenAI proxy, vLLM, LM Studio, ...). |
+| `MISTRAL_API_KEY` | Enables the Mistral provider (used when no OpenAI key is set). |
 | `MISTRAL_MODEL` | Optional default model for `MistralLLMProvider` (default: `mistral-large-latest`). Use e.g. `mistral-small-latest` if your plan doesn't include the large model. |
+| `AGENTENSEMBLE_LLM_PROVIDER` | Optional. Force `openai` or `mistral` when both keys are set. |
 | `SERPER_API_KEY` | Optional. When set, `SearchTool()` uses Serper; otherwise it falls back to DuckDuckGo (needs the `search` extra). |
 
 Copy `.env.example` to `.env` and fill in your keys (`KEY=value`, no spaces around `=`); the
@@ -144,7 +159,7 @@ Without an API key, LLM agents can still be constructed (and inspected or regist
 
 - **Modular** — Agents, tools, orchestration, and memory are decoupled
 - **Async-first** — `run()` and `arun()` on all agents; parallel execution via `asyncio.gather`
-- **Provider-agnostic** — LLM interface supports Mistral (OpenAI/Anthropic-ready)
+- **Provider-agnostic** — one LLM interface, OpenAI and Mistral built in
 - **Production patterns** — Runner, retries, hooks, tracing, session memory
 
 ---
@@ -196,7 +211,7 @@ Without an API key, LLM agents can still be constructed (and inspected or regist
 
 ```bash
 pip install "agentensemble[search]"
-export MISTRAL_API_KEY=...
+export OPENAI_API_KEY=...      # or: export MISTRAL_API_KEY=...
 ```
 
 ```python
@@ -213,7 +228,7 @@ print(result["result"])
 
 ## Examples — Code + Output
 
-Each example is runnable. Requires `MISTRAL_API_KEY` (and the `search` extra for `SearchTool`; `SERPER_API_KEY` is optional). Outputs below are from the author's runs; LLM answers will vary.
+Each example is runnable. Requires `OPENAI_API_KEY` or `MISTRAL_API_KEY` (and the `search` extra for `SearchTool`; `SERPER_API_KEY` is optional). Outputs below are from the author's runs; LLM answers will vary.
 
 ---
 
@@ -697,7 +712,7 @@ Runs all demos with real API calls.
 agentensemble/
 ├── agents/         # ReAct, StateGraph, RAG, Hybrid, Structured
 ├── core/           # AgentProtocol, RunnableProtocol
-├── llm/            # LLMProvider, MistralLLMProvider
+├── llm/            # LLMProvider, OpenAILLMProvider, MistralLLMProvider, get_default_provider
 ├── memory/         # Session, InMemorySession, SQLiteSession
 ├── orchestration/  # Ensemble, Supervisor, Swarm, Pipeline, Debate
 ├── tools/          # Tool protocol, @function_tool, built-ins
@@ -715,7 +730,7 @@ agentensemble/
 
 | Feature            | AgentEnsemble             | LangGraph    | CrewAI | AutoGen |
 | ------------------ | ------------------------- | ------------ | ------ | ------- |
-| Multi-provider LLM | Mistral (extensible)      | Any          | Any    | Any     |
+| Multi-provider LLM | OpenAI, Mistral (extensible) | Any          | Any    | Any     |
 | Async API          | `arun()` everywhere       | Yes          | Yes    | Yes     |
 | Router agents      | RouterAgent               | Manual       | Yes    | Manual  |
 | Planner pattern    | PlannerAgent              | Manual       | Yes    | Manual  |

{agentensemble-0.4.0 → agentensemble-0.5.0}/README.md

@@ -62,15 +62,29 @@ print(graph.run("What is multi-agent AI?")["result"])
 # Summary for: What is multi-agent AI?
 ```
 
-LLM-powered agents (`ReActAgent`, `HybridAgent`, `RouterAgent`, `StructuredAgent`) use Mistral by
-default. Set `MISTRAL_API_KEY`, or pass any `LLMProvider` implementation via `llm=...`.
+LLM-powered agents (`ReActAgent`, `HybridAgent`, `RouterAgent`, `StructuredAgent`) work with
+**OpenAI** or **Mistral**. The provider is picked from your environment: OpenAI if
+`OPENAI_API_KEY` is set, otherwise Mistral if `MISTRAL_API_KEY` is set. You can also pass any
+`LLMProvider` explicitly via `llm=...`:
+
+```python
+from agentensemble import ReActAgent
+from agentensemble.llm import OpenAILLMProvider, MistralLLMProvider
+
+agent = ReActAgent(tools=[...], llm=OpenAILLMProvider(model="gpt-4.1-mini"))
+agent = ReActAgent(tools=[...], llm=MistralLLMProvider(model="mistral-small-latest"))
+```
 
 ## Configuration
 
 | Variable | Purpose |
 | --- | --- |
-| `MISTRAL_API_KEY` | Required for the default Mistral LLM provider (ReAct, Hybrid, Router, Structured agents). |
+| `OPENAI_API_KEY` | Enables the OpenAI provider (preferred when set). |
+| `OPENAI_MODEL` | Optional default model for `OpenAILLMProvider` (default: `gpt-4.1-mini`). Reasoning models such as `gpt-5-mini` work too; temperature is left at the API default for them. |
+| `OPENAI_BASE_URL` | Optional OpenAI-compatible endpoint (Azure OpenAI proxy, vLLM, LM Studio, ...). |
+| `MISTRAL_API_KEY` | Enables the Mistral provider (used when no OpenAI key is set). |
 | `MISTRAL_MODEL` | Optional default model for `MistralLLMProvider` (default: `mistral-large-latest`). Use e.g. `mistral-small-latest` if your plan doesn't include the large model. |
+| `AGENTENSEMBLE_LLM_PROVIDER` | Optional. Force `openai` or `mistral` when both keys are set. |
 | `SERPER_API_KEY` | Optional. When set, `SearchTool()` uses Serper; otherwise it falls back to DuckDuckGo (needs the `search` extra). |
 
 Copy `.env.example` to `.env` and fill in your keys (`KEY=value`, no spaces around `=`); the
@@ -85,7 +99,7 @@ Without an API key, LLM agents can still be constructed (and inspected or regist
 
 - **Modular** — Agents, tools, orchestration, and memory are decoupled
 - **Async-first** — `run()` and `arun()` on all agents; parallel execution via `asyncio.gather`
-- **Provider-agnostic** — LLM interface supports Mistral (OpenAI/Anthropic-ready)
+- **Provider-agnostic** — one LLM interface, OpenAI and Mistral built in
 - **Production patterns** — Runner, retries, hooks, tracing, session memory
 
 ---
@@ -137,7 +151,7 @@ Without an API key, LLM agents can still be constructed (and inspected or regist
 
 ```bash
 pip install "agentensemble[search]"
-export MISTRAL_API_KEY=...
+export OPENAI_API_KEY=...      # or: export MISTRAL_API_KEY=...
 ```
 
 ```python
@@ -154,7 +168,7 @@ print(result["result"])
 
 ## Examples — Code + Output
 
-Each example is runnable. Requires `MISTRAL_API_KEY` (and the `search` extra for `SearchTool`; `SERPER_API_KEY` is optional). Outputs below are from the author's runs; LLM answers will vary.
+Each example is runnable. Requires `OPENAI_API_KEY` or `MISTRAL_API_KEY` (and the `search` extra for `SearchTool`; `SERPER_API_KEY` is optional). Outputs below are from the author's runs; LLM answers will vary.
 
 ---
 
@@ -638,7 +652,7 @@ Runs all demos with real API calls.
 agentensemble/
 ├── agents/         # ReAct, StateGraph, RAG, Hybrid, Structured
 ├── core/           # AgentProtocol, RunnableProtocol
-├── llm/            # LLMProvider, MistralLLMProvider
+├── llm/            # LLMProvider, OpenAILLMProvider, MistralLLMProvider, get_default_provider
 ├── memory/         # Session, InMemorySession, SQLiteSession
 ├── orchestration/  # Ensemble, Supervisor, Swarm, Pipeline, Debate
 ├── tools/          # Tool protocol, @function_tool, built-ins
@@ -656,7 +670,7 @@ agentensemble/
 
 | Feature            | AgentEnsemble             | LangGraph    | CrewAI | AutoGen |
 | ------------------ | ------------------------- | ------------ | ------ | ------- |
-| Multi-provider LLM | Mistral (extensible)      | Any          | Any    | Any     |
+| Multi-provider LLM | OpenAI, Mistral (extensible) | Any          | Any    | Any     |
 | Async API          | `arun()` everywhere       | Yes          | Yes    | Yes     |
 | Router agents      | RouterAgent               | Manual       | Yes    | Manual  |
 | Planner pattern    | PlannerAgent              | Manual       | Yes    | Manual  |

{agentensemble-0.4.0 → agentensemble-0.5.0}/agentensemble/__init__.py

@@ -9,7 +9,7 @@ from importlib.metadata import PackageNotFoundError, version
 try:
     __version__ = version("agentensemble")
 except PackageNotFoundError:  # running from a source checkout without installation
-    __version__ = "0.4.0"
+    __version__ = "0.5.0"
 __author__ = "Irfan Ali"
 
 # Core imports

{agentensemble-0.4.0 → agentensemble-0.5.0}/agentensemble/agents/hybrid_agent.py

@@ -9,17 +9,9 @@ import asyncio
 from typing import Any
 
 from agentensemble.agents.base import AgentState, BaseAgent
+from agentensemble.llm.factory import get_default_provider
 from agentensemble.llm.interface import LLMMessage, LLMProvider, ToolSchema
 
-try:
-    from agentensemble.llm.mistral_provider import MistralLLMProvider
-
-    LLM_AVAILABLE = True
-except ImportError:
-    LLM_AVAILABLE = False
-    MistralLLMProvider = None
-
-
 # Routing tool: LLM chooses next action via function calling
 ROUTE_ACTION_SCHEMA = ToolSchema(
     name="choose_next_action",
@@ -66,16 +58,16 @@ class HybridAgent(BaseAgent):
             tools: Available tools (search, rag, validator)
             max_iterations: Maximum iterations
             early_stopping: Enable early stopping when answer found
-            llm: LLM provider for routing (default: MistralLLMProvider if available).
+            llm: LLM provider for routing (default: OpenAI or Mistral, picked from the environment).
                  If None, uses fixed pipeline: SEARCH -> RAG -> VALIDATE -> ANSWER
             **kwargs: Additional configuration
         """
         super().__init__(name, tools, max_iterations, **kwargs)
         self.early_stopping = early_stopping
         self.llm = llm
-        if self.llm is None and LLM_AVAILABLE and MistralLLMProvider:
+        if self.llm is None:
             try:
-                self.llm = MistralLLMProvider(temperature=0.2)
+                self.llm = get_default_provider(temperature=0.2)
             except (ValueError, ImportError):
                 self.llm = None  # Fall back to fixed pipeline if no API key
 

{agentensemble-0.4.0 → agentensemble-0.5.0}/agentensemble/agents/react_agent.py

@@ -28,13 +28,7 @@ except ImportError:
     TraceEvent = None
     estimate_cost = None
 
-try:
-    from agentensemble.llm.mistral_provider import MistralLLMProvider
-
-    LLM_AVAILABLE = True
-except ImportError:
-    LLM_AVAILABLE = False
-    MistralLLMProvider = None
+from agentensemble.llm.factory import get_default_provider
 
 
 class ReActAgent(BaseAgent):
@@ -61,16 +55,16 @@ class ReActAgent(BaseAgent):
             name: Agent name
             tools: Available tools (SearchTool, RAGTool, FunctionTool, etc.)
             max_iterations: Maximum reasoning/acting cycles
-            llm: LLM provider (default: MistralLLMProvider if available)
+            llm: LLM provider (default: OpenAI or Mistral, picked from the environment)
             session: Optional Session for multi-turn conversation history
             **kwargs: Additional configuration
         """
         super().__init__(name, tools, max_iterations, **kwargs)
         self.llm = llm
         self.session = session
-        if self.llm is None and LLM_AVAILABLE and MistralLLMProvider:
+        if self.llm is None:
             try:
-                self.llm = MistralLLMProvider(temperature=0.2)
+                self.llm = get_default_provider(temperature=0.2)
             except (ValueError, ImportError):
                 # No API key yet: the agent can still be constructed and inspected;
                 # run()/stream() raise a clear RuntimeError until an LLM is available.
@@ -117,7 +111,7 @@ class ReActAgent(BaseAgent):
         """Stream events during ReAct loop."""
         if self.llm is None:
             raise RuntimeError(
-                "LLM required for ReActAgent. Install langchain-mistralai and set MISTRAL_API_KEY."
+                "LLM required for ReActAgent. Set OPENAI_API_KEY or MISTRAL_API_KEY, or pass llm=."
             )
 
         state = AgentState(query=query, context=kwargs.get("context", {}))
@@ -277,7 +271,7 @@ class ReActAgent(BaseAgent):
         """Async ReAct loop: Reason -> Act -> Observe until final answer."""
         if self.llm is None:
             raise RuntimeError(
-                "LLM required for ReActAgent. Install langchain-mistralai and set MISTRAL_API_KEY, "
+                "LLM required for ReActAgent. Set OPENAI_API_KEY or MISTRAL_API_KEY, or pass llm=, "
                 "or pass llm=YourLLMProvider()."
             )
 

{agentensemble-0.4.0 → agentensemble-0.5.0}/agentensemble/agents/structured_agent.py

@@ -14,13 +14,7 @@ from typing import Any
 
 from pydantic import BaseModel
 
-try:
-    from agentensemble.utils.llm import get_mistral_model
-
-    LLM_AVAILABLE = True
-except ImportError:
-    LLM_AVAILABLE = False
-    get_mistral_model = None
+from agentensemble.utils.llm import get_chat_model
 
 # Try langchain>=1.1 approach (create_agent with response_format)
 try:
@@ -72,15 +66,9 @@ class StructuredAgent:
             system_prompt: System prompt for the agent
             **kwargs: Additional configuration
         """
-        if not LLM_AVAILABLE:
-            raise ImportError(
-                "langchain-mistralai is required for StructuredAgent. "
-                "Install with: pip install langchain-mistralai"
-            )
-
         self.name = name
         self.tools = tools or []
-        self.model = model or get_mistral_model()
+        self.model = model or get_chat_model(temperature=0.2)
         self.response_format = response_format
         self.system_prompt = system_prompt
         self.config = kwargs

{agentensemble-0.4.0 → agentensemble-0.5.0}/agentensemble/llm/__init__.py

@@ -2,12 +2,13 @@
 LLM Provider Interface
 
 Provider-agnostic LLM abstraction for agent reasoning and tool calling.
-Supports Mistral, OpenAI, Anthropic, and local models via a unified interface.
+Ships OpenAI and Mistral providers; any LangChain chat model can be wrapped the same way.
 
 Architecture: Clean separation between provider-specific implementations
 and agent logic. Enables multi-provider support without vendor lock-in.
 """
 
+from agentensemble.llm.factory import get_default_provider, resolve_provider_name
 from agentensemble.llm.interface import (
     LLMMessage,
     LLMProvider,
@@ -24,6 +25,14 @@ except ImportError:
     MISTRAL_AVAILABLE = False
     MistralLLMProvider = None
 
+try:
+    from agentensemble.llm.openai_provider import OpenAILLMProvider
+
+    OPENAI_AVAILABLE = True
+except ImportError:
+    OPENAI_AVAILABLE = False
+    OpenAILLMProvider = None
+
 __all__ = [
     "LLMProvider",
     "LLMMessage",
@@ -32,4 +41,8 @@ __all__ = [
     "ToolSchema",
     "MistralLLMProvider",
     "MISTRAL_AVAILABLE",
+    "OpenAILLMProvider",
+    "OPENAI_AVAILABLE",
+    "get_default_provider",
+    "resolve_provider_name",
 ]

agentensemble-0.5.0/agentensemble/llm/factory.py

@@ -0,0 +1,63 @@
+"""
+Default LLM provider selection.
+
+Order of precedence:
+1. ``AGENTENSEMBLE_LLM_PROVIDER`` env var ("openai" or "mistral"), if set.
+2. OpenAI, if ``OPENAI_API_KEY`` is set.
+3. Mistral, if ``MISTRAL_API_KEY`` is set.
+"""
+
+import os
+from typing import Any
+
+from agentensemble.llm.interface import LLMProvider
+
+PROVIDERS = ("openai", "mistral")
+
+
+def _build(name: str, temperature: float, **kwargs: Any) -> LLMProvider:
+    if name == "openai":
+        from agentensemble.llm.openai_provider import OpenAILLMProvider
+
+        return OpenAILLMProvider(temperature=temperature, **kwargs)
+    if name == "mistral":
+        from agentensemble.llm.mistral_provider import MistralLLMProvider
+
+        return MistralLLMProvider(temperature=temperature, **kwargs)
+    raise ValueError(f"Unknown LLM provider: {name!r}. Supported: {', '.join(PROVIDERS)}")
+
+
+def resolve_provider_name() -> str | None:
+    """Return the provider that ``get_default_provider`` would use, or None if no key is set."""
+    explicit = os.getenv("AGENTENSEMBLE_LLM_PROVIDER", "").strip().lower()
+    if explicit:
+        return explicit
+    if os.getenv("OPENAI_API_KEY"):
+        return "openai"
+    if os.getenv("MISTRAL_API_KEY"):
+        return "mistral"
+    return None
+
+
+def get_default_provider(
+    temperature: float = 0.2, provider: str | None = None, **kwargs: Any
+) -> LLMProvider:
+    """
+    Build the default LLM provider from the environment.
+
+    Args:
+        temperature: Sampling temperature passed to the provider.
+        provider: Force a provider ("openai" or "mistral") instead of auto-detecting.
+        **kwargs: Passed to the provider constructor (e.g. ``model=``).
+
+    Raises:
+        ValueError: If no provider can be determined or its API key is missing.
+        ImportError: If the provider's LangChain integration is not installed.
+    """
+    name = (provider or resolve_provider_name() or "").lower()
+    if not name:
+        raise ValueError(
+            "No LLM provider configured. Set OPENAI_API_KEY or MISTRAL_API_KEY "
+            "(or AGENTENSEMBLE_LLM_PROVIDER), or pass llm= explicitly."
+        )
+    return _build(name, temperature, **kwargs)

agentensemble-0.4.0/agentensemble/llm/mistral_provider.py → agentensemble-0.5.0/agentensemble/llm/langchain_base.py

@@ -1,13 +1,27 @@
 """
-Mistral LLM Provider
+Shared LangChain plumbing for chat-model providers.
 
-Implements LLMProvider using Mistral AI via LangChain.
-Uses bind_tools for native function calling (preferred over text parsing).
+Converts between AgentEnsemble's provider-agnostic message/tool models and
+LangChain's chat-model API. Concrete providers (Mistral, OpenAI) only need to
+build the underlying LangChain chat model.
 """
 
+import asyncio
 import json
 from typing import Any
 
+from langchain_core.messages import (
+    AIMessage,
+    BaseMessage,
+    HumanMessage,
+    SystemMessage,
+    ToolMessage,
+)
+from langchain_core.messages import (
+    ToolCall as LCToolCall,
+)
+from langchain_core.runnables import Runnable
+
 from agentensemble.llm.interface import (
     LLMMessage,
     LLMProvider,
@@ -16,30 +30,9 @@ from agentensemble.llm.interface import (
     ToolSchema,
 )
 
-try:
-    from langchain_core.messages import (
-        AIMessage,
-        BaseMessage,
-        HumanMessage,
-        SystemMessage,
-        ToolMessage,
-    )
-    from langchain_core.messages import (
-        ToolCall as LCToolCall,
-    )
-    from langchain_core.runnables import Runnable
-    from langchain_mistralai import ChatMistralAI
-
-    LANGCHAIN_AVAILABLE = True
-except ImportError:
-    LANGCHAIN_AVAILABLE = False
-    ChatMistralAI = None
-    LCToolCall = None
-    Runnable = None
-
 
 def _tool_schema_to_langchain(schema: ToolSchema) -> dict[str, Any]:
-    """Convert ToolSchema to OpenAI-style format for Mistral."""
+    """Convert ToolSchema to OpenAI-style function format (also accepted by Mistral)."""
     return {
         "type": "function",
         "function": {
@@ -52,7 +45,7 @@ def _tool_schema_to_langchain(schema: ToolSchema) -> dict[str, Any]:
     }
 
 
-def _messages_to_langchain(messages: list[LLMMessage]) -> list["BaseMessage"]:
+def _messages_to_langchain(messages: list[LLMMessage]) -> list[BaseMessage]:
     """Convert LLMMessage list to LangChain format."""
     result: list[BaseMessage] = []
     for msg in messages:
@@ -86,7 +79,7 @@ def _messages_to_langchain(messages: list[LLMMessage]) -> list["BaseMessage"]:
     return result
 
 
-def _extract_usage(msg: "AIMessage") -> dict[str, int] | None:
+def _extract_usage(msg: AIMessage) -> dict[str, int] | None:
     """Extract token usage from LangChain AIMessage (usage_metadata or response_metadata)."""
     um = getattr(msg, "usage_metadata", None)
     if um and isinstance(um, dict):
@@ -96,7 +89,7 @@ def _extract_usage(msg: "AIMessage") -> dict[str, int] | None:
             "total_tokens": um.get("total_tokens", 0),
         }
     rm = getattr(msg, "response_metadata", None) or {}
-    usage = rm.get("usage") or rm.get("usage_metadata") or {}
+    usage = rm.get("usage") or rm.get("usage_metadata") or rm.get("token_usage") or {}
     if usage:
         return {
             "input_tokens": usage.get("input_tokens", usage.get("prompt_tokens", 0)),
@@ -129,7 +122,7 @@ def _parse_ai_message(msg: AIMessage) -> LLMResponse:
                     args = {}
             tool_calls.append(
                 ToolCall(
-                    id=tc_id,
+                    id=tc_id or "",
                     name=tc_name,
                     arguments=args if isinstance(args, dict) else {},
                 )
@@ -143,71 +136,57 @@ def _parse_ai_message(msg: AIMessage) -> LLMResponse:
     )
 
 
-class MistralLLMProvider(LLMProvider):
+class LangChainChatProvider(LLMProvider):
     """
-    Mistral AI provider using LangChain's ChatMistralAI.
+    Base provider wrapping any LangChain chat model that supports ``bind_tools``.
 
-    Uses bind_tools for native function calling—cleaner than
-    THOUGHT/ACTION/PAUSE text parsing (LangChain 2024 best practice).
+    Subclasses implement ``_build_model()``, call ``_init_model()`` at the end of
+    ``__init__``, set ``self.model_name``, and may override ``REQUIRED_TOOL_CHOICE``
+    with the provider's spelling of "must call a tool".
+
+    Async HTTP clients are bound to the event loop they were first used on. The sync
+    agent APIs call ``asyncio.run()`` (a fresh loop per call), so the model is rebuilt
+    whenever ``agenerate`` runs on a different loop than last time.
     """
 
-    def __init__(
-        self,
-        model: str | None = None,
-        temperature: float = 0.2,
-        api_key: str | None = None,
-        **kwargs: Any,
-    ):
-        """
-        Initialize Mistral provider.
-
-        Args:
-            model: Model name (e.g., mistral-large-latest, mistral-small-latest). Defaults to
-                the ``MISTRAL_MODEL`` env var, else ``mistral-large-latest``.
-            temperature: Lower = more deterministic (0.2 recommended for tool use)
-            api_key: Mistral API key (defaults to MISTRAL_API_KEY env)
-            **kwargs: Passed to ChatMistralAI
-        """
-        if not LANGCHAIN_AVAILABLE:
-            raise ImportError(
-                "langchain-mistralai and langchain-core required. "
-                "Install: pip install langchain-mistralai langchain-core"
-            )
+    #: Value sent to the API when callers ask for ``tool_choice="required"``.
+    REQUIRED_TOOL_CHOICE: str = "required"
 
-        import os
+    _model: Any
+    _model_loop: asyncio.AbstractEventLoop | None = None
+    model_name: str
 
-        model = model or os.getenv("MISTRAL_MODEL") or "mistral-large-latest"
-        key = api_key or os.getenv("MISTRAL_API_KEY")
-        if not key:
-            raise ValueError("MISTRAL_API_KEY required. Set in .env or pass api_key.")
+    def _build_model(self) -> Any:
+        """Create the underlying LangChain chat model."""
+        raise NotImplementedError
 
-        self._model = ChatMistralAI(
-            model=model,
-            temperature=temperature,
-            mistral_api_key=key,
-            **kwargs,
-        )
-        self.model_name = model
+    def _init_model(self) -> None:
+        self._model = self._build_model()
+        self._model_loop = None
+
+    def _ensure_model_for_running_loop(self) -> None:
+        loop = asyncio.get_running_loop()
+        if self._model_loop is loop:
+            return
+        if self._model_loop is not None:
+            self._model = self._build_model()
+        self._model_loop = loop
 
     def _bind_tools(
         self,
         tools: list[ToolSchema] | None = None,
         tool_choice: str | None = None,
-    ) -> "Runnable":
+    ) -> Runnable:
         """Bind tools to model for function calling."""
         if not tools:
             return self._model
 
         tool_defs = [_tool_schema_to_langchain(t) for t in tools]
-        bound = self._model.bind_tools(tool_defs)
-
-        if tool_choice == "required" and tools:
-            # Mistral: use "any" to force tool use (required -> any per Mistral API)
-            bound = bound.bind(tool_choice="any")
-        elif tool_choice and tool_choice != "auto":
-            bound = bound.bind(tool_choice=tool_choice)
-
-        return bound
+        if tool_choice == "required":
+            return self._model.bind_tools(tool_defs, tool_choice=self.REQUIRED_TOOL_CHOICE)
+        if tool_choice and tool_choice != "auto":
+            return self._model.bind_tools(tool_defs, tool_choice=tool_choice)
+        return self._model.bind_tools(tool_defs)
 
     def generate(
         self,
@@ -230,6 +209,7 @@ class MistralLLMProvider(LLMProvider):
         **kwargs: Any,
     ) -> LLMResponse:
         """Async generation with optional tool calling."""
+        self._ensure_model_for_running_loop()
         lc_messages = _messages_to_langchain(messages)
         bound = self._bind_tools(tools, tool_choice)
         response = await bound.ainvoke(lc_messages, **kwargs)