alita-sdk 0.3.497__py3-none-any.whl → 0.3.516__py3-none-any.whl

alita_sdk/runtime/langchain/document_loaders/AlitaJSONLinesLoader.py

@@ -0,0 +1,77 @@
+from .AlitaJSONLoader import AlitaJSONLoader
+import json
+from io import StringIO
+from typing import List, Iterator
+
+from langchain_core.documents import Document
+from langchain_core.tools import ToolException
+
+
+class AlitaJSONLinesLoader(AlitaJSONLoader):
+    """Load local JSONL files (one JSON object per line) using AlitaJSONLoader behavior.
+
+    Behavior:
+    - Supports both `file_path` and `file_content` (bytes or file-like object), same as AlitaJSONLoader.
+    - Treats each non-empty line as an independent JSON object.
+    - Aggregates all parsed JSON objects into a list and feeds them through the same
+      RecursiveJsonSplitter-based chunking used by AlitaJSONLoader.lazy_load.
+    - Returns a list of Documents with chunked JSON content.
+    """
+
+    def __init__(self, **kwargs):
+        # Reuse AlitaJSONLoader initialization logic (file_path / file_content handling, encoding, etc.)
+        super().__init__(**kwargs)
+
+    def _iter_lines(self) -> Iterator[str]:
+        """Yield lines from file_path or file_content, mirroring AlitaJSONLoader sources."""
+        # Prefer file_path if available
+        if hasattr(self, "file_path") and self.file_path:
+            with open(self.file_path, "r", encoding=self.encoding) as f:
+                for line in f:
+                    yield line
+        # Fallback to file_content if available
+        elif hasattr(self, "file_content") and self.file_content:
+            # file_content may be bytes or a file-like object
+            if isinstance(self.file_content, (bytes, bytearray)):
+                text = self.file_content.decode(self.encoding)
+                for line in StringIO(text):
+                    yield line
+            else:
+                # Assume it's a text file-like object positioned at the beginning
+                self.file_content.seek(0)
+                for line in self.file_content:
+                    yield line
+        else:
+            raise ToolException("'file_path' or 'file_content' parameter should be provided.")
+
+    def load(self) -> List[Document]:  # type: ignore[override]
+        """Load JSONL content by delegating each non-empty line to AlitaJSONLoader.
+
+        For each non-empty line in the underlying source (file_path or file_content):
+        - Create a temporary AlitaJSONLoader instance with that line as file_content.
+        - Call lazy_load() on that instance to apply the same RecursiveJsonSplitter logic
+          as for a normal JSON file.
+        - Accumulate all Documents from all lines and return them as a single list.
+        """
+        docs: List[Document] = []
+
+        for raw_line in self._iter_lines():
+            line = raw_line.strip()
+            if not line:
+                continue
+            try:
+                # Instantiate a per-line AlitaJSONLoader using the same configuration
+                line_loader = AlitaJSONLoader(
+                    file_content=line,
+                    file_name=getattr(self, "file_name", str(getattr(self, "file_path", "no_name"))),
+                    encoding=self.encoding,
+                    autodetect_encoding=self.autodetect_encoding,
+                    max_tokens=self.max_tokens,
+                )
+
+                for doc in line_loader.lazy_load():
+                    docs.append(doc)
+            except Exception as e:
+                raise ToolException(f"Error processing JSONL line: {line[:100]}... Error: {e}") from e
+
+        return docs

alita_sdk/runtime/langchain/document_loaders/AlitaJSONLoader.py

@@ -32,6 +32,8 @@ class AlitaJSONLoader(BaseLoader):
             elif hasattr(self, 'file_content') and self.file_content:
                 if isinstance(self.file_content, bytes):
                     return json.loads(self.file_content.decode(self.encoding))
+                elif isinstance(self.file_content, str):
+                    return json.loads(self.file_content)
                 else:
                     return json.load(self.file_content)
             else:
@@ -45,7 +47,6 @@ class AlitaJSONLoader(BaseLoader):
                         try:
                             with open(self.file_path, encoding=encoding.encoding) as f:
                                 return f.read()
-                            break
                         except UnicodeDecodeError:
                             continue
                 elif hasattr(self, 'file_content') and self.file_content:

alita_sdk/runtime/langchain/document_loaders/constants.py

@@ -21,6 +21,7 @@ from .AlitaDocxMammothLoader import AlitaDocxMammothLoader
 from .AlitaExcelLoader import AlitaExcelLoader
 from .AlitaImageLoader import AlitaImageLoader
 from .AlitaJSONLoader import AlitaJSONLoader
+from .AlitaJSONLinesLoader import AlitaJSONLinesLoader
 from .AlitaPDFLoader import AlitaPDFLoader
 from .AlitaPowerPointLoader import AlitaPowerPointLoader
 from .AlitaTextLoader import AlitaTextLoader
@@ -208,7 +209,7 @@ document_loaders_map = {
         'allowed_to_override': DEFAULT_ALLOWED_BASE
     },
     '.jsonl': {
-        'class': AirbyteJSONLoader,
+        'class': AlitaJSONLinesLoader,
         'mime_type': 'application/jsonl',
         'is_multimodal_processing': False,
         'kwargs': {},

alita_sdk/runtime/langchain/langraph_agent.py

@@ -30,7 +30,7 @@ from ..tools.loop import LoopNode
 from ..tools.loop_output import LoopToolNode
 from ..tools.tool import ToolNode
 from ..utils.evaluate import EvaluateTemplate
-from ..utils.utils import clean_string, TOOLKIT_SPLITTER
+from ..utils.utils import clean_string
 from ..tools.router import RouterNode
 
 logger = logging.getLogger(__name__)
@@ -191,7 +191,7 @@ Answer only with step name, no need to add descrip in case none of the steps are
                     additional_info = """### Additoinal info: """
                 additional_info += "{field}: {value}\n".format(field=field, value=state.get(field, ""))
         decision_input.append(HumanMessage(
-            self.prompt.format(steps=self.steps, description=self.description, additional_info=additional_info)))
+            self.prompt.format(steps=self.steps, description=safe_format(self.description, state), additional_info=additional_info)))
         completion = self.client.invoke(decision_input)
         result = clean_string(completion.content.strip())
         logger.info(f"Plan to transition to: {result}")
@@ -483,8 +483,7 @@ def create_graph(
             node_id = clean_string(node['id'])
             toolkit_name = node.get('toolkit_name')
             tool_name = clean_string(node.get('tool', node_id))
-            if toolkit_name:
-                tool_name = f"{clean_string(toolkit_name)}{TOOLKIT_SPLITTER}{tool_name}"
+            # Tool names are now clean (no prefix needed)
             logger.info(f"Node: {node_id} : {node_type} - {tool_name}")
             if node_type in ['function', 'toolkit', 'mcp', 'tool', 'loop', 'loop_from_tool', 'indexer', 'subgraph', 'pipeline', 'agent']:
                 if node_type == 'mcp' and tool_name not in [tool.name for tool in tools]:
@@ -550,8 +549,8 @@ def create_graph(
                             loop_toolkit_name = node.get('loop_toolkit_name')
                             loop_tool_name = node.get('loop_tool')
                             if (loop_toolkit_name and loop_tool_name) or loop_tool_name:
-                                loop_tool_name = f"{clean_string(loop_toolkit_name)}{TOOLKIT_SPLITTER}{loop_tool_name}" if loop_toolkit_name else clean_string(
-                                    loop_tool_name)
+                                # Use clean tool name (no prefix)
+                                loop_tool_name = clean_string(loop_tool_name)
                                 for t in tools:
                                     if t.name == loop_tool_name:
                                         logger.debug(f"Loop tool discovered: {t}")
@@ -609,10 +608,10 @@ def create_graph(
                 tool_names = []
                 if isinstance(connected_tools, dict):
                     for toolkit, selected_tools in connected_tools.items():
-                        for tool in selected_tools:
-                            tool_names.append(f"{toolkit}{TOOLKIT_SPLITTER}{tool}")
+                        # Add tool names directly (no prefix)
+                        tool_names.extend(selected_tools)
                 elif isinstance(connected_tools, list):
-                    # for cases when tools are provided as a list of names with already bound toolkit_name
+                    # Use provided tool names as-is
                     tool_names = connected_tools
                 
                 if tool_names:

alita_sdk/runtime/langchain/utils.py

@@ -208,7 +208,12 @@ def safe_format(template, mapping):
 def create_pydantic_model(model_name: str, variables: dict[str, dict]):
     fields = {}
     for var_name, var_data in variables.items():
-        fields[var_name] = (parse_pydantic_type(var_data['type']), Field(description=var_data.get('description', None)))
+        if 'default' in var_data:
+            # allow user to define if it is required or not
+            fields[var_name] = (parse_pydantic_type(var_data['type']),
+                                Field(description=var_data.get('description', None), default=var_data.get('default')))
+        else:
+            fields[var_name] = (parse_pydantic_type(var_data['type']), Field(description=var_data.get('description', None)))
     return create_model(model_name, **fields)
 
 def parse_pydantic_type(type_name: str):

alita_sdk/runtime/toolkits/artifact.py

@@ -1,6 +1,7 @@
 from typing import List, Any, Literal, Optional
 
-from alita_sdk.tools.utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length
+from alita_sdk.tools.utils import clean_string, get_max_toolkit_length
+from alita_sdk.tools.elitea_base import filter_missconfigured_index_tools
 from langchain_community.agent_toolkits.base import BaseToolkit
 from langchain_core.tools import BaseTool
 from pydantic import create_model, BaseModel, ConfigDict, Field
@@ -40,26 +41,34 @@ class ArtifactToolkit(BaseToolkit):
         )
     
     @classmethod
+    @filter_missconfigured_index_tools
     def get_toolkit(cls, client: Any, bucket: str, toolkit_name: Optional[str] = None, selected_tools: list[str] = [], **kwargs):
         if selected_tools is None:
             selected_tools = []
+        
         tools = []
         wrapper_payload = {
             **kwargs,
             **(kwargs.get('pgvector_configuration') or {}),
         }
         artifact_wrapper = ArtifactWrapper(alita=client, bucket=bucket, **wrapper_payload)
-        prefix = clean_string(toolkit_name, cls.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
+        # Use clean toolkit name for context (max 1000 chars in description)
+        toolkit_context = f" [Toolkit: {clean_string(toolkit_name, 0)}]" if toolkit_name else ''
         available_tools = artifact_wrapper.get_available_tools()
         for tool in available_tools:
             if selected_tools:
                 if tool["name"] not in selected_tools:
                     continue
+            # Add toolkit context to description with character limit
+            description = tool["description"]
+            if toolkit_context and len(description + toolkit_context) <= 1000:
+                description = description + toolkit_context
             tools.append(BaseAction(
                 api_wrapper=artifact_wrapper,
-                name=prefix + tool["name"],
-                description=tool["description"],
-                args_schema=tool["args_schema"]
+                name=tool["name"],
+                description=description,
+                args_schema=tool["args_schema"],
+                metadata={"toolkit_name": toolkit_name} if toolkit_name else {}
             ))
         return cls(tools=tools)
     

alita_sdk/runtime/toolkits/datasource.py

@@ -3,7 +3,7 @@ from pydantic import create_model, BaseModel, Field
 from langchain_community.agent_toolkits.base import BaseToolkit
 from langchain_core.tools import BaseTool, ToolException
 from ..tools.datasource import DatasourcePredict, DatasourceSearch, datasourceToolSchema
-from alita_sdk.tools.utils import clean_string, TOOLKIT_SPLITTER
+from alita_sdk.tools.utils import clean_string
 
 
 class DatasourcesToolkit(BaseToolkit):
@@ -21,21 +21,28 @@ class DatasourcesToolkit(BaseToolkit):
     @classmethod
     def get_toolkit(cls, client: Any, datasource_ids: list[int], toolkit_name: Optional[str] = None, selected_tools: list[str] = []):
         tools = []
-        prefix = clean_string(toolkit_name) + TOOLKIT_SPLITTER if toolkit_name else ''
+        # Use clean toolkit name for context (max 1000 chars in description)
+        toolkit_context = f" [Toolkit: {clean_string(toolkit_name)}]" if toolkit_name else ''
         for datasource_id in datasource_ids:
             datasource = client.datasource(datasource_id)
             ds_name = clean_string(datasource.name)
             if len(ds_name) == 0:
                 raise ToolException(f'Datasource with id {datasource_id} has incorrect name (i.e. special characters, etc.)')
             if len(selected_tools) == 0 or 'chat' in selected_tools:
-                tools.append(DatasourcePredict(name=f'{prefix}chat',
-                                            description=f'Search and summarize. {datasource.description}',
+                description = f'Search and summarize. {datasource.description}'
+                if toolkit_context and len(description + toolkit_context) <= 1000:
+                    description = description + toolkit_context
+                tools.append(DatasourcePredict(name=f'chat',
+                                            description=description,
                                             datasource=datasource, 
                                             args_schema=datasourceToolSchema,
                                             return_type='str'))
             if len(selected_tools) == 0 or 'search' in selected_tools:
-                tools.append(DatasourceSearch(name=f'{prefix}search',
-                                                description=f'Search return results. {datasource.description}',
+                description = f'Search return results. {datasource.description}'
+                if toolkit_context and len(description + toolkit_context) <= 1000:
+                    description = description + toolkit_context
+                tools.append(DatasourceSearch(name=f'search',
+                                                description=description,
                                                 datasource=datasource, 
                                                 args_schema=datasourceToolSchema,
                                                 return_type='str'))

alita_sdk/runtime/toolkits/mcp.py

@@ -15,7 +15,6 @@ from pydantic import BaseModel, ConfigDict, Field, SecretStr
 from ..tools.mcp_server_tool import McpServerTool
 from ..tools.mcp_remote_tool import McpRemoteTool
 from ..tools.mcp_inspect_tool import McpInspectTool
-from ...tools.utils import TOOLKIT_SPLITTER, clean_string
 from ..models.mcp_models import McpConnectionConfig
 from ..utils.mcp_client import McpClient
 from ..utils.mcp_oauth import (
@@ -40,110 +39,6 @@ def safe_int(value, default):
         logger.warning(f"Invalid integer value '{value}', using default {default}")
         return default
 
-def optimize_tool_name(prefix: str, tool_name: str, max_total_length: int = 64) -> str:
-    """
-    Optimize tool name to fit within max_total_length while preserving meaning.
-    
-    Args:
-        prefix: The toolkit prefix (already cleaned)
-        tool_name: The original tool name
-        max_total_length: Maximum total length for the full tool name (default: 64)
-    
-    Returns:
-        Optimized full tool name in format: prefix___tool_name
-    """
-    splitter = TOOLKIT_SPLITTER
-    splitter_len = len(splitter)
-    prefix_len = len(prefix)
-    
-    # Calculate available space for tool name
-    available_space = max_total_length - prefix_len - splitter_len
-    
-    if available_space <= 0:
-        logger.error(f"Prefix '{prefix}' is too long ({prefix_len} chars), cannot create valid tool name")
-        # Fallback: truncate prefix itself
-        prefix = prefix[:max_total_length - splitter_len - 10]  # Leave 10 chars for tool name
-        available_space = max_total_length - len(prefix) - splitter_len
-    
-    # If tool name fits, use it as-is
-    if len(tool_name) <= available_space:
-        return f'{prefix}{splitter}{tool_name}'
-    
-    # Tool name is too long, need to optimize
-    logger.debug(f"Tool name '{tool_name}' is too long ({len(tool_name)} chars), optimizing to fit {available_space} chars")
-    
-    # Split tool name into parts (handle camelCase, snake_case, and mixed)
-    # First, split by underscores and hyphens
-    parts = re.split(r'[_-]', tool_name)
-    
-    # Further split camelCase within each part
-    all_parts = []
-    for part in parts:
-        # Insert underscore before uppercase letters (camelCase to snake_case)
-        snake_case_part = re.sub(r'([a-z0-9])([A-Z])', r'\1_\2', part)
-        all_parts.extend(snake_case_part.split('_'))
-    
-    # Filter out empty parts
-    all_parts = [p for p in all_parts if p]
-    
-    # Remove redundant prefix words (case-insensitive comparison)
-    # Only remove if prefix is meaningful (>= 3 chars) to avoid over-filtering
-    prefix_lower = prefix.lower()
-    filtered_parts = []
-    for part in all_parts:
-        part_lower = part.lower()
-        # Skip if this part contains the prefix or the prefix contains this part
-        # But only if both are meaningful (>= 3 chars)
-        should_remove = False
-        if len(prefix_lower) >= 3 and len(part_lower) >= 3:
-            if part_lower in prefix_lower or prefix_lower in part_lower:
-                should_remove = True
-                logger.debug(f"Removing redundant part '{part}' (matches prefix '{prefix}')")
-        
-        if not should_remove:
-            filtered_parts.append(part)
-    
-    # If we removed all parts, keep the original parts
-    if not filtered_parts:
-        filtered_parts = all_parts
-    
-    # Reconstruct tool name with filtered parts
-    optimized_name = '_'.join(filtered_parts)
-    
-    # If still too long, truncate intelligently
-    if len(optimized_name) > available_space:
-        # Strategy: Keep beginning and end, as they often contain the most important info
-        # For example: "projectalita_github_io_list_branches" -> "projectalita_list_branches"
-        
-        # Try removing middle parts first
-        if len(filtered_parts) > 2:
-            # Keep first and last parts, remove middle
-            kept_parts = [filtered_parts[0], filtered_parts[-1]]
-            optimized_name = '_'.join(kept_parts)
-            
-            # If still too long, add parts from the end until we run out of space
-            if len(optimized_name) <= available_space and len(filtered_parts) > 2:
-                for i in range(len(filtered_parts) - 2, 0, -1):
-                    candidate = '_'.join([filtered_parts[0]] + filtered_parts[i:])
-                    if len(candidate) <= available_space:
-                        optimized_name = candidate
-                        break
-        
-        # If still too long, just truncate
-        if len(optimized_name) > available_space:
-            # Try to truncate at word boundary
-            truncated = optimized_name[:available_space]
-            last_underscore = truncated.rfind('_')
-            if last_underscore > available_space * 0.7:  # Keep if we're not losing too much
-                optimized_name = truncated[:last_underscore]
-            else:
-                optimized_name = truncated
-    
-    full_name = f'{prefix}{splitter}{optimized_name}'
-    logger.info(f"Optimized tool name: '{tool_name}' ({len(tool_name)} chars) -> '{optimized_name}' ({len(optimized_name)} chars), full: '{full_name}' ({len(full_name)} chars)")
-    
-    return full_name
-
 class McpToolkit(BaseToolkit):
     """
     MCP Toolkit for connecting to a single remote MCP server and exposing its tools.
@@ -153,9 +48,6 @@ class McpToolkit(BaseToolkit):
     tools: List[BaseTool] = []
     toolkit_name: Optional[str] = None
 
-    # Class variable (not Pydantic field) for tool name length limit
-    toolkit_max_length: ClassVar[int] = 0  # No limit for MCP tool names
-
     def __getstate__(self):
         """Custom serialization for pickle compatibility."""
         state = self.__dict__.copy()
@@ -595,28 +487,23 @@ class McpToolkit(BaseToolkit):
     ) -> Optional[BaseTool]:
         """Create a BaseTool from a tool/prompt dictionary (from direct HTTP discovery)."""
         try:
-            # Store toolkit_max_length in local variable to avoid contextual access issues
-            max_length_value = cls.toolkit_max_length
-
-            # Clean toolkit name for prefixing
-            clean_prefix = clean_string(toolkit_name, max_length_value)
-
-            # Optimize tool name to fit within 64 character limit
-            full_tool_name = optimize_tool_name(clean_prefix, tool_dict.get("name", "unknown"))
+            # Use original tool name directly
+            tool_name = tool_dict.get("name", "unknown")
             
             # Check if this is a prompt (converted to tool)
             is_prompt = tool_dict.get("_mcp_type") == "prompt"
             item_type = "prompt" if is_prompt else "tool"
 
-            # Build description and ensure it doesn't exceed 1000 characters
-            description = f"MCP {item_type} '{tool_dict.get('name')}' from toolkit '{toolkit_name}': {tool_dict.get('description', '')}"
+            # Build description with toolkit context and ensure it doesn't exceed 1000 characters
+            base_description = tool_dict.get('description', '')
+            description = f"{base_description}\nToolkit: {toolkit_name} ({connection_config.url})"
             if len(description) > 1000:
                 description = description[:997] + "..."
-                logger.debug(f"Trimmed description for tool '{tool_dict.get('name')}' from {len(description)} to 1000 chars")
+                logger.debug(f"Trimmed description for tool '{tool_name}' to 1000 chars")
 
             # Use McpRemoteTool for remote MCP servers (HTTP/SSE)
             return McpRemoteTool(
-                name=full_tool_name,
+                name=tool_name,
                 description=description,
                 args_schema=McpServerTool.create_pydantic_model_from_schema(
                     tool_dict.get("inputSchema", {})
@@ -628,11 +515,11 @@ class McpToolkit(BaseToolkit):
                 tool_timeout_sec=timeout,
                 is_prompt=is_prompt,
                 prompt_name=tool_dict.get("_mcp_prompt_name") if is_prompt else None,
-                original_tool_name=tool_dict.get('name'),  # Store original name for MCP server invocation
+                original_tool_name=tool_name,  # Store original name for MCP server invocation
                 session_id=session_id  # Pass session ID for stateful SSE servers
             )
         except Exception as e:
-            logger.error(f"Failed to create MCP tool '{tool_dict.get('name')}' from toolkit '{toolkit_name}': {e}")
+            logger.error(f"Failed to create MCP tool '{tool_name}' from toolkit '{toolkit_name}': {e}")
             return None
 
     @classmethod
@@ -691,7 +578,7 @@ class McpToolkit(BaseToolkit):
             # We don't have full connection config in static mode, so create a basic one
             # The inspection tool will work as long as the server is accessible
             inspection_tool = McpInspectTool(
-                name=f"{clean_string(toolkit_name, 50)}{TOOLKIT_SPLITTER}mcp_inspect",
+                name="mcp_inspect",
                 server_name=toolkit_name,
                 server_url="",  # Will be populated by the client if available
                 description=f"Inspect available tools, prompts, and resources from MCP toolkit '{toolkit_name}'"
@@ -713,22 +600,17 @@ class McpToolkit(BaseToolkit):
     ) -> Optional[BaseTool]:
         """Create a BaseTool from discovered metadata."""
         try:
-            # Store toolkit_max_length in local variable to avoid contextual access issues
-            max_length_value = cls.toolkit_max_length
+            # Use original tool name directly
+            tool_name = tool_metadata.name
 
-            # Clean server name for prefixing (use tool_metadata.server instead of toolkit_name)
-            clean_prefix = clean_string(tool_metadata.server, max_length_value)
-            # Optimize tool name to fit within 64 character limit
-            full_tool_name = optimize_tool_name(clean_prefix, tool_metadata.name)
-
-            # Build description and ensure it doesn't exceed 1000 characters
-            description = f"MCP tool '{tool_metadata.name}' from server '{tool_metadata.server}': {tool_metadata.description}"
+            # Build description with toolkit context and ensure it doesn't exceed 1000 characters
+            description = f"{tool_metadata.description}\nToolkit: {toolkit_name}"
             if len(description) > 1000:
                 description = description[:997] + "..."
-                logger.debug(f"Trimmed description for tool '{tool_metadata.name}' from {len(description)} to 1000 chars")
+                logger.debug(f"Trimmed description for tool '{tool_name}' to 1000 chars")
 
             return McpServerTool(
-                name=full_tool_name,
+                name=tool_name,
                 description=description,
                 args_schema=McpServerTool.create_pydantic_model_from_schema(tool_metadata.input_schema),
                 client=client,
@@ -736,7 +618,7 @@ class McpToolkit(BaseToolkit):
                 tool_timeout_sec=timeout
             )
         except Exception as e:
-            logger.error(f"Failed to create MCP tool '{tool_metadata.name}' from server '{tool_metadata.server}': {e}")
+            logger.error(f"Failed to create MCP tool '{tool_name}' from server '{tool_metadata.server}': {e}")
             return None
 
     @classmethod
@@ -749,23 +631,18 @@ class McpToolkit(BaseToolkit):
     ) -> Optional[BaseTool]:
         """Create a single MCP tool."""
         try:
-            # Store toolkit_max_length in local variable to avoid contextual access issues
-            max_length_value = cls.toolkit_max_length
-
-            # Clean toolkit name for prefixing
-            clean_prefix = clean_string(toolkit_name, max_length_value)
+            # Use original tool name directly
+            tool_name = available_tool["name"]
 
-            # Optimize tool name to fit within 64 character limit
-            full_tool_name = optimize_tool_name(clean_prefix, available_tool["name"])
-
-            # Build description and ensure it doesn't exceed 1000 characters
-            description = f"MCP tool '{available_tool['name']}' from toolkit '{toolkit_name}': {available_tool.get('description', '')}"
+            # Build description with toolkit context and ensure it doesn't exceed 1000 characters
+            base_description = available_tool.get('description', '')
+            description = f"{base_description}\nToolkit: {toolkit_name}"
             if len(description) > 1000:
                 description = description[:997] + "..."
-                logger.debug(f"Trimmed description for tool '{available_tool['name']}' from {len(description)} to 1000 chars")
+                logger.debug(f"Trimmed description for tool '{tool_name}' to 1000 chars")
 
             return McpServerTool(
-                name=full_tool_name,
+                name=tool_name,
                 description=description,
                 args_schema=McpServerTool.create_pydantic_model_from_schema(
                     available_tool.get("inputSchema", {})
@@ -775,7 +652,7 @@ class McpToolkit(BaseToolkit):
                 tool_timeout_sec=timeout
             )
         except Exception as e:
-            logger.error(f"Failed to create MCP tool '{available_tool.get('name')}' from toolkit '{toolkit_name}': {e}")
+            logger.error(f"Failed to create MCP tool '{tool_name}' from toolkit '{toolkit_name}': {e}")
             return None
 
     @classmethod
@@ -786,16 +663,8 @@ class McpToolkit(BaseToolkit):
     ) -> Optional[BaseTool]:
         """Create the inspection tool for the MCP toolkit."""
         try:
-            # Store toolkit_max_length in local variable to avoid contextual access issues
-            max_length_value = cls.toolkit_max_length
-
-            # Clean toolkit name for prefixing
-            clean_prefix = clean_string(toolkit_name, max_length_value)
-
-            full_tool_name = f'{clean_prefix}{TOOLKIT_SPLITTER}mcp_inspect'
-
             return McpInspectTool(
-                name=full_tool_name,
+                name="mcp_inspect",
                 server_name=toolkit_name,
                 server_url=connection_config.url,
                 server_headers=connection_config.headers,

alita_sdk/runtime/toolkits/planning.py

@@ -16,7 +16,7 @@ from pydantic.fields import FieldInfo
 
 from ..tools.planning import PlanningWrapper
 from ...tools.base.tool import BaseAction
-from ...tools.utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length
+from ...tools.utils import clean_string, get_max_toolkit_length
 
 
 class PlanningToolkit(BaseToolkit):
@@ -150,8 +150,8 @@ class PlanningToolkit(BaseToolkit):
             plan_callback=plan_callback,
         )
         
-        # Build tool name prefix
-        prefix = clean_string(toolkit_name, cls._toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
+        # Use clean toolkit name for context (max 1000 chars in description)
+        toolkit_context = f" [Toolkit: {clean_string(toolkit_name, 0)}]" if toolkit_name else ''
         
         # Create tools from wrapper
         available_tools = wrapper.get_available_tools()
@@ -159,10 +159,15 @@ class PlanningToolkit(BaseToolkit):
             if tool["name"] not in selected_tools:
                 continue
             
+            # Add toolkit context to description with character limit
+            description = tool["description"]
+            if toolkit_context and len(description + toolkit_context) <= 1000:
+                description = description + toolkit_context
+            
             tools.append(BaseAction(
                 api_wrapper=wrapper,
-                name=prefix + tool["name"],
-                description=tool["description"],
+                name=tool["name"],
+                description=description,
                 args_schema=tool["args_schema"]
             ))