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

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

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

@@ -0,0 +1 @@
+2.0.90

{language_model_common-2.0.89 → language_model_common-2.0.90/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.90
 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.90}/languagemodelcommon/converters/tool_event_handlers.py

@@ -36,6 +36,20 @@ from languagemodelcommon.utilities.tool_display_name_mapper import ToolDisplayNa
 logger = logging.getLogger(__name__)
 logger.setLevel(SRC_LOG_LEVELS.LLM)
 
+# Cap on the tool result/error text forwarded to the response.output_item.done
+# SSE event, so a tool that echoes back large content (e.g. a full skill body)
+# doesn't bloat every trace event; full output remains available via the
+# existing debug-file-writer path for cases that need it.
+TOOL_END_OUTPUT_TRACE_MAX_CHARS = 2000
+
+
+def _truncate_for_trace(
+    text: str, *, max_chars: int = TOOL_END_OUTPUT_TRACE_MAX_CHARS
+) -> str:
+    if len(text) <= max_chars:
+        return text
+    return text[:max_chars] + f"...[truncated {len(text) - max_chars} chars]"
+
 
 class ToolEventHandler(StreamContextMixin):
     def __init__(
@@ -161,23 +175,32 @@ class ToolEventHandler(StreamContextMixin):
                     tool_name,
                 )
 
+            tool_message_content: str = (
+                convert_message_content_into_string(tool_message=tool_message)
+                if tool_message
+                else ""
+            )
+            artifact: Optional[Any] = tool_message.artifact
+            # tool_message.status only flips to "error" for an uncaught exception;
+            # meta-tools like call_tool catch their own failures and report them via
+            # the artifact instead (see CallToolTool), so check both signals.
+            is_error: bool = tool_message.status == "error" or (
+                isinstance(artifact, dict) and artifact.get("is_error") is True
+            )
+
             tool_end_event = chat_request_wrapper.create_tool_end_sse_event(
                 request_id=request_information.request_id,
                 tool_name=tool_name,
                 tool_input=tool_input,
                 runtime_seconds=runtime_seconds,
+                output=_truncate_for_trace(tool_message_content)
+                if tool_message_content
+                else None,
+                is_error=is_error,
             )
             if tool_end_event:
                 yield tool_end_event
 
-            tool_message_content: str = (
-                convert_message_content_into_string(tool_message=tool_message)
-                if tool_message
-                else ""
-            )
-
-            artifact: Optional[Any] = tool_message.artifact
-
             logger.debug(
                 "Tool %s has artifact of type %s: %s",
                 tool_name,

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

@@ -309,9 +309,17 @@ class ChatRequestWrapper(abc.ABC):
         tool_name: str,
         tool_input: dict[str, Any] | None,
         runtime_seconds: float | None,
+        output: str | None = None,
+        is_error: bool = False,
     ) -> str | None:
         """Emit an SSE event when a tool finishes execution.
 
+        ``output`` is the tool's own result/error text (already converted to a
+        plain string and truncated by the caller) and ``is_error`` reflects the
+        underlying ToolMessage's status, so consumers can distinguish a tool
+        that ran to completion from one that failed without having to parse
+        free-text content.
+
         The default implementation returns None (no-op).  Subclasses that
         support structured tool events (e.g. Responses API) override this
         to emit a typed SSE frame the client can use for status updates.

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

@@ -338,8 +338,16 @@ class ResponsesApiRequestWrapper(ChatRequestWrapper):
         tool_name: str,
         tool_input: Dict[str, Any] | None,
         runtime_seconds: float | None,
+        output: str | None = None,
+        is_error: bool = False,
     ) -> str | None:
-        """Emit a ``response.output_item.done`` event with a ``function_call`` item."""
+        """Emit a ``response.output_item.done`` event with a ``function_call`` item.
+
+        Includes ``runtime_seconds`` and the tool's own ``output``/``is_error``
+        so consuming UIs (e.g. baileyai-skills-service's Stream events panel)
+        can show how long a call took and surface failures, rather than only
+        ever seeing a "completed" status with no result.
+        """
         event: Dict[str, Any] = {
             "type": "response.output_item.done",
             "output_index": 0,
@@ -350,7 +358,10 @@ class ResponsesApiRequestWrapper(ChatRequestWrapper):
                 "call_id": f"call_{request_id}_{tool_name}",
                 "name": tool_name,
                 "arguments": json.dumps(tool_input) if tool_input else "",
-                "status": "completed",
+                "status": "failed" if is_error else "completed",
+                "runtime_seconds": runtime_seconds,
+                "output": output or "",
+                "is_error": is_error,
             },
         }
         return f"data: {json.dumps(event)}\n\n"

{language_model_common-2.0.89 → language_model_common-2.0.90}/languagemodelcommon/tools/mcp/call_tool_tool.py

@@ -98,7 +98,7 @@ class CallToolTool(BaseTool):
         if entry is None:
             return (
                 f"Tool '{name}' not found. Use search_tools to find available tools.",
-                None,
+                {"is_error": True},
             )
 
         try:
@@ -122,9 +122,16 @@ class CallToolTool(BaseTool):
                 session_token=self.session_token,
             )
 
+            # Surface the *inner* tool's own error status (result.isError), not just
+            # transport-level failures — CallToolTool itself never raises for a
+            # rejected/invalid call, so this is the only place that signal exists.
             artifact: dict[str, Any] | None = None
-            if app_embed is not None:
-                artifact = {"mcp_app_embed": app_embed}
+            if app_embed is not None or result.isError:
+                artifact = {}
+                if app_embed is not None:
+                    artifact["mcp_app_embed"] = app_embed
+                if result.isError:
+                    artifact["is_error"] = True
 
             return text, artifact
         except AuthorizationNeededException:
@@ -138,4 +145,4 @@ class CallToolTool(BaseTool):
                 entry.server_name,
                 error_detail,
             )
-            return f"Error calling tool '{name}': {error_detail}", None
+            return f"Error calling tool '{name}': {error_detail}", {"is_error": True}

language_model_common-2.0.89/VERSION

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