language-model-common 3.0.4__tar.gz → 3.0.6__tar.gz

{language_model_common-3.0.4/language_model_common.egg-info → language_model_common-3.0.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: language-model-common
-Version: 3.0.4
+Version: 3.0.6
 Summary: Provides the underlying framework to enhance langchain and add loading configurations
 Author-email: Imran Qureshi <imran.qureshi@bwell.com>
 License: Apache-2.0
@@ -21,7 +21,7 @@ Requires-Dist: openai>=2.5.0
 Requires-Dist: langchain-openai>=1.1.6
 Requires-Dist: langgraph>=1.0.0
 Requires-Dist: pydantic<3.0.0,>=2.0
-Requires-Dist: mcp>=1.27.2
+Requires-Dist: mcp>=2.2.0
 Requires-Dist: langgraph-checkpoint>=3.0.0
 Requires-Dist: langgraph-checkpoint-mongodb>=0.3.1
 Requires-Dist: langgraph-store-mongodb>=0.1.0

language_model_common-3.0.6/VERSION

@@ -0,0 +1 @@
+3.0.6

{language_model_common-3.0.4 → language_model_common-3.0.6/language_model_common.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: language-model-common
-Version: 3.0.4
+Version: 3.0.6
 Summary: Provides the underlying framework to enhance langchain and add loading configurations
 Author-email: Imran Qureshi <imran.qureshi@bwell.com>
 License: Apache-2.0
@@ -21,7 +21,7 @@ Requires-Dist: openai>=2.5.0
 Requires-Dist: langchain-openai>=1.1.6
 Requires-Dist: langgraph>=1.0.0
 Requires-Dist: pydantic<3.0.0,>=2.0
-Requires-Dist: mcp>=1.27.2
+Requires-Dist: mcp>=2.2.0
 Requires-Dist: langgraph-checkpoint>=3.0.0
 Requires-Dist: langgraph-checkpoint-mongodb>=0.3.1
 Requires-Dist: langgraph-store-mongodb>=0.1.0

{language_model_common-3.0.4 → language_model_common-3.0.6}/language_model_common.egg-info/requires.txt

@@ -8,7 +8,7 @@ openai>=2.5.0
 langchain-openai>=1.1.6
 langgraph>=1.0.0
 pydantic<3.0.0,>=2.0
-mcp>=1.27.2
+mcp>=2.2.0
 langgraph-checkpoint>=3.0.0
 langgraph-checkpoint-mongodb>=0.3.1
 langgraph-store-mongodb>=0.1.0

{language_model_common-3.0.4 → language_model_common-3.0.6}/languagemodelcommon/converters/langgraph_to_openai_converter.py

@@ -139,6 +139,7 @@ class LangGraphToOpenAIConverter(StreamContextMixin):
 
     _RATE_LIMIT_PATTERNS: tuple[str, ...] = (
         "too many tokens",
+        "too many requests",
         "rate limit",
         "rate_limit",
         "error code: 429",
@@ -150,7 +151,12 @@ class LangGraphToOpenAIConverter(StreamContextMixin):
 
         Detects structurally rather than importing a specific vendor SDK: a
         ``status_code``/``code`` of 429, a class named ``*RateLimitError*``
-        (Anthropic, OpenAI), or a recognizable message pattern.
+        (Anthropic, OpenAI) or ``*ThrottlingException*`` (boto3/botocore Bedrock
+        Converse client), or a recognizable message pattern. Covers both Bedrock
+        client paths language-model-common can construct (BAI-765) — the
+        Anthropic SDK's "too many tokens" wording and botocore's "too many
+        requests"/``ThrottlingException`` wording were previously handled by
+        separate, inconsistent checks in different call sites.
         """
         current: BaseException | None = exception
         while current is not None:
@@ -159,7 +165,10 @@ class LangGraphToOpenAIConverter(StreamContextMixin):
                 or getattr(current, "code", None) == 429
             ):
                 return True
-            if "ratelimiterror" in current.__class__.__name__.lower():
+            class_name = current.__class__.__name__.lower()
+            if class_name.endswith("ratelimiterror") or class_name.endswith(
+                "throttlingexception"
+            ):
                 return True
             msg = str(current).lower()
             if any(p in msg for p in LangGraphToOpenAIConverter._RATE_LIMIT_PATTERNS):
@@ -756,6 +765,18 @@ class LangGraphToOpenAIConverter(StreamContextMixin):
             config=config,
         )
         runtime_context = {"user_id": request_information.user_id}
+
+        # Deliberately no app-level retry-with-backoff here (unlike
+        # _stream_graph_with_messages_async's pre-first-token retry): a single
+        # ainvoke() call can span multiple graph steps (tool calls) with real
+        # side effects (e.g. writes via MCP tools), persisted through an
+        # optional checkpointer keyed by conversation_thread_id. Re-invoking
+        # the whole graph on a rate limit raised partway through a turn risks
+        # re-executing already-committed, non-idempotent tool calls (BAI-765
+        # review). Bedrock-level retry for a single throttled model call is
+        # instead handled at the SDK layer via ModelFactory's max_retries
+        # (see aws_bedrock_max_retries), which only retries the specific node
+        # that was throttled, not the whole graph.
         try:
             output: Dict[str, Any] = await compiled_state_graph.ainvoke(
                 input=input_,
@@ -767,16 +788,16 @@ class LangGraphToOpenAIConverter(StreamContextMixin):
             logger.exception("AttributeError in throttling handling")
             raise
         except Exception as e:
-            # Try to catch ThrottlingException dynamically
-            if (
-                hasattr(e, "__class__")
-                and e.__class__.__name__ == "ThrottlingException"
-            ):
-                logger.exception("AWS ThrottlingException: %s", e)
+            if self._is_rate_limit_error(e):
+                logger.exception(
+                    "Rate limited. request_id=%s error=%s",
+                    request_information.request_id,
+                    e,
+                )
                 raise HTTPException(
                     status_code=429,
                     detail="AWS request throttled. Please try again later.",
-                )
+                ) from e
             raise
         out_messages: List[AnyMessage] = output["messages"]
         return out_messages
@@ -898,14 +919,18 @@ class LangGraphToOpenAIConverter(StreamContextMixin):
         """Compute backoff delay for a rate-limit retry.
 
         Honors an upstream ``Retry-After`` hint when present; otherwise uses
-        exponential backoff with full jitter based on the configured base delay.
+        exponential backoff with full jitter based on the configured base
+        delay. Both branches are clamped to rate_limit_max_backoff_seconds
+        (BAI-765 review) so an unreasonable/malicious upstream Retry-After
+        value can't hang a request-handling coroutine indefinitely.
         """
+        max_delay_seconds = self.environment_variables.rate_limit_max_backoff_seconds
         if retry_after_seconds is not None and retry_after_seconds > 0:
-            return retry_after_seconds
+            return min(retry_after_seconds, max_delay_seconds)
         base_delay_seconds = (
             self.environment_variables.rate_limit_retry_base_delay_ms / 1000.0
         )
-        exponential_delay = base_delay_seconds * (2**attempt)
+        exponential_delay = min(base_delay_seconds * (2**attempt), max_delay_seconds)
         # Full jitter: random point in [0, exponential_delay] avoids thundering herd.
         return random.uniform(0, exponential_delay)
 

{language_model_common-3.0.4 → language_model_common-3.0.6}/languagemodelcommon/mcp/interceptors/types.py

@@ -7,17 +7,22 @@ from collections.abc import Awaitable, Callable
 from dataclasses import dataclass, replace
 from typing import Any, Protocol, Self, runtime_checkable
 
-from mcp.types import CallToolResult
+from mcp.types import CallToolResult, InputRequiredResult, InputResponses
 from typing_extensions import NotRequired, TypedDict, Unpack
 
-# Result type — matches what interceptors and handlers return.
-MCPToolCallResult = CallToolResult
+# Result type — matches what interceptors and handlers return. Widened for
+# SEP-2322: a guard-tool-gated tool may return InputRequiredResult instead
+# of a terminal CallToolResult.
+MCPToolCallResult = CallToolResult | InputRequiredResult
 
 
 class _MCPToolCallRequestOverrides(TypedDict, total=False):
     name: NotRequired[str]
     args: NotRequired[dict[str, Any]]
     headers: NotRequired[dict[str, Any] | None]
+    input_responses: NotRequired["InputResponses | None"]
+    request_state: NotRequired[str | None]
+    allow_input_required: NotRequired[bool]
 
 
 @dataclass
@@ -28,6 +33,17 @@ class MCPToolCallRequest:
         name: Tool name to invoke.
         args: Tool arguments as key-value pairs.
         headers: HTTP headers for applicable transports.
+        input_responses: Answers to a prior call's InputRequiredResult
+            (SEP-2322 guard-tool retry). None on a first-round call.
+        request_state: Opaque state echoed from a prior InputRequiredResult.
+            Must be passed through byte-exact; never inspected here.
+        allow_input_required: Whether the caller is prepared to receive an
+            InputRequiredResult instead of a terminal CallToolResult.
+            Defaults to False so existing callers that don't handle
+            InputRequiredResult keep getting the pre-SEP-2322 behavior
+            (session.call_tool raises instead of returning one). Only
+            callers that actually check isinstance(result,
+            InputRequiredResult) should set this to True.
 
     Context fields (read-only, for routing/logging):
         server_name: Name of the MCP server handling the tool.
@@ -37,6 +53,9 @@ class MCPToolCallRequest:
     args: dict[str, Any]
     server_name: str
     headers: dict[str, Any] | None = None
+    input_responses: InputResponses | None = None
+    request_state: str | None = None
+    allow_input_required: bool = False
 
     def override(self, **overrides: Unpack[_MCPToolCallRequestOverrides]) -> Self:
         return replace(self, **overrides)

{language_model_common-3.0.4 → language_model_common-3.0.6}/languagemodelcommon/mcp/mcp_client/langchain_adapter.py

@@ -4,6 +4,7 @@ import re
 from typing import Any
 
 from langchain_core.tools import BaseTool, StructuredTool
+from mcp.types import InputRequest, InputRequiredResult
 from mcp.types import Tool as MCPTool
 
 from languagemodelcommon.mcp.callbacks import Callbacks, CallbackContext, _MCPCallbacks
@@ -27,6 +28,68 @@ from languagemodelcommon.mcp.mcp_client.tool_list_cache import ToolListCache
 _INVALID_TOOL_NAME_CHARS = re.compile(r"[^a-zA-Z0-9_-]")
 
 
+class MCPInputRequiredError(RuntimeError):
+    """Raised when an MCP tool call returns InputRequiredResult (SEP-2322
+    guard-tool ask) instead of a terminal CallToolResult.
+
+    Carries everything a caller needs to resubmit the *exact same* call via
+    ``call_mcp_tool_raw`` once it has collected an answer to
+    ``input_requests`` -- this package has no opinion on how that answer is
+    collected (a human-in-the-loop UI, a LangGraph ``interrupt()``, or
+    anything else); it only guarantees the retry leg has what it needs.
+
+    Deliberately a plain ``RuntimeError`` subclass, not ``BaseException``:
+    unlike mcp-fhir-agent's server-side ``ElicitationRequired`` (which must
+    survive broad `except Exception` handlers several call layers below the
+    tool function), this exception is raised directly at the LangChain tool
+    boundary with no intermediate layer *in this package* that could swallow
+    it -- this package makes no guarantee beyond its own boundary.
+
+    IMPORTANT -- this is the caller's responsibility, not something this
+    package can enforce: if you execute this tool's coroutine through a
+    framework that wraps tool execution in its own broad, default
+    exception-to-error-message conversion, that framework's handling sits
+    between this raise site and any "top-level catcher" you may have and
+    WILL swallow this exception before your code ever sees it. The primary
+    example is LangGraph's prebuilt ``ToolNode``, whose default
+    ``handle_tool_errors=True`` wraps every tool call in `except Exception`
+    and converts it to a generic error ``ToolMessage``, discarding
+    ``input_requests``/``request_state`` in the process. If you wire this
+    tool into a ``ToolNode``-style executor, you MUST catch
+    ``MCPInputRequiredError`` yourself at or before the point where that
+    framework invokes the tool -- do not rely on it propagating further up.
+    baileyai's ``wrap_tool_for_guard_tool_bridge``
+    (`baileyai/services/mcp/guard_tool_bridge.py`) is the correct pattern:
+    it catches ``MCPInputRequiredError`` immediately around its own
+    ``await tool.ainvoke(...)`` call, before ``ToolNode`` (or any other
+    framework-level handler) ever gets a chance to intercept it -- see the
+    companion baileyai ADR
+    (`adrs/006-mcp-guard-tool-elicitation-support.md`) for how it's
+    consumed.
+    """
+
+    def __init__(
+        self,
+        *,
+        tool_name: str,
+        arguments: dict[str, Any],
+        connection: "MCPConnectionConfig",
+        server_name: str | None,
+        input_requests: dict[str, InputRequest],
+        request_state: str | None,
+    ) -> None:
+        self.tool_name = tool_name
+        self.arguments = arguments
+        self.connection = connection
+        self.server_name = server_name
+        self.input_requests = input_requests
+        self.request_state = request_state
+        super().__init__(
+            f"MCP tool {tool_name!r} requires input before it can proceed "
+            f"(fields: {sorted(input_requests)})"
+        )
+
+
 def _sanitize_tool_name(name: str) -> str:
     """Replace characters that violate LLM provider tool-name constraints.
 
@@ -99,8 +162,18 @@ def mcp_tool_to_langchain_tool(
             args=arguments,
             server_name=server_name or "unknown",
             headers=None,
+            allow_input_required=True,
         )
         call_tool_result = await handler(request)
+        if isinstance(call_tool_result, InputRequiredResult):
+            raise MCPInputRequiredError(
+                tool_name=tool.name,
+                arguments=arguments,
+                connection=connection,
+                server_name=server_name,
+                input_requests=call_tool_result.input_requests or {},
+                request_state=call_tool_result.request_state,
+            )
         content = convert_call_tool_result(call_tool_result)
         return content, None
 

{language_model_common-3.0.4 → language_model_common-3.0.6}/languagemodelcommon/mcp/mcp_client/tool_invocation.py

@@ -7,7 +7,7 @@ from collections.abc import Awaitable, Callable
 from typing import Any
 
 from langchain_core.callbacks.manager import adispatch_custom_event
-from mcp.types import CallToolResult
+from mcp.types import CallToolResult, InputRequiredResult, InputResponses
 from pydantic import ValidationError
 
 from languagemodelcommon.mcp.callbacks import Callbacks, CallbackContext, _MCPCallbacks
@@ -231,19 +231,37 @@ async def _execute_tool_call_with_heartbeat(
     progress_callback: Any,
     server_name: str,
     heartbeat_interval_seconds: float,
-) -> CallToolResult:
+    input_responses: InputResponses | None = None,
+    request_state: str | None = None,
+    allow_input_required: bool = False,
+) -> CallToolResult | InputRequiredResult:
     """Call ``session.call_tool``, emitting a synthetic ``mcp_tool_heartbeat``
     custom event every ``heartbeat_interval_seconds`` while the call is in
     flight, regardless of whether the tool reports real progress.
 
+    ``input_responses``/``request_state`` are SEP-2322 guard-tool retry
+    fields, forwarded byte-exact to ``session.call_tool``. When
+    ``allow_input_required`` is True, an ``InputRequiredResult`` is returned
+    to the caller instead of raising -- see ``ClientSession.call_tool``'s own
+    docstring for the raise-vs-return contract.
+
     Uses ``asyncio.shield`` so a heartbeat tick's wait_for timeout never
     cancels the underlying tool call -- only the local wait is abandoned and
     retried on the same call_task. If this coroutine itself is cancelled
     (e.g. the overall chat turn is aborted), the inner call_task is
     cancelled too rather than left running in the background.
     """
-    call_task: "asyncio.Task[CallToolResult]" = asyncio.ensure_future(
-        session.call_tool(name, arguments, progress_callback=progress_callback)
+    call_task: "asyncio.Task[CallToolResult | InputRequiredResult]" = (
+        asyncio.ensure_future(
+            session.call_tool(
+                name,
+                arguments,
+                progress_callback=progress_callback,
+                input_responses=input_responses,
+                request_state=request_state,
+                allow_input_required=allow_input_required,
+            )
+        )
     )
     elapsed_seconds = 0.0
     try:
@@ -350,6 +368,9 @@ def _make_execute_tool(
                     progress_callback=mcp_callbacks.progress_callback,
                     server_name=request.server_name,
                     heartbeat_interval_seconds=heartbeat_interval_seconds,
+                    input_responses=request.input_responses,
+                    request_state=request.request_state,
+                    allow_input_required=request.allow_input_required,
                 )
             except Exception:
                 await session_pool.evict(effective_config)
@@ -363,6 +384,7 @@ def _make_execute_tool(
             effective_config, mcp_callbacks=mcp_callbacks
         ) as session:
             await session.initialize()
+            result: CallToolResult | InputRequiredResult
             try:
                 if await _tool_supports_tasks(
                     session=session,
@@ -392,6 +414,9 @@ def _make_execute_tool(
                             progress_callback=mcp_callbacks.progress_callback,
                             server_name=request.server_name,
                             heartbeat_interval_seconds=heartbeat_interval_seconds,
+                            input_responses=request.input_responses,
+                            request_state=request.request_state,
+                            allow_input_required=request.allow_input_required,
                         )
                 else:
                     result = await _execute_tool_call_with_heartbeat(
@@ -401,6 +426,9 @@ def _make_execute_tool(
                         progress_callback=mcp_callbacks.progress_callback,
                         server_name=request.server_name,
                         heartbeat_interval_seconds=heartbeat_interval_seconds,
+                        input_responses=request.input_responses,
+                        request_state=request.request_state,
+                        allow_input_required=request.allow_input_required,
                     )
             except Exception as e:
                 captured_exception = e
@@ -423,11 +451,24 @@ async def call_mcp_tool_raw(
     session_pool: McpSessionPool | None = None,
     tool_list_cache: ToolListCache | None = None,
     heartbeat_interval_seconds: float = 15.0,
-) -> CallToolResult:
-    """Call an MCP tool and return the raw CallToolResult.
+    input_responses: InputResponses | None = None,
+    request_state: str | None = None,
+    allow_input_required: bool = False,
+) -> MCPToolCallResult:
+    """Call an MCP tool and return the raw CallToolResult (or, for a
+    guard-tool-gated tool, an InputRequiredResult).
 
     This is used by the call_tool meta-tool to proxy calls without
-    converting to LangChain format.
+    converting to LangChain format, and by callers resubmitting a SEP-2322
+    guard-tool answer (``input_responses``/``request_state``) directly,
+    bypassing the LangChain tool-call path entirely since the retry leg
+    isn't driven by a fresh LLM tool call.
+
+    ``allow_input_required`` defaults to False so existing callers that
+    don't handle ``InputRequiredResult`` keep getting the pre-SEP-2322
+    behavior: the underlying session raises rather than returning one.
+    Pass True only if the caller actually checks
+    ``isinstance(result, InputRequiredResult)``.
     """
     mcp_callbacks = (
         callbacks.to_mcp_format(
@@ -452,5 +493,8 @@ async def call_mcp_tool_raw(
         args=arguments,
         server_name=server_name,
         headers=None,
+        input_responses=input_responses,
+        request_state=request_state,
+        allow_input_required=allow_input_required,
     )
     return await handler(request)

{language_model_common-3.0.4 → language_model_common-3.0.6}/languagemodelcommon/models/model_factory.py

@@ -199,6 +199,36 @@ class ModelFactory:
 
         model_parameters_dict = dict(model_parameters_dict)
 
+        if "max_retries" not in model_parameters_dict:
+            max_attempts = (
+                self._environment_variables.aws_bedrock_max_retries
+                if self._environment_variables
+                else None
+            )
+            if max_attempts is not None:
+                # aws_bedrock_max_retries returns boto3 max_attempts semantics
+                # (total attempts including the first, matching
+                # AwsClientFactory.create_bedrock_client's Converse client
+                # config), but ChatAnthropicBedrock's max_retries kwarg counts
+                # only retries *after* the first attempt. Convert so the same
+                # env var value yields the same total attempt count on both
+                # Bedrock client paths (BAI-765 review).
+                max_retries = max(0, max_attempts - 1)
+                model_parameters_dict["max_retries"] = max_retries
+                source_env_var = (
+                    "AWS_BEDROCK_MAX_ATTEMPTS"
+                    if os.environ.get("AWS_BEDROCK_MAX_ATTEMPTS")
+                    else "AWS_BEDROCK_MAX_RETRIES"
+                )
+                logger.info(
+                    "Using %s=%d (max_retries=%d) for Anthropic Bedrock client %s "
+                    "(overriding langchain_aws's hardcoded default of 2; BAI-765)",
+                    source_env_var,
+                    max_attempts,
+                    max_retries,
+                    model_name,
+                )
+
         if "max_tokens" not in model_parameters_dict:
             resolved_max_tokens = self._resolve_anthropic_bedrock_max_tokens(
                 model_name=model_name

{language_model_common-3.0.4 → language_model_common-3.0.6}/languagemodelcommon/utilities/environment/language_model_common_environment_variables.py

@@ -264,6 +264,17 @@ class LanguageModelCommonEnvironmentVariables(
         """Base delay in milliseconds for rate-limit retry exponential backoff."""
         return int(os.environ.get("RATE_LIMIT_RETRY_BASE_DELAY_MS", "500"))
 
+    @property
+    def rate_limit_max_backoff_seconds(self) -> float:
+        """Upper bound on a single rate-limit retry delay, in seconds.
+
+        Applies to both the exponential-backoff and upstream Retry-After
+        branches of _compute_rate_limit_backoff, so an unreasonable or
+        malicious Retry-After header value can't hang a request-handling
+        coroutine indefinitely (BAI-765 review).
+        """
+        return float(os.environ.get("RATE_LIMIT_MAX_BACKOFF_SECONDS", "60"))
+
     @property
     def mongo_db_token_collection_name(self) -> Optional[str]:
         return os.environ.get("MONGO_DB_TOKEN_COLLECTION_NAME")
@@ -357,6 +368,30 @@ class LanguageModelCommonEnvironmentVariables(
     def aws_bedrock_retry_mode(self) -> str:
         return os.environ.get("AWS_BEDROCK_RETRY_MODE", "adaptive")
 
+    @property
+    def aws_bedrock_max_retries(self) -> Optional[int]:
+        """Max Bedrock call attempts, in boto3 max_attempts semantics (total
+        attempts including the first).
+
+        Shares AWS_BEDROCK_MAX_ATTEMPTS/AWS_BEDROCK_MAX_RETRIES with
+        AwsClientFactory.create_bedrock_client's boto3 retry config (BAI-765).
+        Despite this property's name, the returned value is *attempts*, not
+        *retries* — callers that hand it to an SDK using retries-after-first
+        semantics (e.g. ChatAnthropicBedrock's max_retries kwarg) must convert
+        it (max(0, value - 1)) to keep total attempt counts consistent across
+        Bedrock client paths (BAI-765 review). Returns None when unset so
+        callers keep the underlying SDK's own default instead of forcing one.
+        """
+        value = os.environ.get("AWS_BEDROCK_MAX_ATTEMPTS") or os.environ.get(
+            "AWS_BEDROCK_MAX_RETRIES"
+        )
+        if value is None or value.strip() == "":
+            return None
+        try:
+            return int(value)
+        except ValueError:
+            return None
+
     @property
     def aws_credentials_profile(self) -> Optional[str]:
         return os.environ.get("AWS_CREDENTIALS_PROFILE")

{language_model_common-3.0.4 → language_model_common-3.0.6}/pyproject.toml

@@ -28,7 +28,7 @@ dependencies = [
     "langchain-openai>=1.1.6",
     "langgraph>=1.0.0",
     "pydantic>=2.0,<3.0.0",
-    "mcp>=1.27.2",
+    "mcp>=2.2.0",
     "langgraph-checkpoint>=3.0.0",
     "langgraph-checkpoint-mongodb>=0.3.1",
     "langgraph-store-mongodb>=0.1.0",

language_model_common-3.0.4/VERSION

@@ -1 +0,0 @@
-3.0.4