language-model-common 3.0.0__tar.gz → 3.0.2__tar.gz

{language_model_common-3.0.0/language_model_common.egg-info → language_model_common-3.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: language-model-common
-Version: 3.0.0
+Version: 3.0.2
 Summary: Provides the underlying framework to enhance langchain and add loading configurations
 Author-email: Imran Qureshi <imran.qureshi@bwell.com>
 License: Apache-2.0
@@ -30,7 +30,7 @@ Requires-Dist: simple-container>=1.0.2
 Requires-Dist: pypdf>=6.6.0
 Requires-Dist: markdownify>=0.14.1
 Requires-Dist: beautifulsoup4>=4.12.3
-Requires-Dist: oidcauthlib>=3.0.18
+Requires-Dist: oidcauthlib>=3.0.21
 Requires-Dist: fsspec>=2026.2.0
 Requires-Dist: authlib>=1.6.5
 Requires-Dist: langchain-google-genai>=4.1.3

language_model_common-3.0.2/VERSION

@@ -0,0 +1 @@
+3.0.2

{language_model_common-3.0.0 → language_model_common-3.0.2/language_model_common.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: language-model-common
-Version: 3.0.0
+Version: 3.0.2
 Summary: Provides the underlying framework to enhance langchain and add loading configurations
 Author-email: Imran Qureshi <imran.qureshi@bwell.com>
 License: Apache-2.0
@@ -30,7 +30,7 @@ Requires-Dist: simple-container>=1.0.2
 Requires-Dist: pypdf>=6.6.0
 Requires-Dist: markdownify>=0.14.1
 Requires-Dist: beautifulsoup4>=4.12.3
-Requires-Dist: oidcauthlib>=3.0.18
+Requires-Dist: oidcauthlib>=3.0.21
 Requires-Dist: fsspec>=2026.2.0
 Requires-Dist: authlib>=1.6.5
 Requires-Dist: langchain-google-genai>=4.1.3

{language_model_common-3.0.0 → language_model_common-3.0.2}/language_model_common.egg-info/requires.txt

@@ -17,7 +17,7 @@ simple-container>=1.0.2
 pypdf>=6.6.0
 markdownify>=0.14.1
 beautifulsoup4>=4.12.3
-oidcauthlib>=3.0.18
+oidcauthlib>=3.0.21
 fsspec>=2026.2.0
 authlib>=1.6.5
 langchain-google-genai>=4.1.3

{language_model_common-3.0.0 → language_model_common-3.0.2}/languagemodelcommon/configs/config_reader/mcp_json_fetcher.py

@@ -74,7 +74,7 @@ class McpJsonFetcher:
 
         raw_json = text_parts[0]
 
-        if getattr(result, "isError", False):
+        if getattr(result, "is_error", False):
             error_msg = (
                 f"get_mcp_servers_config returned an error for plugin "
                 f"'{plugin_name}' from {self._url}: {raw_json}"
@@ -140,7 +140,7 @@ class McpJsonFetcher:
 
         raw_json = text_parts[0]
 
-        if getattr(result, "isError", False):
+        if getattr(result, "is_error", False):
             logger.warning(
                 "get_mcp_servers_config returned an error from %s: %s",
                 self._url,

{language_model_common-3.0.0 → language_model_common-3.0.2}/languagemodelcommon/mcp/callbacks.py

@@ -7,7 +7,7 @@ from dataclasses import dataclass
 from typing import Protocol, runtime_checkable
 
 from mcp.client.session import LoggingFnT as MCPLoggingFnT
-from mcp.shared.session import ProgressFnT as MCPProgressFnT
+from mcp.shared.dispatcher import ProgressFnT as MCPProgressFnT
 from mcp.types import LoggingMessageNotificationParams
 
 

{language_model_common-3.0.0 → language_model_common-3.0.2}/languagemodelcommon/mcp/interceptors/tracing.py

@@ -116,7 +116,7 @@ class TracingMcpCallInterceptor:
                             span.set_attribute(
                                 "mcp.result.content_blocks", len(result.content)
                             )
-                            if result.structuredContent is not None:
+                            if result.structured_content is not None:
                                 span.set_attribute("mcp.result.structured", True)
                     except Exception:
                         pass

{language_model_common-3.0.0 → language_model_common-3.0.2}/languagemodelcommon/mcp/interceptors/truncation.py

@@ -80,7 +80,9 @@ class TruncationMcpCallInterceptor:
             if isinstance(result, CallToolResult):
                 if logger.isEnabledFor(DEBUG):
                     # See if there is structured_content
-                    structured_content: dict[str, Any] | None = result.structuredContent
+                    structured_content: dict[str, Any] | None = (
+                        result.structured_content
+                    )
                     logger.debug(
                         f"=== Tool structured output received: {type(structured_content)}: {structured_content} ==="
                     )

{language_model_common-3.0.0 → language_model_common-3.0.2}/languagemodelcommon/mcp/mcp_client/content_conversion.py

@@ -31,15 +31,15 @@ def convert_mcp_content_to_lc_block(
         return create_text_block(text=content.text)
 
     if isinstance(content, ImageContent):
-        return create_image_block(base64=content.data, mime_type=content.mimeType)
+        return create_image_block(base64=content.data, mime_type=content.mime_type)
 
     if isinstance(content, AudioContent):
         raise NotImplementedError(
-            f"AudioContent conversion not supported. Mime type: {content.mimeType}"
+            f"AudioContent conversion not supported. Mime type: {content.mime_type}"
         )
 
     if isinstance(content, ResourceLink):
-        mime_type = content.mimeType or None
+        mime_type = content.mime_type or None
         if mime_type and mime_type.startswith("image/"):
             return create_image_block(url=str(content.uri), mime_type=mime_type)
         return create_file_block(url=str(content.uri), mime_type=mime_type)
@@ -49,7 +49,7 @@ def convert_mcp_content_to_lc_block(
         if isinstance(resource, TextResourceContents):
             return create_text_block(text=resource.text)
         if isinstance(resource, BlobResourceContents):
-            mime_type = resource.mimeType or None
+            mime_type = resource.mime_type or None
             if mime_type and mime_type.startswith("image/"):
                 return create_image_block(base64=resource.blob, mime_type=mime_type)
             return create_file_block(base64=resource.blob, mime_type=mime_type)
@@ -63,11 +63,11 @@ def convert_call_tool_result(
 ) -> list[ToolMessageContentBlock]:
     """Convert a CallToolResult to LangChain content blocks.
 
-    When the MCP server signals an error (isError=True), the error content is
+    When the MCP server signals an error (is_error=True), the error content is
     returned as normal text blocks prefixed with "Error:" so the LLM can see
     the failure reason and retry with corrected parameters.
     """
-    if result.isError:
+    if result.is_error:
         error_parts = [
             block.text for block in result.content if isinstance(block, TextContent)
         ]

{language_model_common-3.0.0 → language_model_common-3.0.2}/languagemodelcommon/mcp/mcp_client/langchain_adapter.py

@@ -114,7 +114,7 @@ def mcp_tool_to_langchain_tool(
     return StructuredTool(
         name=_sanitize_tool_name(tool.name),
         description=tool.description or "",
-        args_schema=tool.inputSchema,
+        args_schema=tool.input_schema,
         coroutine=call_tool,
         response_format="content_and_artifact",
         metadata=metadata or None,

{language_model_common-3.0.0 → language_model_common-3.0.2}/languagemodelcommon/mcp/mcp_client/session.py

@@ -6,9 +6,9 @@ from contextlib import asynccontextmanager
 from datetime import timedelta
 from typing import Any
 
-import httpx
+import httpx2
 from mcp import ClientSession
-from mcp.client.streamable_http import streamablehttp_client
+from mcp.client.streamable_http import streamable_http_client
 from typing_extensions import NotRequired, TypedDict
 
 from languagemodelcommon.mcp.callbacks import _MCPCallbacks
@@ -35,15 +35,15 @@ class McpSessionError(Exception):
 
 
 class McpHttpClientFactory:
-    """Protocol-compatible callable for creating httpx async clients."""
+    """Protocol-compatible callable for creating httpx2 async clients."""
 
     def __call__(
         self,
         headers: dict[str, str] | None = None,
-        timeout: httpx.Timeout | None = None,
-        auth: httpx.Auth | None = None,
-    ) -> httpx.AsyncClient:
-        return httpx.AsyncClient(
+        timeout: httpx2.Timeout | None = None,
+        auth: httpx2.Auth | None = None,
+    ) -> httpx2.AsyncClient:
+        return httpx2.AsyncClient(
             auth=auth,
             headers=headers,
             timeout=timeout,
@@ -73,11 +73,20 @@ async def create_mcp_session(
     headers = config.get("headers")
     timeout = config.get("timeout", DEFAULT_TIMEOUT)
     sse_read_timeout = config.get("sse_read_timeout", DEFAULT_SSE_READ_TIMEOUT)
-    httpx_client_factory = config.get("httpx_client_factory")
-
-    kwargs: dict[str, Any] = {}
-    if httpx_client_factory is not None:
-        kwargs["httpx_client_factory"] = httpx_client_factory
+    httpx_client_factory = config.get("httpx_client_factory") or McpHttpClientFactory()
+
+    # mcp>=2.0's streamable_http_client takes a ready-made httpx2.AsyncClient
+    # (http_client=) instead of individual headers/timeout/sse_read_timeout
+    # kwargs. connect/write/pool keep `timeout`; `read` gets the longer
+    # `sse_read_timeout`, since the streamable HTTP connection is a
+    # long-lived read that would otherwise be cut short by `timeout`.
+    http_client = httpx_client_factory(
+        headers=headers,
+        timeout=httpx2.Timeout(
+            timeout.total_seconds(),
+            read=sse_read_timeout.total_seconds(),
+        ),
+    )
 
     session_kwargs: dict[str, Any] = {}
     if mcp_callbacks is not None:
@@ -85,37 +94,38 @@ async def create_mcp_session(
             session_kwargs["logging_callback"] = mcp_callbacks.logging_callback
 
     try:
+        # streamable_http_client only manages the http_client's lifecycle
+        # when it creates one itself (http_client=None) -- since we always
+        # pass a pre-built client, we own closing it.
         async with (
-            streamablehttp_client(
+            http_client,
+            streamable_http_client(
                 url,
-                headers,
-                timeout,
-                sse_read_timeout,
-                **kwargs,
-            ) as (read, write, _),
+                http_client=http_client,
+            ) as (read, write),
             ClientSession(read, write, **session_kwargs) as session,
         ):
             yield session
-    except httpx.ConnectError as e:
+    except httpx2.ConnectError as e:
         raise McpSessionError(
             f"Connection refused — is the MCP server running at {url}? "
             f"({type(e).__name__}: {e})",
             url=url,
         ) from e
-    except httpx.ConnectTimeout as e:
+    except httpx2.ConnectTimeout as e:
         raise McpSessionError(
             f"Connection timed out reaching MCP server at {url} "
             f"(timeout={timeout}). ({type(e).__name__}: {e})",
             url=url,
         ) from e
-    except httpx.ReadTimeout as e:
+    except httpx2.ReadTimeout as e:
         raise McpSessionError(
             f"Read timed out waiting for MCP server at {url} "
             f"(sse_read_timeout={sse_read_timeout}). "
             f"({type(e).__name__}: {e})",
             url=url,
         ) from e
-    except httpx.HTTPStatusError as e:
+    except httpx2.HTTPStatusError as e:
         raise McpSessionError(
             f"MCP server at {url} returned HTTP {e.response.status_code}. "
             f"({type(e).__name__}: {e})",

{language_model_common-3.0.0 → language_model_common-3.0.2}/languagemodelcommon/mcp/mcp_client/session_pool.py

@@ -23,7 +23,7 @@ logger.setLevel(SRC_LOG_LEVELS.MCP)
 class _PooledSession:
     """A live MCP session whose CM lifecycle runs in a dedicated task.
 
-    ``streamablehttp_client`` uses anyio task groups whose cancel scopes
+    ``streamable_http_client`` uses anyio task groups whose cancel scopes
     enforce that ``__aexit__`` is called in the same asyncio task that
     called ``__aenter__``.  To satisfy this, a background task runs the
     CM and keeps it alive until ``close_event`` is set.  The session
@@ -119,7 +119,7 @@ class McpSessionPool:
     Each session's context manager lifecycle runs in a dedicated asyncio
     task so that ``__aenter__`` and ``__aexit__`` execute in the same
     task — required by anyio cancel scopes used inside
-    ``streamablehttp_client``.
+    ``streamable_http_client``.
     """
 
     def __init__(self) -> None:

{language_model_common-3.0.0 → language_model_common-3.0.2}/languagemodelcommon/mcp/mcp_client/tool_invocation.py

@@ -93,7 +93,7 @@ async def _tool_supports_tasks(
     """Check whether a specific tool supports task-augmented execution.
 
     Server-level task capability is necessary but not sufficient. Each tool
-    declares its own task support via execution.taskSupport in the tools/list
+    declares its own task support via execution.task_support in the tools/list
     response. Only tools with "optional" or "required" support tasks.
 
     Reads from the existing ToolListCache (populated when tools are listed)
@@ -112,7 +112,7 @@ async def _tool_supports_tasks(
     for tool in tools:
         if tool.name == tool_name:
             if tool.execution is not None:
-                task_support = getattr(tool.execution, "taskSupport", None)
+                task_support = getattr(tool.execution, "task_support", None)
                 return task_support in ("optional", "required")
             return False
 
@@ -120,20 +120,20 @@ async def _tool_supports_tasks(
 
 
 def _extract_task_id_from_create_result(create_result: Any) -> str:
-    """Extract taskId from CreateTaskResult, handling both spec versions.
+    """Extract task_id from CreateTaskResult, handling both spec versions.
 
-    Old spec: result.task.taskId (nested under 'task' field)
-    New spec: result.taskId (flat, Result & Task merged)
+    Old spec: result.task.task_id (nested under 'task' field)
+    New spec: result.task_id (flat, Result & Task merged)
     """
-    # New spec: taskId directly on result
-    if hasattr(create_result, "taskId"):
-        return str(create_result.taskId)
+    # New spec: task_id directly on result
+    if hasattr(create_result, "task_id"):
+        return str(create_result.task_id)
 
     # Old spec: nested under .task
     if hasattr(create_result, "task"):
-        return str(create_result.task.taskId)
+        return str(create_result.task.task_id)
 
-    raise ValueError(f"Cannot extract taskId from {type(create_result)}")
+    raise ValueError(f"Cannot extract task_id from {type(create_result)}")
 
 
 def _extract_result_from_task_status(task_status: Any) -> CallToolResult | None:
@@ -196,7 +196,7 @@ async def _execute_tool_as_task(
                 {
                     "task_id": task_id,
                     "status": status.status,
-                    "message": getattr(status, "statusMessage", None),
+                    "message": getattr(status, "status_message", None),
                     "server_name": server_name,
                     "tool_name": name,
                 },
@@ -297,7 +297,7 @@ def _make_execute_tool(
 
     If the server and tool both advertise task support, the tool is
     executed via the MCP task protocol with polling and progress events.
-    Per-tool ``execution.taskSupport`` is checked from the already-cached
+    Per-tool ``execution.task_support`` is checked from the already-cached
     tool list so that tools with ``"forbidden"`` (or no declaration) use
     normal call_tool.
     """

{language_model_common-3.0.0 → language_model_common-3.0.2}/languagemodelcommon/mcp/mcp_client/tool_list_cache.py

@@ -8,6 +8,7 @@ from dataclasses import dataclass
 from typing import Protocol
 
 from mcp import ClientSession
+from mcp.types import PaginatedRequestParams
 from mcp.types import Tool as MCPTool
 
 from languagemodelcommon.utilities.logger.log_levels import SRC_LOG_LEVELS
@@ -266,12 +267,13 @@ async def list_all_tools(session: ClientSession) -> list[MCPTool]:
         if iterations > MAX_ITERATIONS:
             raise RuntimeError("Exceeded max iterations while listing tools")
 
-        result = await session.list_tools(cursor=cursor)
+        params = PaginatedRequestParams(cursor=cursor) if cursor is not None else None
+        result = await session.list_tools(params=params)
         if result.tools:
             all_tools.extend(result.tools)
-        if not result.nextCursor:
+        if not result.next_cursor:
             break
-        cursor = result.nextCursor
+        cursor = result.next_cursor
 
     return all_tools
 

{language_model_common-3.0.0 → language_model_common-3.0.2}/languagemodelcommon/utilities/logger/logging_response.py

@@ -1,7 +1,8 @@
 import logging
-from typing import Any, AsyncIterator, override
+from collections.abc import AsyncGenerator
+from typing import override
 
-import httpx
+import httpx2
 
 from languagemodelcommon.utilities.logger.log_levels import SRC_LOG_LEVELS
 
@@ -9,28 +10,29 @@ logger = logging.getLogger(__name__)
 logger.setLevel(SRC_LOG_LEVELS.HTTP)
 
 
-class LoggingResponse(httpx.Response):
+class LoggingResponse(httpx2.Response):
     """
     A custom HTTP response class that logs the request and response details.
-    This class extends httpx.Response to log the request method, URL, status code,
+    This class extends httpx2.Response to log the request method, URL, status code,
     and response content in bytes as they are streamed.
     """
 
     @override
-    async def aiter_bytes(self, *args: Any, **kwargs: Any) -> AsyncIterator[bytes]:
+    async def aiter_bytes(
+        self, chunk_size: int | None = None
+    ) -> AsyncGenerator[bytes, None]:
         """
         Asynchronously iterate over the response content in bytes, logging each chunk.
         This method overrides the default aiter_bytes method to include logging.
         Args:
-            *args: Positional arguments passed to the parent method.
-            **kwargs: Keyword arguments passed to the parent method.
+            chunk_size: Passed through to the parent method.
         Yields:
             bytes: The next chunk of response content in bytes.
         """
         logger.debug(
             f"====== Response: {self.request.method} {self.url} {self.status_code} ====="
         )
-        async for chunk in super().aiter_bytes(*args, **kwargs):
+        async for chunk in super().aiter_bytes(chunk_size):
             logger.debug(chunk)
             yield chunk
         logger.debug(

{language_model_common-3.0.0 → language_model_common-3.0.2}/languagemodelcommon/utilities/logger/logging_transport.py

@@ -1,7 +1,7 @@
 import logging
 from typing import override
 
-import httpx
+import httpx2
 
 from languagemodelcommon.utilities.logger.log_levels import SRC_LOG_LEVELS
 from languagemodelcommon.utilities.logger.logging_response import (
@@ -12,29 +12,29 @@ logger = logging.getLogger(__name__)
 logger.setLevel(SRC_LOG_LEVELS.HTTP)
 
 
-class LoggingTransport(httpx.AsyncBaseTransport):
+class LoggingTransport(httpx2.AsyncBaseTransport):
     """
     A custom HTTP transport that logs request and response details.
-    This class extends httpx.AsyncBaseTransport to log the request method, URL,
+    This class extends httpx2.AsyncBaseTransport to log the request method, URL,
     headers, and content before sending the request, and logs the response status code,
     headers, and content as it is streamed back.
-    It is designed to be used with httpx for asynchronous HTTP requests.
+    It is designed to be used with httpx2 for asynchronous HTTP requests.
     It logs the request method, URL, headers, and content before sending the request,
     and logs the response status code, headers, and content as it is streamed back.
     This transport can be used to monitor and debug HTTP requests and responses in an application.
     """
 
-    def __init__(self, transport: httpx.AsyncBaseTransport) -> None:
+    def __init__(self, transport: httpx2.AsyncBaseTransport) -> None:
         """
         Initialize the LoggingTransport with a given transport.
         Args:
-            transport (httpx.AsyncBaseTransport): The underlying transport to wrap.
+            transport (httpx2.AsyncBaseTransport): The underlying transport to wrap.
             This transport will handle the actual HTTP requests and responses.
         """
-        self.transport: httpx.AsyncBaseTransport = transport
+        self.transport: httpx2.AsyncBaseTransport = transport
 
     @override
-    async def handle_async_request(self, request: httpx.Request) -> LoggingResponse:
+    async def handle_async_request(self, request: httpx2.Request) -> LoggingResponse:
         """
         Handle an asynchronous HTTP request, logging the request details and returning a LoggingResponse.
         Args:
@@ -60,7 +60,7 @@ class LoggingTransport(httpx.AsyncBaseTransport):
                 stream=response.stream,
                 extensions=response.extensions,
             )
-        except httpx.HTTPError as e:
+        except httpx2.HTTPError as e:
             logger.exception(f"HTTP error occurred: {e}")
             raise
         except Exception as e:

{language_model_common-3.0.0 → language_model_common-3.0.2}/pyproject.toml

@@ -37,7 +37,7 @@ dependencies = [
     "pypdf>=6.6.0",
     "markdownify>=0.14.1",
     "beautifulsoup4>=4.12.3",
-    "oidcauthlib>=3.0.18",
+    "oidcauthlib>=3.0.21",
     "fsspec>=2026.2.0",
     "authlib>=1.6.5",
     "langchain-google-genai>=4.1.3",

language_model_common-3.0.0/VERSION

@@ -1 +0,0 @@
-3.0.0