language-model-common 2.0.89__tar.gz → 2.0.91__tar.gz

{language_model_common-2.0.89/language_model_common.egg-info → language_model_common-2.0.91}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: language-model-common
-Version: 2.0.89
+Version: 2.0.91
 Summary: Provides the underlying framework to enhance langchain and add loading configurations
 Author-email: Imran Qureshi <imran.qureshi@bwell.com>
 License: Apache-2.0

language_model_common-2.0.91/VERSION

@@ -0,0 +1 @@
+2.0.91

{language_model_common-2.0.89 → language_model_common-2.0.91/language_model_common.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: language-model-common
-Version: 2.0.89
+Version: 2.0.91
 Summary: Provides the underlying framework to enhance langchain and add loading configurations
 Author-email: Imran Qureshi <imran.qureshi@bwell.com>
 License: Apache-2.0

{language_model_common-2.0.89 → language_model_common-2.0.91}/languagemodelcommon/converters/streaming_manager.py

@@ -379,15 +379,6 @@ class LangGraphStreamingManager(StreamContextMixin):
             )
             if chunk:
                 yield chunk
-        elif name == "mcp_tool_heartbeat":
-            data = dict(event.get("data", {}))
-            chunk = chat_request_wrapper.create_tool_heartbeat_sse_event(
-                request_id=request_information.request_id,
-                tool_name=data.get("tool_name", "unknown"),
-                elapsed_seconds=float(data.get("elapsed_seconds", 0.0)),
-            )
-            if chunk:
-                yield chunk
         else:
             logger.debug("Skipped custom event: %s", name)
 

{language_model_common-2.0.89 → language_model_common-2.0.91}/languagemodelcommon/mcp/mcp_client/langchain_adapter.py

@@ -62,7 +62,6 @@ def mcp_tool_to_langchain_tool(
     server_name: str | None = None,
     session_pool: McpSessionPool | None = None,
     tool_list_cache: ToolListCache | None = None,
-    heartbeat_interval_seconds: float = 15.0,
 ) -> BaseTool:
     """Convert an MCP Tool to a LangChain BaseTool.
 
@@ -85,7 +84,6 @@ def mcp_tool_to_langchain_tool(
         mcp_callbacks=mcp_callbacks,
         session_pool=session_pool,
         tool_list_cache=tool_list_cache,
-        heartbeat_interval_seconds=heartbeat_interval_seconds,
     )
     handler = build_interceptor_chain(
         base_handler=execute_tool, tool_interceptors=tool_interceptors

{language_model_common-2.0.89 → language_model_common-2.0.91}/languagemodelcommon/mcp/mcp_client/tool_invocation.py

@@ -1,12 +1,9 @@
 """Tool invocation — interceptor chain and raw MCP tool calls."""
 
-import asyncio
-import contextlib
 import logging
 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 pydantic import ValidationError
 
@@ -177,6 +174,8 @@ async def _execute_tool_as_task(
     Raises TaskProtocolError if the server does not respond with a valid
     CreateTaskResult (e.g., returns a plain CallToolResult instead).
     """
+    from langchain_core.callbacks.manager import adispatch_custom_event
+
     try:
         create_result = await session.experimental.call_tool_as_task(
             name, arguments, ttl=60000
@@ -223,66 +222,12 @@ async def _execute_tool_as_task(
     return result
 
 
-async def _execute_tool_call_with_heartbeat(
-    *,
-    session: Any,
-    name: str,
-    arguments: dict[str, Any],
-    progress_callback: Any,
-    server_name: str,
-    heartbeat_interval_seconds: float,
-) -> CallToolResult:
-    """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.
-
-    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)
-    )
-    elapsed_seconds = 0.0
-    try:
-        while True:
-            try:
-                return await asyncio.wait_for(
-                    asyncio.shield(call_task), timeout=heartbeat_interval_seconds
-                )
-            except asyncio.TimeoutError:
-                elapsed_seconds += heartbeat_interval_seconds
-                try:
-                    await adispatch_custom_event(
-                        "mcp_tool_heartbeat",
-                        {
-                            "server_name": server_name,
-                            "tool_name": name,
-                            "elapsed_seconds": elapsed_seconds,
-                        },
-                    )
-                except RuntimeError as e:
-                    logger.debug(
-                        "Skipping mcp_tool_heartbeat event dispatch: %s (tool=%s)",
-                        e,
-                        name,
-                    )
-    except asyncio.CancelledError:
-        call_task.cancel()
-        with contextlib.suppress(asyncio.CancelledError):
-            await call_task
-        raise
-
-
 def _make_execute_tool(
     *,
     config: MCPConnectionConfig,
     mcp_callbacks: _MCPCallbacks,
     session_pool: McpSessionPool | None = None,
     tool_list_cache: ToolListCache | None = None,
-    heartbeat_interval_seconds: float = 15.0,
 ) -> Callable[[MCPToolCallRequest], Awaitable[MCPToolCallResult]]:
     """Create an execute_tool handler that opens a session and calls the tool.
 
@@ -340,13 +285,10 @@ def _make_execute_tool(
                         )
                         if tool_list_cache is not None:
                             await tool_list_cache.invalidate_async(key=cache_key)
-                return await _execute_tool_call_with_heartbeat(
-                    session=session,
-                    name=request.name,
-                    arguments=request.args,
+                return await session.call_tool(
+                    request.name,
+                    request.args,
                     progress_callback=mcp_callbacks.progress_callback,
-                    server_name=request.server_name,
-                    heartbeat_interval_seconds=heartbeat_interval_seconds,
                 )
             except Exception:
                 await session_pool.evict(effective_config)
@@ -382,22 +324,16 @@ def _make_execute_tool(
                         )
                         if tool_list_cache is not None:
                             await tool_list_cache.invalidate_async(key=cache_key)
-                        result = await _execute_tool_call_with_heartbeat(
-                            session=session,
-                            name=request.name,
-                            arguments=request.args,
+                        result = await session.call_tool(
+                            request.name,
+                            request.args,
                             progress_callback=mcp_callbacks.progress_callback,
-                            server_name=request.server_name,
-                            heartbeat_interval_seconds=heartbeat_interval_seconds,
                         )
                 else:
-                    result = await _execute_tool_call_with_heartbeat(
-                        session=session,
-                        name=request.name,
-                        arguments=request.args,
+                    result = await session.call_tool(
+                        request.name,
+                        request.args,
                         progress_callback=mcp_callbacks.progress_callback,
-                        server_name=request.server_name,
-                        heartbeat_interval_seconds=heartbeat_interval_seconds,
                     )
             except Exception as e:
                 captured_exception = e
@@ -419,7 +355,6 @@ async def call_mcp_tool_raw(
     tool_interceptors: list[ToolCallInterceptor] | None = None,
     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.
 
@@ -439,7 +374,6 @@ async def call_mcp_tool_raw(
         mcp_callbacks=mcp_callbacks,
         session_pool=session_pool,
         tool_list_cache=tool_list_cache,
-        heartbeat_interval_seconds=heartbeat_interval_seconds,
     )
     handler = build_interceptor_chain(
         base_handler=execute_tool, tool_interceptors=tool_interceptors

{language_model_common-2.0.89 → language_model_common-2.0.91}/languagemodelcommon/mcp/mcp_tool_provider.py

@@ -6,7 +6,6 @@ from typing import Any, Dict, List
 
 import httpx
 from httpx import HTTPStatusError
-from langchain_core.callbacks.manager import adispatch_custom_event
 from langchain_core.tools import BaseTool
 from mcp import ClientSession
 from mcp.types import (
@@ -211,24 +210,6 @@ class MCPToolProvider:
         logger.info(
             f"MCP Tool Progress - Server: {context.server_name}, Progress: {progress}, Total: {total}, Message: {message}"
         )
-        try:
-            await adispatch_custom_event(
-                "mcp_task_progress",
-                {
-                    "task_id": "",
-                    "status": f"{progress:g}/{total:g}" if total else f"{progress:g}",
-                    "message": message,
-                    "server_name": context.server_name,
-                    "tool_name": context.tool_name,
-                },
-            )
-        except RuntimeError as e:
-            logger.debug(
-                "Skipping mcp_task_progress event dispatch: %s (server=%s, tool=%s)",
-                e,
-                context.server_name,
-                context.tool_name,
-            )
 
     def _build_connection_config(self, tool_config: AgentConfig) -> MCPConnectionConfig:
         """Build an MCPConnectionConfig from an AgentConfig."""
@@ -304,7 +285,6 @@ class MCPToolProvider:
                 ],
                 server_name=tool_config.name,
                 tool_list_cache=self.tool_list_cache,
-                heartbeat_interval_seconds=self.environment_variables.mcp_tool_heartbeat_interval_seconds,
             )
             tools.append(langchain_tool)
 
@@ -471,7 +451,6 @@ class MCPToolProvider:
                         server_name=tool_config.name,
                         session_pool=session_pool,
                         tool_list_cache=self.tool_list_cache,
-                        heartbeat_interval_seconds=self.environment_variables.mcp_tool_heartbeat_interval_seconds,
                     )
                     for mcp_tool in mcp_tools
                 ]
@@ -1031,7 +1010,6 @@ class MCPToolProvider:
             ],
             session_pool=session_pool,
             tool_list_cache=self.tool_list_cache,
-            heartbeat_interval_seconds=self.environment_variables.mcp_tool_heartbeat_interval_seconds,
         )
 
     async def fetch_mcp_app_embed(

{language_model_common-2.0.89 → language_model_common-2.0.91}/languagemodelcommon/models/model_factory.py

@@ -151,6 +151,34 @@ class ModelFactory:
     def _is_anthropic_model(model_name: str) -> bool:
         return model_name.startswith(("anthropic.", "us.anthropic."))
 
+    @staticmethod
+    def _resolve_anthropic_bedrock_max_tokens(model_name: str) -> int | None:
+        """Look up the real max_output_tokens for a Bedrock Anthropic model ID.
+
+        ``ChatAnthropicBedrock`` inherits ``ChatAnthropic.set_default_max_tokens``,
+        which resolves an unset ``max_tokens`` from ``langchain_anthropic``'s own
+        model-profile registry — keyed by bare Anthropic API names (e.g.
+        ``claude-sonnet-4-5-20250929``), not Bedrock cross-region inference
+        profile IDs (e.g. ``us.anthropic.claude-sonnet-4-5-20250929-v1:0``). For
+        every Bedrock-prefixed ID that lookup misses, silently capping output at
+        ``_FALLBACK_MAX_OUTPUT_TOKENS`` (4096) even when the model supports far
+        more (64000 for Claude Sonnet 4.5) — which truncates long tool-call
+        arguments (e.g. a full skill/document body) mid-generation.
+        ``langchain_aws``'s own Bedrock-aware profile registry (used elsewhere,
+        e.g. by ``ChatAnthropicBedrock._set_model_profile``, but too late to
+        affect ``max_tokens``) does have entries keyed by the full Bedrock ID, so
+        look the real limit up there and pass it through explicitly.
+        """
+        try:
+            from langchain_aws.chat_models.anthropic import (
+                _get_default_model_profile,
+            )
+        except ImportError:
+            return None
+        profile = _get_default_model_profile(model_name)
+        max_output_tokens = profile.get("max_output_tokens")
+        return int(max_output_tokens) if max_output_tokens else None
+
     def _create_anthropic_bedrock_model(
         self,
         *,
@@ -164,6 +192,17 @@ class ModelFactory:
         from pydantic import SecretStr
         import boto3
 
+        if "max_tokens" not in model_parameters_dict:
+            resolved_max_tokens = self._resolve_anthropic_bedrock_max_tokens(model_name)
+            if resolved_max_tokens is not None:
+                model_parameters_dict["max_tokens"] = resolved_max_tokens
+                logger.info(
+                    "Resolved max_tokens=%d for Bedrock model %s from profile "
+                    "(overriding langchain_anthropic's unprefixed-lookup default)",
+                    resolved_max_tokens,
+                    model_name,
+                )
+
         if thinking_budget and thinking_budget > 0:
             model_parameters_dict["thinking"] = {
                 "type": "enabled",

{language_model_common-2.0.89 → language_model_common-2.0.91}/languagemodelcommon/structures/openai/request/chat_completion_api_request_wrapper.py

@@ -67,7 +67,6 @@ class ChatCompletionApiRequestWrapper(ChatRequestWrapper):
         enable_debug_logging: bool,
         environment_variables: "LanguageModelCommonEnvironmentVariables",
         emit_task_progress: bool | None = None,
-        emit_tool_heartbeat: bool | None = None,
     ) -> None:
         """
         Wraps an OpenAI /chat/completions request to provide a consistent interface for different request types.
@@ -85,11 +84,6 @@ class ChatCompletionApiRequestWrapper(ChatRequestWrapper):
             if emit_task_progress is not None
             else environment_variables.emit_task_progress_in_chat_completions
         )
-        self._emit_tool_heartbeat: bool = (
-            emit_tool_heartbeat
-            if emit_tool_heartbeat is not None
-            else environment_variables.emit_tool_heartbeat_in_chat_completions
-        )
         self._debug_prefixes = environment_variables.debug_prefixes
         self._apply_debug_prefix_toggle()
 
@@ -284,23 +278,6 @@ class ChatCompletionApiRequestWrapper(ChatRequestWrapper):
             source="task_progress",
         )
 
-    @override
-    def create_tool_heartbeat_sse_event(
-        self,
-        *,
-        request_id: str,
-        tool_name: str,
-        elapsed_seconds: float,
-    ) -> str | None:
-        if not self._emit_tool_heartbeat:
-            return None
-        return self.create_sse_message(
-            request_id=request_id,
-            content=f"\n[Still running {tool_name}... ({elapsed_seconds:.0f}s)]\n",
-            usage_metadata=None,
-            source="tool_heartbeat",
-        )
-
     @override
     def create_non_streaming_response(
         self,

{language_model_common-2.0.89 → language_model_common-2.0.91}/languagemodelcommon/structures/openai/request/chat_request_wrapper.py

@@ -272,21 +272,6 @@ class ChatRequestWrapper(abc.ABC):
         """
         return None
 
-    def create_tool_heartbeat_sse_event(
-        self,
-        *,
-        request_id: str,
-        tool_name: str,
-        elapsed_seconds: float,
-    ) -> str | None:
-        """Emit a synthetic heartbeat while a tool call is in flight without
-        reporting real progress.
-
-        The default implementation returns None (no-op).  Subclasses override
-        to emit the event in their respective SSE formats.
-        """
-        return None
-
     def create_tool_start_sse_event(
         self,
         *,

{language_model_common-2.0.89 → language_model_common-2.0.91}/languagemodelcommon/structures/openai/request/responses_api_request_wrapper.py

@@ -373,29 +373,6 @@ class ResponsesApiRequestWrapper(ChatRequestWrapper):
         }
         return f"data: {json.dumps(event)}\n\n"
 
-    @override
-    def create_tool_heartbeat_sse_event(
-        self,
-        *,
-        request_id: str,
-        tool_name: str,
-        elapsed_seconds: float,
-    ) -> str | None:
-        """Emit a synthetic heartbeat as a ``task.progress`` SSE event.
-
-        Reuses the exact same wire format as create_task_progress_sse_event
-        so existing consumers (e.g. baileyai-skills-service's frontend, which
-        already treats any `type: "task.progress"` payload as a non-content
-        trace event) require no changes.
-        """
-        event: Dict[str, Any] = {
-            "type": "task.progress",
-            "task_id": "",
-            "status": "in_progress",
-            "message": f"Still running {tool_name}... ({elapsed_seconds:.0f}s)",
-        }
-        return f"data: {json.dumps(event)}\n\n"
-
     @staticmethod
     def _convert_usage_to_response_usage(
         usages: list[UsageMetadata],

{language_model_common-2.0.89 → language_model_common-2.0.91}/languagemodelcommon/utilities/environment/language_model_common_environment_variables.py

@@ -289,22 +289,6 @@ class LanguageModelCommonEnvironmentVariables(
         """Timeout in seconds for tool calls."""
         return int(os.environ.get("TOOL_CALL_TIMEOUT_SECONDS", "600"))
 
-    @property
-    def mcp_tool_heartbeat_interval_seconds(self) -> float:
-        """Interval in seconds between synthetic heartbeat events emitted
-        while an MCP tool call is in flight without reporting progress."""
-        return float(os.environ.get("MCP_TOOL_HEARTBEAT_INTERVAL_SECONDS", "15"))
-
-    @property
-    def emit_tool_heartbeat_in_chat_completions(self) -> bool:
-        """When True, synthetic MCP tool heartbeats are emitted as content
-        deltas in the Chat Completions streaming format. Separate from
-        emit_task_progress_in_chat_completions so enabling one does not
-        change the volume/behavior of the other."""
-        return self.str2bool(
-            os.environ.get("EMIT_TOOL_HEARTBEAT_IN_CHAT_COMPLETIONS", "false")
-        )
-
     @property
     def app_login_uri(self) -> str:
         value = os.environ.get("APP_LOGIN_URI")

language_model_common-2.0.89/VERSION

@@ -1 +0,0 @@
-2.0.89