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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: language-model-common
-Version: 2.0.87
+Version: 2.0.89
 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/VERSION

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: language-model-common
-Version: 2.0.87
+Version: 2.0.89
 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.87 → language_model_common-2.0.89}/languagemodelcommon/converters/streaming_manager.py

@@ -379,6 +379,15 @@ 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.87 → language_model_common-2.0.89}/languagemodelcommon/mcp/mcp_client/langchain_adapter.py

@@ -62,6 +62,7 @@ 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.
 
@@ -84,6 +85,7 @@ 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.87 → language_model_common-2.0.89}/languagemodelcommon/mcp/mcp_client/tool_invocation.py

@@ -1,9 +1,12 @@
 """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
 
@@ -174,8 +177,6 @@ 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
@@ -222,12 +223,66 @@ 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.
 
@@ -285,10 +340,13 @@ def _make_execute_tool(
                         )
                         if tool_list_cache is not None:
                             await tool_list_cache.invalidate_async(key=cache_key)
-                return await session.call_tool(
-                    request.name,
-                    request.args,
+                return await _execute_tool_call_with_heartbeat(
+                    session=session,
+                    name=request.name,
+                    arguments=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)
@@ -324,16 +382,22 @@ def _make_execute_tool(
                         )
                         if tool_list_cache is not None:
                             await tool_list_cache.invalidate_async(key=cache_key)
-                        result = await session.call_tool(
-                            request.name,
-                            request.args,
+                        result = await _execute_tool_call_with_heartbeat(
+                            session=session,
+                            name=request.name,
+                            arguments=request.args,
                             progress_callback=mcp_callbacks.progress_callback,
+                            server_name=request.server_name,
+                            heartbeat_interval_seconds=heartbeat_interval_seconds,
                         )
                 else:
-                    result = await session.call_tool(
-                        request.name,
-                        request.args,
+                    result = await _execute_tool_call_with_heartbeat(
+                        session=session,
+                        name=request.name,
+                        arguments=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
@@ -355,6 +419,7 @@ 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.
 
@@ -374,6 +439,7 @@ 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.87 → language_model_common-2.0.89}/languagemodelcommon/mcp/mcp_tool_provider.py

@@ -6,6 +6,7 @@ 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 (
@@ -210,6 +211,24 @@ 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."""
@@ -285,6 +304,7 @@ 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)
 
@@ -451,6 +471,7 @@ 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
                 ]
@@ -1010,6 +1031,7 @@ 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.87 → language_model_common-2.0.89}/languagemodelcommon/structures/openai/request/chat_completion_api_request_wrapper.py

@@ -67,6 +67,7 @@ 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.
@@ -84,6 +85,11 @@ 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()
 
@@ -278,6 +284,23 @@ 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.87 → language_model_common-2.0.89}/languagemodelcommon/structures/openai/request/chat_request_wrapper.py

@@ -272,6 +272,21 @@ 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.87 → language_model_common-2.0.89}/languagemodelcommon/structures/openai/request/responses_api_request_wrapper.py

@@ -373,6 +373,29 @@ 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.87 → language_model_common-2.0.89}/languagemodelcommon/utilities/environment/language_model_common_environment_variables.py

@@ -289,6 +289,22 @@ 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.87/VERSION

@@ -1 +0,0 @@
-2.0.87