TeLLMgramBot 3.13.6__tar.gz → 3.13.7__tar.gz

{tellmgrambot-3.13.6 → tellmgrambot-3.13.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: TeLLMgramBot
-Version: 3.13.6
+Version: 3.13.7
 Summary: LLM-powered Telegram bot (OpenAI + Anthropic)
 Home-page: https://github.com/Digital-Heresy/TeLLMgramBot
 Author: Digital Heresy

{tellmgrambot-3.13.6 → tellmgrambot-3.13.7}/TeLLMgramBot/TeLLMgramBot.py

@@ -784,11 +784,9 @@ class TelegramBot:
         """
         Build the tool list to pass to the LLM for this request.
 
-        Webhook tool schemas are only injected when two conditions are both true:
-        (1) the chat is a private chat, and (2) the requesting user is bot_owner.
-        In all other contexts only _SEARCH_TOOL is included so webhook tool names,
-        descriptions, and endpoint structure are never visible to group participants
-        or non-owner users.
+        _SEARCH_TOOL is always included. Owner in private chat receives all webhook and
+        MCP schemas. Owner in group/supergroup receives only schemas with allow_groups=True.
+        Non-owners and all other chat types (channels) receive only _SEARCH_TOOL.
 
         Args:
             chat_type: Telegram chat type string ('private', 'group', 'supergroup', etc.).
@@ -798,8 +796,16 @@ class TelegramBot:
             List of provider-compatible tool schema dicts.
         """
         tools = [_SEARCH_TOOL]
-        if chat_type == 'private' and username in self.telegram['owners']:
-            tools = tools + self.webhook_schemas
+        if username not in self.telegram['owners']:
+            return tools
+        if chat_type == 'private':
+            return tools + self.webhook_schemas
+        if chat_type in ('group', 'supergroup'):
+            group_schemas = [
+                s for s in self.webhook_schemas
+                if self.webhook_defs.get(s['name'], {}).get('allow_groups', False)
+            ]
+            return tools + group_schemas
         return tools
 
     async def _handle_tool_call(
@@ -811,8 +817,8 @@ class TelegramBot:
 
         Routes 'search_messages' to the built-in search handler. Webhook and MCP tools are
         routed to execute_webhook() or execute_mcp() (distinguished by '_mcp_server' key in
-        tool_def) after a defense-in-depth permission check (primary gate is _build_tool_list()
-        which only injects tool schemas for owner+private chats).
+        tool_def) after a defense-in-depth permission check that rechecks owner status and
+        allow_groups scope even for group/supergroup chats (channels are always denied).
 
         Args:
             tool_call: The ToolCall returned by the provider.
@@ -859,11 +865,14 @@ class TelegramBot:
 
         tool_def = self.webhook_defs.get(tool_call.name)
         if tool_def:
-            # Defense-in-depth guard: primary gate is _build_tool_list() not injecting schemas
-            # for non-owner or non-private contexts; this catches any edge case where a tool
-            # call arrives despite the schema not being injected.
-            if chat_type != 'private' or username not in self.telegram['owners']:
-                return "[Permission denied: tools are only available in a private chat with the bot owner]"
+            # Defense-in-depth guard: primary gate is _build_tool_list(); this catches
+            # edge cases where a tool call arrives despite the schema not being injected.
+            if username not in self.telegram['owners']:
+                return "[Permission denied: tools are only available to the bot owner]"
+            if chat_type not in ('private', 'group', 'supergroup'):
+                return "[Permission denied: tools are not available in this chat type]"
+            if chat_type != 'private' and not tool_def.get('allow_groups', False):
+                return "[Permission denied: this tool is not enabled for group chats]"
             if tool_def.get('_mcp_server'):
                 return await execute_mcp(tool_def, tool_call.arguments)
             return await execute_webhook(tool_def, tool_call.arguments)

{tellmgrambot-3.13.6 → tellmgrambot-3.13.7}/TeLLMgramBot/tools.py

@@ -6,6 +6,7 @@ entries, discover_mcp_tools() for async MCP server discovery, execute_webhook()
 dispatching webhook tool calls, and execute_mcp() for MCP tool calls at runtime.
 """
 import ipaddress
+import json
 import logging
 import os
 import re
@@ -81,6 +82,71 @@ def _is_blocked_address(hostname: str) -> bool:
     return False
 
 
+def _extract_json_path(obj, segments: list) -> list:
+    """
+    Walk a dotted-path segment list through a parsed JSON object, returning all matching leaf values.
+
+    Supports wildcard array traversal via '[*]' segments with an early-exit budget check
+    to cap total extracted results. Non-empty strings and numeric scalars (int, float)
+    are returned as string values; booleans, None, and empty containers return empty list.
+    Mismatched path segments or missing keys return empty list (not an error).
+
+    Args:
+        obj: Parsed JSON object (typically a dict or list).
+        segments: List of path segments (e.g., ['data', 'items', '[*]', 'name']).
+
+    Returns:
+        List of matched leaf values as strings, or empty list if no matches.
+    """
+    if not segments:
+        if isinstance(obj, bool) or obj is None:
+            return []
+        if isinstance(obj, (str, int, float)):
+            return [str(obj)] if str(obj).strip() else []
+        return []
+    seg = segments[0]
+    rest = segments[1:]
+    if seg == '[*]':
+        if not isinstance(obj, list):
+            return []
+        results = []
+        total = 0
+        for item in obj:
+            batch = _extract_json_path(item, rest)
+            for v in batch:
+                total += len(v)
+                results.append(v)
+                if total >= _RESPONSE_BODY_LIMIT:
+                    return results
+        return results
+    if not isinstance(obj, dict) or seg not in obj:
+        return []
+    return _extract_json_path(obj[seg], rest)
+
+
+def _validated_json_path(value, tool_name: str):
+    """Return value if it is a non-empty string, else log a warning and return None."""
+    if value is None:
+        return None
+    if isinstance(value, str) and value.strip():
+        return value
+    logger.warning(
+        f"Webhook tool '{tool_name}': 'response_json_path' must be a non-empty string; ignoring."
+    )
+    return None
+
+
+def _validated_bool(value, tool_name: str, key_name: str) -> bool:
+    """Return value if it is a real bool, else log a warning and return False."""
+    if isinstance(value, bool):
+        return value
+    if value is not None:
+        logger.warning(
+            f"Tool '{tool_name}': '{key_name}' must be a boolean (true/false); defaulting to false."
+        )
+    return False
+
+
 def build_tool_registry(
     tools_config: list,
     allow_local: bool = False,
@@ -94,6 +160,7 @@ def build_tool_registry(
     variables are excluded with a logged warning (graceful-degradation pattern).
     Non-dict entries, non-dict headers values, and non-dict parameter definitions
     are skipped with warnings. Duplicate tool names are deduplicated (first wins).
+    Calls _validated_json_path() to validate response_json_path at registry build time.
 
     Args:
         tools_config: List of raw tool definition dicts from bot config 'tools:' key.
@@ -104,7 +171,9 @@ def build_tool_registry(
     Returns:
         Tuple of (schemas, defs) where:
         - schemas: list of provider-compatible tool schema dicts (same shape as _SEARCH_TOOL).
-        - defs: dict mapping tool name -> resolved definition dict with expanded headers.
+        - defs: dict mapping tool name -> resolved definition dict with expanded headers,
+                optional 'response_json_path' for JSON response extraction, and 'allow_groups'
+                flag for group/supergroup scope control.
     """
     schemas = []
     defs = {}
@@ -189,6 +258,8 @@ def build_tool_registry(
             'method': str(entry.get('method', 'POST')).upper(),
             'headers': expanded_headers,
             'normalize_args': entry.get('normalize_args'),
+            'response_json_path': _validated_json_path(entry.get('response_json_path'), name),
+            'allow_groups': _validated_bool(entry.get('allow_groups'), name, 'allow_groups'),
             'allow_local': allow_local,
         }
 
@@ -205,7 +276,8 @@ async def discover_mcp_tools(
 
     For each entry with an 'mcp_server:' key, sends a JSON-RPC 2.0 tools/list request
     to the server base URL, translates MCP inputSchema to provider-compatible parameters,
-    and returns (schemas, defs) for the discovered tools.
+    and returns (schemas, defs) for the discovered tools. Passes allow_groups through to
+    MCP tool defs.
 
     Headers support $ENV_VAR expansion. Missing env vars disable the MCP source with a
     warning. Discovery failures (non-2xx, timeout, network error) log a warning and
@@ -353,6 +425,7 @@ async def discover_mcp_tools(
                 'name': tool_name,
                 '_mcp_server': server_url,
                 'headers': expanded_headers,
+                'allow_groups': _validated_bool(entry.get('allow_groups'), tool_name, 'allow_groups'),
                 'allow_local': allow_local,
             }
             all_registered.add(tool_name)
@@ -452,9 +525,13 @@ async def execute_webhook(tool_def: dict, arguments: dict) -> str:
     Execute a webhook tool call and return a framed result string for LLM injection.
 
     Applies argument normalization, URL template substitution ({param} -> value),
-    and SSRF protection before firing the HTTP request. The response body is wrapped
-    with a '[Tool result from <name>]:' framing line so the LLM can distinguish
-    tool output from user instructions (prompt injection guard).
+    and SSRF protection before firing the HTTP request. On 2xx response, if
+    'response_json_path' is set in tool_def and is a valid string, parses the response
+    as JSON and extracts values at the dotted path (supporting [*] array wildcards);
+    falls back to raw response on invalid JSON or no path matches with a WARNING logged.
+    The response body is wrapped with a '[Tool result from <name>]:' framing line
+    so the LLM can distinguish tool output from user instructions (prompt injection
+    guard).
 
     Request headers are never logged at any level. Response bodies are logged at
     DEBUG only, truncated to 200 characters. Only tool name, HTTP method, base URL
@@ -462,7 +539,8 @@ async def execute_webhook(tool_def: dict, arguments: dict) -> str:
     to the LLM is truncated to 4000 characters to prevent overwhelming the context.
 
     Args:
-        tool_def: Resolved tool definition dict from build_tool_registry defs.
+        tool_def: Resolved tool definition dict from build_tool_registry defs
+                  (may contain 'response_json_path' for JSON extraction).
         arguments: Arguments dict from the LLM ToolCall.
 
     Returns:
@@ -525,6 +603,25 @@ async def execute_webhook(tool_def: dict, arguments: dict) -> str:
         logger.debug(f"Webhook '{name}' response: {resp.text[:_RESPONSE_LOG_LIMIT]}")
 
         body = resp.text
+        json_path = tool_def.get('response_json_path')
+        if json_path and isinstance(json_path, str):
+            try:
+                data = json.loads(body)
+                normalized = json_path.replace('[*]', '.[*]')
+                segments = [s for s in normalized.split('.') if s]
+                extracted = _extract_json_path(data, segments)
+                if extracted:
+                    body = '\n'.join(extracted)
+                else:
+                    logger.warning(
+                        f"Webhook '{name}': response_json_path '{json_path}' matched no values; "
+                        f"using raw response"
+                    )
+            except Exception:
+                logger.warning(
+                    f"Webhook '{name}': response_json_path extraction failed; using raw response"
+                )
+
         if len(body) > _RESPONSE_BODY_LIMIT:
             body = body[:_RESPONSE_BODY_LIMIT] + f"\n[Response truncated at {_RESPONSE_BODY_LIMIT} characters]"
         return f"[Tool result from {name}]:\n{body}"

{tellmgrambot-3.13.6 → tellmgrambot-3.13.7}/TeLLMgramBot.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: TeLLMgramBot
-Version: 3.13.6
+Version: 3.13.7
 Summary: LLM-powered Telegram bot (OpenAI + Anthropic)
 Home-page: https://github.com/Digital-Heresy/TeLLMgramBot
 Author: Digital Heresy

{tellmgrambot-3.13.6 → tellmgrambot-3.13.7}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r") as fh:
 
 setup(
     name='TeLLMgramBot',
-    version='3.13.6',
+    version='3.13.7',
     packages=find_packages(),
     license='MIT',
     author='Digital Heresy',