alita-sdk 0.3.379__py3-none-any.whl → 0.3.627__py3-none-any.whl

alita_sdk/runtime/toolkits/__init__.py

@@ -0,0 +1,31 @@
+"""
+Runtime toolkits module for Alita SDK.
+This module provides various toolkit implementations for LangGraph agents.
+"""
+
+from .application import ApplicationToolkit
+from .artifact import ArtifactToolkit
+from .datasource import DatasourcesToolkit
+from .planning import PlanningToolkit
+from .prompt import PromptToolkit
+from .subgraph import SubgraphToolkit
+from .vectorstore import VectorStoreToolkit
+from .mcp import McpToolkit
+from .mcp_config import McpConfigToolkit, get_session_manager as get_mcp_session_manager
+from .skill_router import SkillRouterToolkit
+from ...tools.memory import MemoryToolkit
+
+__all__ = [
+    "ApplicationToolkit",
+    "ArtifactToolkit",
+    "DatasourcesToolkit",
+    "PlanningToolkit",
+    "PromptToolkit",
+    "SubgraphToolkit",
+    "VectorStoreToolkit",
+    "McpToolkit",
+    "McpConfigToolkit",
+    "get_mcp_session_manager",
+    "SkillRouterToolkit",
+    "MemoryToolkit"
+]

alita_sdk/runtime/toolkits/application.py

@@ -22,24 +22,43 @@ class ApplicationToolkit(BaseToolkit):
     
     @classmethod
     def get_toolkit(cls, client: 'AlitaClient', application_id: int, application_version_id: int,
-                    selected_tools: list[str] = [], store: Optional[BaseStore] = None):
-        
+                    selected_tools: list[str] = [], store: Optional[BaseStore] = None,
+                    ignored_mcp_servers: Optional[list] = None, is_subgraph: bool = False, mcp_tokens: Optional[dict] = None):
+
         app_details = client.get_app_details(application_id)
         version_details = client.get_app_version_details(application_id, application_version_id)
         model_settings = {
             "max_tokens": version_details['llm_settings']['max_tokens'],
-            "top_p": version_details['llm_settings']['top_p'],
+            "reasoning_effort": version_details['llm_settings'].get('reasoning_effort'),
             "temperature": version_details['llm_settings']['temperature'],
         }
 
-        app = client.application(application_id, application_version_id, store=store, 
-                                 llm=client.get_llm(version_details['llm_settings']['model_name'], 
-                                                    model_settings))
-        return cls(tools=[Application(name=app_details.get("name"), 
-                                      description=app_details.get("description"), 
-                                      application=app, 
+        app = client.application(application_id, application_version_id, store=store,
+                                 llm=client.get_llm(version_details['llm_settings']['model_name'],
+                                                    model_settings),
+                                 ignored_mcp_servers=ignored_mcp_servers,
+                                 mcp_tokens=mcp_tokens)
+
+        # Extract icon_meta from version_details meta field
+        icon_meta = version_details.get('meta', {}).get('icon_meta', {})
+
+        return cls(tools=[Application(name=app_details.get("name"),
+                                      description=app_details.get("description"),
+                                      application=app,
                                       args_schema=applicationToolSchema,
-                                      return_type='str')])
+                                      return_type='str',
+                                      client=client,
+                                      metadata={'icon_meta': icon_meta} if icon_meta else {},
+                                      is_subgraph=is_subgraph,
+                                      args_runnable={
+                                          "application_id": application_id,
+                                          "application_version_id": application_version_id,
+                                          "store": store,
+                                          "llm": client.get_llm(version_details['llm_settings']['model_name'], model_settings),
+                                          "ignored_mcp_servers": ignored_mcp_servers,
+                                          "is_subgraph": is_subgraph,  # Pass is_subgraph flag
+                                          "mcp_tokens": mcp_tokens,
+                                      })])
             
     def get_tools(self):
         return self.tools

alita_sdk/runtime/toolkits/artifact.py

@@ -1,11 +1,13 @@
 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
 from pydantic.fields import FieldInfo
 from ..tools.artifact import ArtifactWrapper
+from ..utils.constants import TOOLKIT_NAME_META, TOOLKIT_TYPE_META, TOOL_NAME_META
 from ...tools.base.tool import BaseAction
 from ...configurations.pgvector import PgVectorConfiguration
 
@@ -23,11 +25,7 @@ class ArtifactToolkit(BaseToolkit):
             # client = (Any, FieldInfo(description="Client object", required=True, autopopulate=True)),
             bucket=(str, FieldInfo(
                 description="Bucket name",
-                pattern=r'^[a-z][a-z0-9-]*$',
-                json_schema_extra={
-                    'toolkit_name': True,
-                    'max_toolkit_length': ArtifactToolkit.toolkit_max_length
-                }
+                pattern=r'^[a-z][a-z0-9-]*$'
             )),
             selected_tools=(List[Literal[tuple(selected_tools)]], Field(default=[], json_schema_extra={'args_schemas': selected_tools})),
             # indexer settings
@@ -37,30 +35,41 @@ class ArtifactToolkit(BaseToolkit):
             embedding_model=(Optional[str], Field(default=None, description="Embedding configuration.",
                                                   json_schema_extra={'configuration_model': 'embedding'})),
 
-            __config__=ConfigDict(json_schema_extra={'metadata': {"label": "Artifact", "icon_url": None}})
+            __config__=ConfigDict(json_schema_extra={'metadata': {"label": "Artifact",
+                                                                  "icon_url": None,
+                                                                  "max_length": ArtifactToolkit.toolkit_max_length
+                                                                  }})
         )
     
     @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_META: toolkit_name, TOOLKIT_TYPE_META: "artifact", TOOL_NAME_META: tool['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'))