swarmauri-standard 0.6.0.dev4__tar.gz

swarmauri_standard-0.6.0.dev4/PKG-INFO

@@ -0,0 +1,80 @@
+Metadata-Version: 2.1
+Name: swarmauri-standard
+Version: 0.6.0.dev4
+Summary: This repository includes standard components within the Swarmauri framework.
+Home-page: http://github.com/swarmauri/swarmauri-sdk
+License: Apache-2.0
+Author: Jacob Stewart
+Author-email: jacob@swarmauri.com
+Requires-Python: >=3.10,<3.13
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Provides-Extra: full
+Provides-Extra: io
+Provides-Extra: ml-toolkits
+Provides-Extra: nlp
+Provides-Extra: nlp-tools
+Provides-Extra: visualization
+Requires-Dist: Pillow (>=8.0,<11.0)
+Requires-Dist: aiofiles (==24.1.0) ; extra == "io" or extra == "full"
+Requires-Dist: aiohttp (>=3.10.10,<4.0.0) ; extra == "io" or extra == "full"
+Requires-Dist: beautifulsoup4 (==04.12.3) ; extra == "nlp-tools" or extra == "full"
+Requires-Dist: httpx (>=0.27.0,<0.28.0)
+Requires-Dist: joblib (>=1.4.0,<2.0.0)
+Requires-Dist: matplotlib (>=3.9.2) ; extra == "visualization" or extra == "full"
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: pydantic (>=2.9.2,<3.0.0)
+Requires-Dist: requests (>=2.32.3,<3.0.0)
+Requires-Dist: scikit-learn (>=1.4.2,<2.0.0) ; extra == "ml-toolkits" or extra == "full"
+Requires-Dist: scipy (>=1.7.0,<1.14.0)
+Requires-Dist: swarmauri_base (>=0.6.0.dev4,<0.7.0)
+Requires-Dist: swarmauri_core (>=0.6.0.dev4,<0.7.0)
+Requires-Dist: toml (>=0.10.2,<0.11.0)
+Requires-Dist: typing_extensions
+Requires-Dist: yake (==0.4.8) ; extra == "nlp" or extra == "full"
+Project-URL: Repository, http://github.com/swarmauri/swarmauri-sdk
+Description-Content-Type: text/markdown
+
+# Swarmauri SDK
+
+The Swarmauri SDK offers a comprehensive suite of tools designed for building distributed, extensible systems using the Swarmauri framework. 
+
+## Core 
+- **Core Interfaces**: Define the fundamental communication and data-sharing protocols between components in a Swarmauri-based system.
+
+## Standard
+- **Base Classes**: Provide a foundation for constructing Swarmauri components, with standardized methods and properties.
+- **Mixins**: Reusable code fragments designed to be integrated into various classes, offering shared functionality across different components.
+- **Concrete Classes**: Ready-to-use, pre-implemented classes that fulfill standard system needs while adhering to Swarmauri principles. **These classes are the first in line for ongoing support and maintenance, ensuring they remain stable, performant, and up to date with future SDK developments.**
+
+## Community
+- **Third-Party Plug-in Integration**: Concrete classes designed to extend the framework’s capabilities by utilizing third-party libraries and plugins.
+- **Open Source Contributions**: A collaborative space for developers to contribute new components, plug-ins, and features.
+
+## Experimental
+- **In-Development Components**: Early-stage features and components that push the boundaries of the Swarmauri framework, offering innovative solutions that are still in testing phases.
+
+# Features
+
+- **Polymorphism**: Allows for dynamic behavior switching between components, enabling flexible, context-aware system behavior.
+- **Discriminated Unions**: Provides a robust method for handling multiple possible object types in a type-safe manner.
+- **Serialization**: Efficiently encode and decode data for transmission across different environments and system components, with support for both standard and custom serialization formats.
+- **Intensional and Extensional Programming**: Leverages both rule-based (intensional) and set-based (extensional) approaches to building and manipulating complex data structures, offering developers a wide range of tools for system design.
+
+## Use Cases
+
+- **Modular Systems**: Develop scalable, pluggable systems that can evolve over time by adding or modifying components without disrupting the entire ecosystem.
+- **Distributed Architectures**: Build systems with distributed nodes that seamlessly communicate using the SDK’s standardized interfaces.
+- **Third-Party Integrations**: Extend the system's capabilities by easily incorporating third-party tools, libraries, and services.
+- **Prototype and Experimentation**: Test cutting-edge ideas using the experimental components in the SDK, while retaining the reliability of core and standard features for production systems.
+
+# Future Development
+
+The Swarmauri SDK is an evolving platform, and the community is encouraged to contribute to its growth. Upcoming releases will focus on enhancing the framework's modularity, providing more advanced serialization methods, and expanding the community-driven component library.
+
+
+

swarmauri_standard-0.6.0.dev4/README.md

@@ -0,0 +1,38 @@
+# Swarmauri SDK
+
+The Swarmauri SDK offers a comprehensive suite of tools designed for building distributed, extensible systems using the Swarmauri framework. 
+
+## Core 
+- **Core Interfaces**: Define the fundamental communication and data-sharing protocols between components in a Swarmauri-based system.
+
+## Standard
+- **Base Classes**: Provide a foundation for constructing Swarmauri components, with standardized methods and properties.
+- **Mixins**: Reusable code fragments designed to be integrated into various classes, offering shared functionality across different components.
+- **Concrete Classes**: Ready-to-use, pre-implemented classes that fulfill standard system needs while adhering to Swarmauri principles. **These classes are the first in line for ongoing support and maintenance, ensuring they remain stable, performant, and up to date with future SDK developments.**
+
+## Community
+- **Third-Party Plug-in Integration**: Concrete classes designed to extend the framework’s capabilities by utilizing third-party libraries and plugins.
+- **Open Source Contributions**: A collaborative space for developers to contribute new components, plug-ins, and features.
+
+## Experimental
+- **In-Development Components**: Early-stage features and components that push the boundaries of the Swarmauri framework, offering innovative solutions that are still in testing phases.
+
+# Features
+
+- **Polymorphism**: Allows for dynamic behavior switching between components, enabling flexible, context-aware system behavior.
+- **Discriminated Unions**: Provides a robust method for handling multiple possible object types in a type-safe manner.
+- **Serialization**: Efficiently encode and decode data for transmission across different environments and system components, with support for both standard and custom serialization formats.
+- **Intensional and Extensional Programming**: Leverages both rule-based (intensional) and set-based (extensional) approaches to building and manipulating complex data structures, offering developers a wide range of tools for system design.
+
+## Use Cases
+
+- **Modular Systems**: Develop scalable, pluggable systems that can evolve over time by adding or modifying components without disrupting the entire ecosystem.
+- **Distributed Architectures**: Build systems with distributed nodes that seamlessly communicate using the SDK’s standardized interfaces.
+- **Third-Party Integrations**: Extend the system's capabilities by easily incorporating third-party tools, libraries, and services.
+- **Prototype and Experimentation**: Test cutting-edge ideas using the experimental components in the SDK, while retaining the reliability of core and standard features for production systems.
+
+# Future Development
+
+The Swarmauri SDK is an evolving platform, and the community is encouraged to contribute to its growth. Upcoming releases will focus on enhancing the framework's modularity, providing more advanced serialization methods, and expanding the community-driven component library.
+
+

swarmauri_standard-0.6.0.dev4/pyproject.toml

@@ -0,0 +1,128 @@
+[tool.poetry]
+name = "swarmauri-standard"
+version = "0.6.0.dev4"
+description = "This repository includes standard components within the Swarmauri framework."
+authors = ["Jacob Stewart <jacob@swarmauri.com>"]
+license = "Apache-2.0"
+readme = "README.md"
+repository = "http://github.com/swarmauri/swarmauri-sdk"
+classifiers = [
+    "License :: OSI Approved :: Apache Software License",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12"
+]
+
+[tool.poetry.dependencies]
+python = ">=3.10,<3.13"
+
+# Swarmauri
+swarmauri_core = "^0.6.0.dev4"
+swarmauri_base = "^0.6.0.dev4"
+
+# Dependencies
+toml = "^0.10.2"
+httpx = "^0.27.0"
+joblib = "^1.4.0"
+numpy = "*"
+pandas = "*"
+pydantic = "^2.9.2"
+typing_extensions = "*"
+
+# We should remove and only rely on httpx
+requests = "^2.32.3"
+
+# This should be set to optional also
+Pillow = ">=8.0,<11.0"
+
+# Optional dependencies with versions specified
+aiofiles = { version = "24.1.0", optional = true }
+aiohttp = { version = "^3.10.10", optional = true }
+#cohere = { version = "^5.11.0", optional = true }
+#mistralai = { version = "^1.2.1", optional = true }
+#fal-client = { version = ">=0.5.0", optional = true }
+#google-generativeai = { version = "^0.8.3", optional = true }
+#openai = { version = "^1.52.0", optional = true }
+#nltk = { version = "^3.9.1", optional = true }
+#textblob = { version = "^0.18.0", optional = true }
+yake = { version = "==0.4.8", optional = true }
+beautifulsoup4 = { version = "04.12.3", optional = true }
+#gensim = { version = "==4.3.3", optional = true }
+scipy = { version = ">=1.7.0,<1.14.0", optional = true }
+scikit-learn = { version = "^1.4.2", optional = true }
+#spacy = { version = ">=3.0.0,<=3.8.2", optional = true }
+#transformers = { version = "^4.45.0", optional = true }
+#torch = { version = "^2.5.0", optional = true }
+#keras = { version = ">=3.2.0", optional = true }
+#tf-keras = { version = ">=2.16.0", optional = true }
+matplotlib = { version = ">=3.9.2", optional = true }
+
+[tool.poetry.extras]
+# Extras without versioning, grouped for specific use cases
+io = ["aiofiles", "aiohttp"]
+#llms = ["cohere", "mistralai", "fal-client", "google-generativeai", "openai"]
+nlp = [
+    #"nltk", 
+    #"textblob", 
+    "yake"
+]
+nlp_tools = ["beautifulsoup4"]
+#ml_toolkits = ["gensim", "scipy", "scikit-learn"]
+ml_toolkits = ["scikit-learn"]
+#spacy = ["spacy"]
+#transformers = ["transformers"]
+#torch = ["torch"]
+#tensorflow = ["keras", "tf-keras"]
+visualization = ["matplotlib"]
+
+# Full option to install all extras
+full = [
+    "aiofiles", "aiohttp",
+    #"cohere", "mistralai", "fal-client", "google-generativeai", "openai",
+    #"nltk", "textblob", 
+    "yake",
+    "beautifulsoup4",
+    "scikit-learn",
+    #"gensim", "scipy", "scikit-learn",
+    #"spacy",
+    #"transformers",
+    #"torch",
+    #"keras", "tf-keras",
+    "matplotlib"
+]
+
+[tool.poetry.dev-dependencies]
+flake8 = "^7.0"
+pytest = "^8.0"
+pytest-asyncio = ">=0.24.0"
+pytest-timeout = "^2.3.1"
+pytest-xdist = "^3.6.1"
+pytest-json-report = "^1.5.0"
+python-dotenv = "^1.0.0"
+jsonschema = "^4.18.5"
+ipython = "^8.28.0"
+requests = "^2.32.3"
+
+[build-system]
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.pytest.ini_options]
+norecursedirs = ["combined", "scripts"]
+asyncio_mode = "auto"
+
+markers = [
+    "test: standard test",
+    "unit: Unit tests",
+    "integration: Integration tests",
+    "acceptance: Acceptance tests",
+    "experimental: Experimental tests",
+    "timeout: mark test to timeout after X seconds",
+]
+
+log_cli = true
+log_cli_level = "INFO"
+log_cli_format = "%(asctime)s [%(levelname)s] %(message)s"
+log_cli_date_format = "%Y-%m-%d %H:%M:%S"
+
+asyncio_default_fixture_loop_scope = "function"

swarmauri_standard-0.6.0.dev4/swarmauri_standard/README.md

@@ -0,0 +1,37 @@
+# Standard Library
+
+
+The Standard Library extends the Core Library with concrete implementations of models, agents, tools, parsers, and more. It aims to provide ready-to-use components that can be easily integrated into machine learning projects.
+
+## Features
+
+- **Predefined Models and Agents**: Implements standard models and agents ready for use.
+- **Toolkit**: A collection of tools for various tasks (e.g., weather information, math operations).
+- **Parsers Implementations**: Various parsers for text data, including HTML and CSV parsers.
+- **Conversations and Chunkers**: Manage conversation histories and chunk text data.
+- **Vectorizers**: Transform text data into vector representations.
+- **Document Stores and Vector Stores**: Concrete implementations for storing and retrieving data.
+
+## Getting Started
+
+To make the best use of the Standard Library, first ensure that the Core Library is set up in your project as the Standard Library builds upon it.
+
+```python
+# Example usage of a concrete model from the Standard Library
+from swarmauri.standard.models.concrete import OpenAIModel
+
+# Initialize the model with necessary configuration
+model = OpenAIModel(api_key="your_api_key_here")
+```
+
+## Documentation
+
+For more detailed guides and API documentation, check the [Docs](/docs) directory within the library. You'll find examples, configuration options, and best practices for utilizing the provided components.
+
+## Contributing
+
+Your contributions can help the Standard Library grow! Whether it's adding new tools, improving models, or writing documentation, we appreciate your help. Please send a pull request with your contributions.
+
+## License
+
+Please see the `LICENSE` file in the repository for details.

swarmauri_standard-0.6.0.dev4/swarmauri_standard/__init__.py

@@ -0,0 +1,37 @@
+__long_desc__ = """
+# Swarmauri Standard SDK
+
+The Swarmauri Standard SDK offers a comprehensive suite of tools designed for building distributed, extensible systems using the Swarmauri framework. 
+
+## Standard
+- **Base Classes**: Provide a foundation for constructing Swarmauri components, with standardized methods and properties.
+- **Mixins**: Reusable code fragments designed to be integrated into various classes, offering shared functionality across different components.
+- **Concrete Classes**: Ready-to-use, pre-implemented classes that fulfill standard system needs while adhering to Swarmauri principles. **These classes are the first in line for ongoing support and maintenance, ensuring they remain stable, performant, and up to date with future SDK developments.**
+
+# Features
+
+- **Polymorphism**: Allows for dynamic behavior switching between components, enabling flexible, context-aware system behavior.
+- **Discriminated Unions**: Provides a robust method for handling multiple possible object types in a type-safe manner.
+- **Serialization**: Efficiently encode and decode data for transmission across different environments and system components, with support for both standard and custom serialization formats.
+- **Intensional and Extensional Programming**: Leverages both rule-based (intensional) and set-based (extensional) approaches to building and manipulating complex data structures, offering developers a wide range of tools for system design.
+
+## Use Cases
+
+- **Modular Systems**: Develop scalable, pluggable systems that can evolve over time by adding or modifying components without disrupting the entire ecosystem.
+- **Distributed Architectures**: Build systems with distributed nodes that seamlessly communicate using the SDK’s standardized interfaces.
+- **Third-Party Integrations**: Extend the system's capabilities by easily incorporating third-party tools, libraries, and services.
+- **Prototype and Experimentation**: Test cutting-edge ideas using the experimental components in the SDK, while retaining the reliability of core and standard features for production systems.
+
+# Future Development
+
+The Swarmauri SDK is an evolving platform, and the community is encouraged to contribute to its growth. Upcoming releases will focus on enhancing the framework's modularity, providing more advanced serialization methods, and expanding the community-driven component library.
+
+Visit us at: https://swarmauri.com
+Follow us at: https://github.com/swarmauri 
+"""
+from .__version__ import __version__
+
+__all__ = [
+    "__version__",
+    # other packages you want to expose
+]

swarmauri_standard-0.6.0.dev4/swarmauri_standard/__version__.py

@@ -0,0 +1 @@
+__version__ = "0.5.2.dev1"

swarmauri_standard-0.6.0.dev4/swarmauri_standard/agents/QAAgent.py

@@ -0,0 +1,19 @@
+from typing import Any, Optional, Dict, Literal
+from swarmauri_base.agents.AgentBase import AgentBase
+from swarmauri.conversations.concrete.MaxSystemContextConversation import MaxSystemContextConversation
+from swarmauri.messages.concrete.HumanMessage import HumanMessage
+
+
+class QAAgent(AgentBase):
+    conversation: MaxSystemContextConversation = MaxSystemContextConversation(max_size=2)
+    type: Literal['QAAgent'] = 'QAAgent'
+
+    def exec(self, 
+        input_str: Optional[str] = "",
+        llm_kwargs: Optional[Dict] = {} 
+        ) -> Any:
+        
+        self.conversation.add_message(HumanMessage(content=input_str))
+        self.llm.predict(conversation=self.conversation, **llm_kwargs)
+        
+        return self.conversation.get_last().content

swarmauri_standard-0.6.0.dev4/swarmauri_standard/agents/RagAgent.py

@@ -0,0 +1,99 @@
+from typing import Any, Optional, Union, Dict, Literal
+from swarmauri_core.messages import IMessage
+
+from swarmauri_base.agents.AgentBase import AgentBase
+from swarmauri_base.agents.AgentRetrieveMixin import AgentRetrieveMixin
+from swarmauri_base.agents.AgentConversationMixin import AgentConversationMixin
+from swarmauri_base.agents.AgentVectorStoreMixin import AgentVectorStoreMixin
+from swarmauri_base.agents.AgentSystemContextMixin import AgentSystemContextMixin
+
+from swarmauri.messages.concrete import (HumanMessage, 
+                                                  SystemMessage,
+                                                  AgentMessage)
+
+from swarmauri_core.typing import SubclassUnion
+from swarmauri_base.llms.LLMBase import LLMBase
+from swarmauri_base.conversations.ConversationBase import ConversationBase
+from swarmauri_base.vector_stores.VectorStoreBase import VectorStoreBase
+
+class RagAgent(AgentRetrieveMixin, 
+               AgentVectorStoreMixin, 
+               AgentSystemContextMixin, 
+               AgentConversationMixin, 
+               AgentBase):
+    """
+    RagAgent (Retriever-And-Generator Agent) extends DocumentAgentBase,
+    specialized in retrieving documents based on input queries and generating responses.
+    """
+    llm: SubclassUnion[LLMBase]
+    conversation: SubclassUnion[ConversationBase]
+    vector_store: SubclassUnion[VectorStoreBase]
+    system_context:  Union[SystemMessage, str]
+    type: Literal['RagAgent'] = 'RagAgent'
+    
+    def _create_preamble_context(self):
+        substr = self.system_context.content
+        substr += '\n\n'
+        substr += '\n'.join([doc.content for doc in self.last_retrieved])
+        return substr
+
+    def _create_post_context(self):
+        substr = '\n'.join([doc.content for doc in self.last_retrieved])
+        substr += '\n\n'
+        substr += self.system_context.content
+        return substr
+
+    def exec(self, 
+             input_data: Optional[Union[str, IMessage]] = "", 
+             top_k: int = 5, 
+             preamble: bool = True,
+             fixed: bool = False,
+             llm_kwargs: Optional[Dict] = {}
+             ) -> Any:
+        try:
+            # Check if the input is a string, then wrap it in a HumanMessage
+            if isinstance(input_data, str):
+                human_message = HumanMessage(content=input_data)
+            elif isinstance(input_data, IMessage):
+                human_message = input_data
+            else:
+                raise TypeError("Input data must be a string or an instance of Message.")
+            
+            # Add the human message to the conversation
+            self.conversation.add_message(human_message)
+
+            # Retrieval and set new substr for system context
+            if top_k > 0 and len(self.vector_store.documents) > 0:
+                self.last_retrieved = self.vector_store.retrieve(query=input_data, top_k=top_k)
+
+                if preamble:
+                    substr = self._create_preamble_context()
+                else:
+                    substr = self._create_post_context()
+
+            else:
+                if fixed:
+                    if preamble:
+                        substr = self._create_preamble_context()
+                    else:
+                        substr = self._create_post_context()
+                else:
+                    substr = self.system_context.content
+                    self.last_retrieved = []
+                
+            # Use substr to set system context
+            system_context = SystemMessage(content=substr)
+            self.conversation.system_context = system_context
+            
+
+            # Retrieve the conversation history and predict a response
+            if llm_kwargs:
+                self.llm.predict(conversation=self.conversation, **llm_kwargs)
+            else:
+                self.llm.predict(conversation=self.conversation)
+                
+            return self.conversation.get_last().content
+
+        except Exception as e:
+            print(f"RagAgent error: {e}")
+            raise e

swarmauri_standard-0.6.0.dev4/swarmauri_standard/agents/SimpleConversationAgent.py

@@ -0,0 +1,28 @@
+from typing import Any, Optional, Dict, Literal, List, Union
+
+from swarmauri_base.agents.AgentBase import AgentBase
+from swarmauri_base.agents.AgentConversationMixin import AgentConversationMixin
+from swarmauri.messages.concrete import HumanMessage
+
+from swarmauri_core.typing import SubclassUnion
+from swarmauri_base.conversations.ConversationBase import ConversationBase
+
+from swarmauri.messages.concrete.HumanMessage import contentItem
+
+
+class SimpleConversationAgent(AgentConversationMixin, AgentBase):
+    conversation: SubclassUnion[ConversationBase]  #
+    type: Literal["SimpleConversationAgent"] = "SimpleConversationAgent"
+
+    def exec(
+        self,
+        input_data: Optional[Union[str, List[contentItem]]] = "",
+        llm_kwargs: Optional[Dict] = {},
+    ) -> Any:
+
+        if input_str:
+            human_message = HumanMessage(content=input_str)
+            self.conversation.add_message(human_message)
+
+        self.llm.predict(conversation=self.conversation, **llm_kwargs)
+        return self.conversation.get_last().content

swarmauri_standard-0.6.0.dev4/swarmauri_standard/agents/ToolAgent.py

@@ -0,0 +1,47 @@
+from pydantic import ConfigDict
+from typing import Any, Optional, Union, Dict, Literal
+import json
+import logging
+from swarmauri_core.messages import IMessage
+
+from swarmauri_base.llms.LLMBase import LLMBase
+from swarmauri_base.agents.AgentBase import AgentBase
+from swarmauri_base.agents.AgentConversationMixin import AgentConversationMixin
+from swarmauri_base.agents.AgentToolMixin import AgentToolMixin
+from swarmauri.messages.concrete import HumanMessage, AgentMessage, FunctionMessage
+
+from swarmauri_core.typing import SubclassUnion
+from swarmauri_base.toolkits.ToolkitBase import ToolkitBase
+from swarmauri_base.conversations.ConversationBase import ConversationBase
+
+class ToolAgent(AgentToolMixin, AgentConversationMixin, AgentBase):
+    llm: SubclassUnion[LLMBase]
+    toolkit: SubclassUnion[ToolkitBase]
+    conversation: SubclassUnion[ConversationBase] # 🚧  Placeholder
+    model_config = ConfigDict(extra='forbid', arbitrary_types_allowed=True)
+    type: Literal['ToolAgent'] = 'ToolAgent'
+    
+    def exec(self, 
+        input_data: Optional[Union[str, IMessage]] = "",  
+        llm_kwargs: Optional[Dict] = {}) -> Any:
+
+        # Check if the input is a string, then wrap it in a HumanMessage
+        if isinstance(input_data, str):
+            human_message = HumanMessage(content=input_data)
+        elif isinstance(input_data, IMessage):
+            human_message = input_data
+        else:
+            raise TypeError("Input data must be a string or an instance of Message.")
+
+        # Add the human message to the conversation
+        self.conversation.add_message(human_message)
+
+        #predict a response        
+        self.conversation = self.llm.predict(
+            conversation=self.conversation, 
+            toolkit=self.toolkit, 
+            **llm_kwargs)
+
+        logging.info(self.conversation.get_last().content)
+
+        return self.conversation.get_last().content

swarmauri_standard-0.6.0.dev4/swarmauri_standard/agents/__init__.py

@@ -0,0 +1,16 @@
+from swarmauri.utils._lazy_import import _lazy_import
+
+# List of agent names (file names without the ".py" extension) and corresponding class names
+agent_files = [
+    ("swarmauri.agents.concrete.QAAgent", "QAAgent"),
+    ("swarmauri.agents.concrete.RagAgent", "RagAgent"),
+    ("swarmauri.agents.concrete.SimpleConversationAgent", "SimpleConversationAgent"),
+    ("swarmauri.agents.concrete.ToolAgent", "ToolAgent"),
+]
+
+# Lazy loading of agent classes, storing them in variables
+for module_name, class_name in agent_files:
+    globals()[class_name] = _lazy_import(module_name, class_name)
+
+# Adding the lazy-loaded agent classes to __all__
+__all__ = [class_name for _, class_name in agent_files]

swarmauri_standard-0.6.0.dev4/swarmauri_standard/chains/CallableChain.py

@@ -0,0 +1,29 @@
+from typing import Any, Callable, List, Dict, Optional
+from swarmauri_core.chains.ICallableChain import ICallableChain, CallableDefinition
+
+
+class CallableChain(ICallableChain):
+    
+    def __init__(self, callables: Optional[List[CallableDefinition]] = None):
+        
+        self.callables = callables if callables is not None else []
+
+    def __call__(self, *initial_args, **initial_kwargs):
+        result = None
+        for func, args, kwargs in self.callables:
+            if result is not None:
+                # If there was a previous result, use it as the first argument for the next function
+                args = [result] + list(args)
+            result = func(*args, **kwargs)
+        return result
+    
+    def add_callable(self, func: Callable[[Any], Any], args: List[Any] = None, kwargs: Dict[str, Any] = None) -> None:
+        # Add a new callable to the chain
+        self.callables.append((func, args or [], kwargs or {}))
+    
+    def __or__(self, other: "CallableChain") -> "CallableChain":
+        if not isinstance(other, CallableChain):
+            raise TypeError("Operand must be an instance of CallableChain")
+        
+        new_chain = CallableChain(self.callables + other.callables)
+        return new_chain

swarmauri_standard-0.6.0.dev4/swarmauri_standard/chains/ChainStep.py

@@ -0,0 +1,8 @@
+from typing import Literal
+from swarmauri_base.chains.ChainStepBase import ChainStepBase
+
+class ChainStep(ChainStepBase):
+    """
+    Represents a single step within an execution chain.
+    """
+    type: Literal['ChainStep'] = 'ChainStep'

swarmauri_standard-0.6.0.dev4/swarmauri_standard/chains/ContextChain.py

@@ -0,0 +1,48 @@
+from typing import Any, Dict, List, Callable, Optional, Tuple, Union, Literal
+from swarmauri_core.typing import SubclassUnion
+from swarmauri_base.tools.ToolBase import ToolBase
+from swarmauri.chains.concrete.ChainStep import ChainStep
+from swarmauri_base.chains.ChainContextBase import ChainContextBase
+from swarmauri_core.chains.IChain import IChain
+
+
+class ContextChain(IChain, ChainContextBase):
+    """
+    Enhanced to support ChainSteps with return parameters, storing return values as instance state variables.
+    Implements the IChain interface including get_schema_info and remove_step methods.
+    """
+
+    type: Literal["ContextChain"] = "ContextChain"
+
+    def add_step(
+        self,
+        key: str,
+        method: SubclassUnion[ToolBase],
+        args: Tuple = (),
+        kwargs: Dict[str, Any] = {},
+        ref: Optional[str] = None,
+    ):
+        # Directly store args, kwargs, and optionally a return_key without resolving them
+        step = ChainStep(key=key, method=method, args=args, kwargs=kwargs, ref=ref)
+        self.steps.append(step)
+
+    def remove_step(self, step: ChainStep) -> None:
+        self.steps = [s for s in self._steps if s.key != step.key]
+
+    def execute(self, *args, **kwargs) -> Dict[str, Any]:
+        # Execute the chain and manage result storage based on return_key
+        for step in self.steps:
+            resolved_args = [self._resolve_placeholders(arg) for arg in step.args]
+            resolved_kwargs = {
+                k: self._resolve_placeholders(v)
+                for k, v in step.kwargs.items()
+                if k != "ref"
+            }
+            result = step.method(*resolved_args, **resolved_kwargs)
+            if step.ref:  # step.ref is used here as the return_key analogy
+                resolved_ref = self._resolve_ref(step.ref)
+                self.context[resolved_ref] = result
+                self.update(
+                    **{resolved_ref: result}
+                )  # Update context with new state value
+        return self.context  # or any specific result you intend to return

swarmauri_standard-0.6.0.dev4/swarmauri_standard/chains/PromptContextChain.py

@@ -0,0 +1,5 @@
+from typing import Literal
+from swarmauri_base.chains.PromptContextChainBase import PromptContextChainBase
+
+class PromptContextChain(PromptContextChainBase):
+    type: Literal['PromptContextChain'] = 'PromptContextChain'

swarmauri_standard-0.6.0.dev4/swarmauri_standard/chains/__init__.py

@@ -0,0 +1,15 @@
+from swarmauri.utils._lazy_import import _lazy_import
+
+chains_files = [
+    ("swarmauri.chains.concrete.CallableChain import", "CallableChain"),
+    ("swarmauri.chains.concrete.ChainStep", "ChainStep"),
+    ("swarmauri.chains.concrete.PromptContextChain", "PromptContextChain"),
+    ("swarmauri.chains.concrete.ContextChain", "ContextChain"),
+]
+
+# Lazy loading of chain classes, storing them in variables
+for module_name, class_name in chains_files:
+    globals()[class_name] = _lazy_import(module_name, class_name)
+
+# Adding the lazy-loaded chain classes to __all__
+__all__ = [class_name for _, class_name in chains_files]