foundationallm-agent-plugins-langchain 0.9.7.post3__tar.gz

foundationallm_agent_plugins_langchain-0.9.7.post3/PKG-INFO

@@ -0,0 +1,26 @@
+Metadata-Version: 2.4
+Name: foundationallm-agent-plugins-langchain
+Version: 0.9.7.post3
+Summary: FoundationaLLM Agent plugins.
+Author-email: FoundationaLLM <dev@foundationallm.ai>
+License-Expression: MIT
+Project-URL: Homepage, https://foundationallm.ai
+Project-URL: Issues, https://github.com/foundationallm/foundationallm/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+
+# FoundationaLLM Agent Plugins LangChain
+
+This package provides the FoundationaLLM agent plugins built on LangChain.
+
+To package and publish the package run the following commands (in the folder where `pyproject.toml` is located):
+
+```cmd
+python -m pip install --upgrade build
+python -m pip install --upgrade twine
+
+python -m build
+python -m twine upload dist/*
+```

foundationallm_agent_plugins_langchain-0.9.7.post3/README.md

@@ -0,0 +1,13 @@
+# FoundationaLLM Agent Plugins LangChain
+
+This package provides the FoundationaLLM agent plugins built on LangChain.
+
+To package and publish the package run the following commands (in the folder where `pyproject.toml` is located):
+
+```cmd
+python -m pip install --upgrade build
+python -m pip install --upgrade twine
+
+python -m build
+python -m twine upload dist/*
+```

foundationallm_agent_plugins_langchain-0.9.7.post3/foundationallm_agent_plugins_langchain/__init__.py

@@ -0,0 +1 @@
+from .workflow_plugin_manager import FoundationaLLMAgentWorkflowLangChainPluginManager

foundationallm_agent_plugins_langchain-0.9.7.post3/foundationallm_agent_plugins_langchain/_metadata/foundationallm_manifest.json

@@ -0,0 +1,7 @@
+{
+    "display_name": "FoundationaLLM Agent Plugins LangChain (Python)",
+    "description": "The FoundationaLLM Agent plugins (built on LangChain) package for Python.",
+    "plugin_managers": [
+        "FoundationaLLMAgentWorkflowLangChainPluginManager"
+    ]
+}

foundationallm_agent_plugins_langchain-0.9.7.post3/foundationallm_agent_plugins_langchain/workflow_plugin_manager.py

@@ -0,0 +1,88 @@
+from typing import List
+
+from foundationallm.config import Configuration, UserIdentity
+from foundationallm.models.agents import (
+    AgentTool,
+    GenericAgentWorkflow,
+    AgentWorkflowBase
+)
+from foundationallm.langchain.common import FoundationaLLMWorkflowBase
+from foundationallm.operations import OperationsManager
+from foundationallm.plugins import WorkflowPluginManagerBase
+from foundationallm_agent_plugins_langchain.workflows import (
+    FoundationaLLMLangChainAgentWorkflow,
+    FoundationaLLMLangChainLCELWorkflow,
+    FoundationaLLMLangGraphReActAgentWorkflow,
+)
+
+class FoundationaLLMAgentWorkflowLangChainPluginManager(WorkflowPluginManagerBase):
+
+    FOUNDATIONALLM_LANGCHAIN_AGENT_WORKFLOW_CLASS_NAME = 'FoundationaLLMLangChainAgentWorkflow'
+    FOUNDATIONALLM_LANGCHAIN_LCEL_WORKFLOW_CLASS_NAME = 'FoundationaLLMLangChainLCELWorkflow'
+    FOUNDATIONALLM_LANGGRAPH_REACT_WORKFLOW_CLASS_NAME = 'FoundationaLLMLangGraphReActAgentWorkflow'
+
+    def __init__(self):
+        super().__init__()
+
+    def create_workflow(self,
+        workflow_config: GenericAgentWorkflow | AgentWorkflowBase,
+        objects: dict,
+        tools: List[AgentTool],
+        operations_manager: OperationsManager,
+        user_identity: UserIdentity,
+        config: Configuration,
+        intercept_http_calls: bool = False) -> FoundationaLLMWorkflowBase:
+        """
+        Creates a workflow instance based on the workflow configuration.
+
+        Parameters
+        ----------
+        workflow_config : GenericAgentWorkflow | AgentWorkflowBase
+            The workflow configuration.
+        objects : dict
+            The exploded objects assigned from the agent.
+        tools : List[FoundationaLLMToolBase]
+            The tools assigned to the agent.
+        user_identity : UserIdentity
+            The user identity of the user initiating the request.
+        config : Configuration
+            The application configuration for FoundationaLLM.
+        intercept_http_calls : bool, optional
+            Whether to intercept HTTP calls made by the workflow, by default False.
+
+        Returns
+        -------
+        FoundationaLLMWorkflowBase
+            The workflow instance.
+        """
+        if workflow_config.class_name == FoundationaLLMAgentWorkflowLangChainPluginManager.FOUNDATIONALLM_LANGCHAIN_AGENT_WORKFLOW_CLASS_NAME:
+            return FoundationaLLMLangChainAgentWorkflow(
+                workflow_config,
+                objects,
+                tools,
+                operations_manager,
+                user_identity,
+                config,
+                intercept_http_calls=intercept_http_calls)
+        if workflow_config.class_name == FoundationaLLMAgentWorkflowLangChainPluginManager.FOUNDATIONALLM_LANGCHAIN_LCEL_WORKFLOW_CLASS_NAME:
+            return FoundationaLLMLangChainLCELWorkflow(
+                workflow_config,
+                objects,
+                tools,
+                operations_manager,
+                user_identity,
+                config,
+                intercept_http_calls=intercept_http_calls)
+        if workflow_config.class_name == FoundationaLLMAgentWorkflowLangChainPluginManager.FOUNDATIONALLM_LANGGRAPH_REACT_WORKFLOW_CLASS_NAME:
+            return FoundationaLLMLangGraphReActAgentWorkflow(
+                workflow_config,
+                objects,
+                tools,
+                operations_manager,
+                user_identity,
+                config,
+                intercept_http_calls=intercept_http_calls)
+        raise ValueError(f'Unknown workflow name: {workflow_config.name}')
+
+    def refresh_tools(self):
+        print('Refreshing tools...')

foundationallm_agent_plugins_langchain-0.9.7.post3/foundationallm_agent_plugins_langchain/workflows/__init__.py

@@ -0,0 +1,3 @@
+from .foundationallm_langchain_agent_workflow import FoundationaLLMLangChainAgentWorkflow
+from .foundationallm_langchain_lcel_workflow import FoundationaLLMLangChainLCELWorkflow
+from .foundationallm_langgraph_react_agent_workflow import FoundationaLLMLangGraphReActAgentWorkflow

foundationallm_agent_plugins_langchain-0.9.7.post3/foundationallm_agent_plugins_langchain/workflows/foundationallm_langchain_agent_workflow.py

@@ -0,0 +1,237 @@
+"""
+Class: FoundationaLLMLangChainAgentWorkflow
+Description: FoundationaLLM agent workflow based on the built-in LangChain ReAct Agent.
+"""
+
+import time
+from dataclasses import dataclass
+from typing import Dict, List, Optional
+from opentelemetry.trace import SpanKind
+
+from langchain_core.messages import (
+    AIMessage,
+    BaseMessage,
+    HumanMessage,
+    ToolMessage
+)
+from langchain.agents import create_agent
+
+from foundationallm.langchain.common import (
+    FoundationaLLMWorkflowBase,
+    FoundationaLLMToolBase
+)
+from foundationallm.config import (
+    Configuration,
+    UserIdentity
+)
+from foundationallm.models.agents import (
+    GenericAgentWorkflow,
+    AgentWorkflowBase
+)
+from foundationallm.models.constants import (
+    AgentCapabilityCategories
+)
+from foundationallm.models.messages import MessageHistoryItem
+from foundationallm.models.orchestration import (
+    CompletionRequestObjectKeys,
+    CompletionResponse,
+    ContentArtifact,
+    FileHistoryItem,
+    OpenAITextMessageContentItem
+)
+from foundationallm.operations import OperationsManager
+
+@dataclass
+class Context:
+    original_user_prompt: str
+    recursion_limit: int
+
+class FoundationaLLMLangChainAgentWorkflow(FoundationaLLMWorkflowBase):
+    """
+    FoundationaLLM workflow based on the LangChain built-in ReAct Agent.
+    """
+
+    def __init__(
+        self,
+        workflow_config: GenericAgentWorkflow | AgentWorkflowBase,
+        objects: Dict,
+        tools: List[FoundationaLLMToolBase],
+        operations_manager: OperationsManager,
+        user_identity: UserIdentity,
+        config: Configuration,
+        intercept_http_calls: bool = False
+    ):
+        """
+        Initializes the FoundationaLLMLangChainAgentWorkflow class with the workflow configuration.
+
+        Parameters
+        ----------
+        workflow_config : GenericAgentWorkflow | AgentWorkflowBase
+            The workflow assigned to the agent.
+        objects : dict
+            The exploded objects assigned from the agent.
+        tools : List[FoundationaLLMToolBase]
+            The tools assigned to the agent.
+        user_identity : UserIdentity
+            The user identity of the user initiating the request.
+        config : Configuration
+            The application configuration for FoundationaLLM.
+        intercept_http_calls : bool, optional
+            Whether to intercept HTTP calls made by the workflow, by default False.
+        """
+        super().__init__(workflow_config, objects, tools, operations_manager, user_identity, config)
+        self.name = workflow_config.name
+        self.default_error_message = workflow_config.properties.get(
+            'default_error_message',
+            'An error occurred while processing the request.') \
+            if workflow_config.properties else 'An error occurred while processing the request.'
+
+        # Sets self.workflow_llm
+        self.create_workflow_llm(intercept_http_calls=intercept_http_calls)
+        self.instance_id = objects.get(CompletionRequestObjectKeys.INSTANCE_ID, None)
+
+    async def invoke_async(
+        self,
+        operation_id: str,
+        user_prompt:str,
+        user_prompt_rewrite: Optional[str],
+        message_history: List[MessageHistoryItem],
+        file_history: List[FileHistoryItem],
+        conversation_id: Optional[str] = None,
+        objects: dict = None
+    )-> CompletionResponse:
+
+        """
+        Invokes the workflow asynchronously.
+
+        Parameters
+        ----------
+        operation_id : str
+            The unique identifier of the FoundationaLLM operation.
+        user_prompt : str
+            The user prompt message.
+        user_prompt_rewrite : str
+            The user prompt rewrite message containing additional context to clarify the user's intent.
+        message_history : List[BaseMessage]
+            The message history.
+        file_history : List[FileHistoryItem]
+            The file history.
+        conversation_id : Optional[str]
+            The conversation identifier for the workflow execution.
+        objects : dict
+            The exploded objects assigned from the agent. This is used to pass additional context to the workflow.
+        """
+
+        workflow_start_time = time.time()
+
+        if objects is None:
+            objects = {}
+
+        content_artifacts: List[ContentArtifact] = []
+        input_tokens = 0
+        output_tokens = 0
+
+        llm_prompt = user_prompt_rewrite or user_prompt
+        workflow_main_prompt = self.create_workflow_main_prompt()
+
+        message_list = self.__get_message_list(
+            llm_prompt,
+            message_history,
+            objects
+        )
+
+        graph = create_agent(
+            model=self.workflow_llm,
+            tools=self.tools,
+            system_prompt=workflow_main_prompt,
+            context_schema=Context
+        )
+
+        # This is a port of the previous graph recursion limit handling
+        # TODO: Clarify if this still has an effect with the new LangGraph implementation
+        graph_recursion_limit = self.workflow_config.properties.get('graph_recursion_limit', None) if self.workflow_config.properties else None
+
+        response = await graph.ainvoke(
+            { "messages": message_list },
+            context=Context(
+                original_user_prompt=llm_prompt,
+                recursion_limit=graph_recursion_limit))
+
+        # TODO: process tool messages with analysis results AIMessage with content='' but has addition_kwargs={'tool_calls';[...]}
+
+        # Get ContentArtifact items from ToolMessages
+        tool_messages = [message for message in response["messages"] if isinstance(message, ToolMessage)]
+        for tool_message in tool_messages:
+            if tool_message.artifact is not None:
+                # if the tool message artifact is a list, check if it contains a ContentArtifact item
+                if isinstance(tool_message.artifact, list):
+                    for item in tool_message.artifact:
+                        if isinstance(item, ContentArtifact):
+                            content_artifacts.append(item)
+
+        final_message = response["messages"][-1]
+        response_content = OpenAITextMessageContentItem(
+            value = final_message.content,
+            agent_capability_category = AgentCapabilityCategories.FOUNDATIONALLM_KNOWLEDGE_MANAGEMENT
+        )
+
+        workflow_end_time = time.time()
+        output_tokens = final_message.usage_metadata["output_tokens"] or 0
+        input_tokens = final_message.usage_metadata["input_tokens"] or 0
+
+
+        workflow_content_artifact = self.create_workflow_execution_content_artifact(
+                llm_prompt,
+                input_tokens,
+                output_tokens,
+                workflow_end_time - workflow_start_time)
+        content_artifacts.append(workflow_content_artifact)
+
+        retvalue = CompletionResponse(
+            operation_id=operation_id,
+            content = [response_content],
+            content_artifacts=content_artifacts,
+            user_prompt=llm_prompt,
+            full_prompt=workflow_main_prompt,
+            completion_tokens=output_tokens,
+            prompt_tokens=input_tokens,
+            total_tokens=output_tokens + input_tokens,
+            total_cost=0
+        )
+        return retvalue
+
+    def __get_message_list(
+        self,
+        llm_prompt: str,
+        message_history: List[MessageHistoryItem],
+        objects: dict
+    ) -> List[BaseMessage]:
+        """
+        Returns the message history in the format required by the workflow.
+
+        Parameters
+        ----------
+        llm_prompt : str
+            The LLM prompt to be processed.
+        message_history : List[MessageHistoryItem]
+            The message history to be processed.
+        objects : dict
+            The exploded objects assigned from the agent. This is used to pass additional context to the workflow.
+        """
+
+        if objects is None:
+            objects = {}
+
+        # Convert message history to LangChain message types
+        messages = []
+        for message in message_history:
+            # Convert MessageHistoryItem to appropriate LangChain message type
+            if message.sender == "User":
+                messages.append(HumanMessage(content=message.text))
+            else:
+                messages.append(AIMessage(content=message.text))
+
+        return [
+            *messages,
+            HumanMessage(content=llm_prompt)
+        ]

foundationallm_agent_plugins_langchain-0.9.7.post3/foundationallm_agent_plugins_langchain/workflows/foundationallm_langchain_lcel_workflow.py

@@ -0,0 +1,285 @@
+"""
+Class: FoundationaLLMLangChainLCELWorkflow
+Description: FoundationaLLM agent workflow based on LangChain LCEL.
+"""
+
+import time
+from typing import Dict, List, Optional
+from opentelemetry.trace import SpanKind
+
+from langchain_classic.callbacks import get_openai_callback
+from langchain_core.output_parsers import StrOutputParser
+from langchain_core.prompts import PromptTemplate
+from langchain_core.runnables import RunnablePassthrough, RunnableLambda
+
+from foundationallm.config import (
+    Configuration,
+    UserIdentity
+)
+from foundationallm.langchain.common import (
+    FoundationaLLMWorkflowBase,
+    FoundationaLLMToolBase
+)
+from foundationallm.langchain.exceptions import LangChainException
+from foundationallm.models.agents import (
+    GenericAgentWorkflow,
+    AgentWorkflowBase
+)
+from foundationallm.models.constants import (
+    AgentCapabilityCategories
+)
+from foundationallm.models.language_models import LanguageModelProvider
+from foundationallm.models.messages import MessageHistoryItem
+from foundationallm.models.orchestration import (
+    CompletionRequestObjectKeys,
+    CompletionResponse,
+    ContentArtifact,
+    FileHistoryItem,
+    OpenAITextMessageContentItem
+)
+from foundationallm.operations import OperationsManager
+
+
+class FoundationaLLMLangChainLCELWorkflow(FoundationaLLMWorkflowBase):
+    """
+    FoundationaLLM workflow based on LangChain LCEL.
+    """
+
+    def __init__(
+        self,
+        workflow_config: GenericAgentWorkflow | AgentWorkflowBase,
+        objects: Dict,
+        tools: List[FoundationaLLMToolBase],
+        operations_manager: OperationsManager,
+        user_identity: UserIdentity,
+        config: Configuration,
+        intercept_http_calls: bool = False
+    ):
+        """
+        Initializes the FoundationaLLMLangChainLCELWorkflow class with the workflow configuration.
+
+        Parameters
+        ----------
+        workflow_config : GenericAgentWorkflow | AgentWorkflowBase
+            The workflow assigned to the agent.
+        objects : dict
+            The exploded objects assigned from the agent.
+        tools : List[FoundationaLLMToolBase]
+            The tools assigned to the agent.
+        user_identity : UserIdentity
+            The user identity of the user initiating the request.
+        config : Configuration
+            The application configuration for FoundationaLLM.
+        intercept_http_calls : bool, optional
+            Whether to intercept HTTP calls made by the workflow, by default False.
+        """
+        super().__init__(workflow_config, objects, tools, operations_manager, user_identity, config)
+        self.name = workflow_config.name
+        self.default_error_message = workflow_config.properties.get(
+            'default_error_message',
+            'An error occurred while processing the request.') \
+            if workflow_config.properties else 'An error occurred while processing the request.'
+
+        # Sets self.workflow_llm
+        self.create_workflow_llm(intercept_http_calls=intercept_http_calls)
+        self.instance_id = objects.get(CompletionRequestObjectKeys.INSTANCE_ID, None)
+
+    async def invoke_async(
+        self,
+        operation_id: str,
+        user_prompt:str,
+        user_prompt_rewrite: Optional[str],
+        message_history: List[MessageHistoryItem],
+        file_history: List[FileHistoryItem],
+        conversation_id: Optional[str] = None,
+        objects: dict = None
+    )-> CompletionResponse:
+
+        """
+        Invokes the workflow asynchronously.
+
+        Parameters
+        ----------
+        operation_id : str
+            The unique identifier of the FoundationaLLM operation.
+        user_prompt : str
+            The user prompt message.
+        user_prompt_rewrite : str
+            The user prompt rewrite message containing additional context to clarify the user's intent.
+        message_history : List[BaseMessage]
+            The message history.
+        file_history : List[FileHistoryItem]
+            The file history.
+        conversation_id : Optional[str]
+            The conversation identifier for the workflow execution.
+        objects : dict
+            The exploded objects assigned from the agent. This is used to pass additional context to the workflow.
+        """
+
+        workflow_start_time = time.time()
+
+        if objects is None:
+            objects = {}
+
+        content_artifacts: List[ContentArtifact] = []
+        input_tokens = 0
+        output_tokens = 0
+
+        llm_prompt = user_prompt_rewrite or user_prompt
+        workflow_main_prompt = self.create_workflow_main_prompt()
+
+        # Get the prompt template.
+        prompt_template = self.__get_prompt_template(
+            workflow_main_prompt,
+            message_history
+        )
+
+        chain_context = { "context": RunnablePassthrough() }
+
+        # Compose LCEL chain
+        chain = (
+            chain_context
+            | prompt_template
+            | RunnableLambda(self.__record_full_prompt)
+            | self.workflow_llm
+        )
+
+        retvalue = None
+
+        ai_model = self.get_workflow_main_model_definition()
+        api_endpoint = self.get_ai_model_api_endpoint_configuration(ai_model)
+
+        if api_endpoint.provider == LanguageModelProvider.MICROSOFT or api_endpoint.provider == LanguageModelProvider.OPENAI:
+            # OpenAI compatible models
+            with get_openai_callback() as cb:
+                # add output parser to openai callback
+                chain = chain | StrOutputParser()
+                try:
+                    with self.tracer.start_as_current_span('langchain_invoke_lcel_chain', kind=SpanKind.SERVER):
+                        completion = await chain.ainvoke(llm_prompt)
+
+                    workflow_end_time = time.time()
+
+                    response_content = OpenAITextMessageContentItem(
+                        value = completion,
+                        agent_capability_category = AgentCapabilityCategories.FOUNDATIONALLM_KNOWLEDGE_MANAGEMENT
+                    )
+
+                    output_tokens = cb.completion_tokens
+                    input_tokens = cb.prompt_tokens
+
+                    workflow_content_artifact = self.create_workflow_execution_content_artifact(
+                            llm_prompt,
+                            input_tokens,
+                            output_tokens,
+                            workflow_end_time - workflow_start_time)
+                    content_artifacts.append(workflow_content_artifact)
+
+                    retvalue = CompletionResponse(
+                            operation_id=operation_id,
+                            content = [response_content],
+                            content_artifacts=content_artifacts,
+                            user_prompt=llm_prompt,
+                            full_prompt=self.full_prompt.text,
+                            completion_tokens = output_tokens,
+                            prompt_tokens = input_tokens,
+                            total_tokens = input_tokens + output_tokens,
+                            total_cost = cb.total_cost
+                        )
+
+                except Exception as e:
+                    raise LangChainException(f"An unexpected exception occurred when executing the completion request: {str(e)}", 500)
+        else:
+            with self.tracer.start_as_current_span('langchain_invoke_lcel_chain', kind=SpanKind.SERVER):
+                completion = await chain.ainvoke(llm_prompt)
+
+            workflow_end_time = time.time()
+
+            response_content = OpenAITextMessageContentItem(
+                value = completion.content,
+                agent_capability_category = AgentCapabilityCategories.FOUNDATIONALLM_KNOWLEDGE_MANAGEMENT
+            )
+
+            output_tokens = completion.usage_metadata["output_tokens"]
+            input_tokens = completion.usage_metadata["input_tokens"]
+
+            workflow_content_artifact = self.create_workflow_execution_content_artifact(
+                    llm_prompt,
+                    input_tokens,
+                    output_tokens,
+                    workflow_end_time - workflow_start_time)
+            content_artifacts.append(workflow_content_artifact)
+
+            retvalue = CompletionResponse(
+                    operation_id=operation_id,
+                    content = [response_content],
+                    content_artifacts=content_artifacts,
+                    user_prompt=llm_prompt,
+                    full_prompt=self.full_prompt.text,
+                    completion_tokens = output_tokens,
+                    prompt_tokens = input_tokens,
+                    total_tokens = input_tokens + output_tokens,
+                    total_cost=0
+                )
+
+        return retvalue
+
+    def __build_conversation_history(
+        self,
+        messages:List[MessageHistoryItem]=None
+    ) -> str:
+        """
+        Builds a chat history string from a list of MessageHistoryItem objects to
+        be added to the prompt for the completion request.
+
+        Parameters
+        ----------
+        messages : List[MessageHistoryItem]
+            The list of messages from which to build the chat history.
+        message_count : int
+            The number of messages to include in the chat history.
+        """
+        if messages is None or len(messages)==0:
+            return ""
+        chat_history = "Chat History:\n"
+        for msg in messages:
+            chat_history += msg.sender + ": " + msg.text + "\n"
+        chat_history += "\n\n"
+        return chat_history
+
+    def __get_prompt_template(
+        self,
+        prompt: str,
+        message_history: List[MessageHistoryItem]
+    ) -> PromptTemplate:
+        """
+        Build a prompt template.
+        """
+
+        prompt_builder = f'{prompt}\n\n'
+
+        # Add the message history, if it exists.
+        prompt_builder += self.__build_conversation_history(message_history)
+
+        # Insert the context into the template.
+        prompt_builder += '{context}'
+
+        # Create the prompt template.
+        return PromptTemplate.from_template(prompt_builder)
+
+    def __record_full_prompt(self, prompt: str) -> str:
+        """
+        Records the full prompt for the completion request.
+
+        Parameters
+        ----------
+        prompt : str
+            The prompt that is populated with context.
+
+        Returns
+        -------
+        str
+            Returns the full prompt.
+        """
+        self.full_prompt = prompt
+        return prompt

foundationallm_agent_plugins_langchain-0.9.7.post3/foundationallm_agent_plugins_langchain/workflows/foundationallm_langgraph_react_agent_workflow.py

@@ -0,0 +1,225 @@
+"""
+Class: FoundationaLLMLangGraphReActAgentWorkflow
+Description: FoundationaLLM agent workflow based on the LangChain LangGraph ReAct Agent.
+"""
+
+import time
+from typing import Dict, List, Optional
+from opentelemetry.trace import SpanKind
+
+from langchain_core.messages import (
+    AIMessage,
+    BaseMessage,
+    HumanMessage,
+    ToolMessage
+)
+from langgraph.prebuilt import create_react_agent
+
+from foundationallm.langchain.common import (
+    FoundationaLLMWorkflowBase,
+    FoundationaLLMToolBase
+)
+from foundationallm.config import (
+    Configuration,
+    UserIdentity
+)
+from foundationallm.models.agents import (
+    GenericAgentWorkflow,
+    AgentWorkflowBase
+)
+from foundationallm.models.constants import (
+    AgentCapabilityCategories
+)
+from foundationallm.models.messages import MessageHistoryItem
+from foundationallm.models.orchestration import (
+    CompletionRequestObjectKeys,
+    CompletionResponse,
+    ContentArtifact,
+    FileHistoryItem,
+    OpenAITextMessageContentItem
+)
+from foundationallm.operations import OperationsManager
+
+
+class FoundationaLLMLangGraphReActAgentWorkflow(FoundationaLLMWorkflowBase):
+    """
+    FoundationaLLM workflow based on the LangGraph ReAct Agent.
+    """
+
+    def __init__(
+        self,
+        workflow_config: GenericAgentWorkflow | AgentWorkflowBase,
+        objects: Dict,
+        tools: List[FoundationaLLMToolBase],
+        operations_manager: OperationsManager,
+        user_identity: UserIdentity,
+        config: Configuration,
+        intercept_http_calls: bool = False
+    ):
+        """
+        Initializes the FoundationaLLMLangGraphReActAgentWorkflow class with the workflow configuration.
+
+        Parameters
+        ----------
+        workflow_config : GenericAgentWorkflow | AgentWorkflowBase
+            The workflow assigned to the agent.
+        objects : dict
+            The exploded objects assigned from the agent.
+        tools : List[FoundationaLLMToolBase]
+            The tools assigned to the agent.
+        user_identity : UserIdentity
+            The user identity of the user initiating the request.
+        config : Configuration
+            The application configuration for FoundationaLLM.
+        intercept_http_calls : bool, optional
+            Whether to intercept HTTP calls made by the workflow, by default False.
+        """
+        super().__init__(workflow_config, objects, tools, operations_manager, user_identity, config)
+        self.name = workflow_config.name
+        self.default_error_message = workflow_config.properties.get(
+            'default_error_message',
+            'An error occurred while processing the request.') \
+            if workflow_config.properties else 'An error occurred while processing the request.'
+
+        # Sets self.workflow_llm
+        self.create_workflow_llm(intercept_http_calls=intercept_http_calls)
+        self.instance_id = objects.get(CompletionRequestObjectKeys.INSTANCE_ID, None)
+
+    async def invoke_async(
+        self,
+        operation_id: str,
+        user_prompt:str,
+        user_prompt_rewrite: Optional[str],
+        message_history: List[MessageHistoryItem],
+        file_history: List[FileHistoryItem],
+        conversation_id: Optional[str] = None,
+        objects: dict = None
+    )-> CompletionResponse:
+
+        """
+        Invokes the workflow asynchronously.
+
+        Parameters
+        ----------
+        operation_id : str
+            The unique identifier of the FoundationaLLM operation.
+        user_prompt : str
+            The user prompt message.
+        user_prompt_rewrite : str
+            The user prompt rewrite message containing additional context to clarify the user's intent.
+        message_history : List[BaseMessage]
+            The message history.
+        file_history : List[FileHistoryItem]
+            The file history.
+        conversation_id : Optional[str]
+            The conversation identifier for the workflow execution.
+        objects : dict
+            The exploded objects assigned from the agent. This is used to pass additional context to the workflow.
+        """
+
+        workflow_start_time = time.time()
+
+        if objects is None:
+            objects = {}
+
+        content_artifacts: List[ContentArtifact] = []
+        input_tokens = 0
+        output_tokens = 0
+
+        llm_prompt = user_prompt_rewrite or user_prompt
+        workflow_main_prompt = self.create_workflow_main_prompt()
+
+        message_list = self.__get_message_list(
+            llm_prompt,
+            message_history,
+            objects
+        )
+
+        graph = create_react_agent(
+            model=self.workflow_llm,
+            tools=self.tools,
+            prompt=workflow_main_prompt
+        )
+
+        response = await graph.ainvoke(
+            { "messages": message_list },
+            config= {"configurable": {"original_user_prompt": llm_prompt, **({"recursion_limit": self.workflow_config.graph_recursion_limit} if self.workflow_config.graph_recursion_limit is not None else {})}}
+        )
+
+        # TODO: process tool messages with analysis results AIMessage with content='' but has addition_kwargs={'tool_calls';[...]}
+
+        # Get ContentArtifact items from ToolMessages
+        tool_messages = [message for message in response["messages"] if isinstance(message, ToolMessage)]
+        for tool_message in tool_messages:
+            if tool_message.artifact is not None:
+                # if the tool message artifact is a list, check if it contains a ContentArtifact item
+                if isinstance(tool_message.artifact, list):
+                    for item in tool_message.artifact:
+                        if isinstance(item, ContentArtifact):
+                            content_artifacts.append(item)
+
+        final_message = response["messages"][-1]
+        response_content = OpenAITextMessageContentItem(
+            value = final_message.content,
+            agent_capability_category = AgentCapabilityCategories.FOUNDATIONALLM_KNOWLEDGE_MANAGEMENT
+        )
+
+        workflow_end_time = time.time()
+        output_tokens = final_message.usage_metadata["output_tokens"] or 0
+        input_tokens = final_message.usage_metadata["input_tokens"] or 0
+
+        workflow_content_artifact = self.create_workflow_execution_content_artifact(
+                llm_prompt,
+                input_tokens,
+                output_tokens,
+                workflow_end_time - workflow_start_time)
+        content_artifacts.append(workflow_content_artifact)
+
+        retvalue = CompletionResponse(
+            operation_id=operation_id,
+            content = [response_content],
+            content_artifacts=content_artifacts,
+            user_prompt=llm_prompt,
+            full_prompt=workflow_main_prompt,
+            completion_tokens=output_tokens,
+            prompt_tokens=input_tokens,
+            total_tokens=output_tokens + input_tokens,
+            total_cost=0
+        )
+        return retvalue
+
+    def __get_message_list(
+        self,
+        llm_prompt: str,
+        message_history: List[MessageHistoryItem],
+        objects: dict
+    ) -> List[BaseMessage]:
+        """
+        Returns the message history in the format required by the workflow.
+
+        Parameters
+        ----------
+        llm_prompt : str
+            The LLM prompt to be processed.
+        message_history : List[MessageHistoryItem]
+            The message history to be processed.
+        objects : dict
+            The exploded objects assigned from the agent. This is used to pass additional context to the workflow.
+        """
+
+        if objects is None:
+            objects = {}
+
+        # Convert message history to LangChain message types
+        messages = []
+        for message in message_history:
+            # Convert MessageHistoryItem to appropriate LangChain message type
+            if message.sender == "User":
+                messages.append(HumanMessage(content=message.text))
+            else:
+                messages.append(AIMessage(content=message.text))
+
+        return [
+            *messages,
+            HumanMessage(content=llm_prompt)
+        ]

foundationallm_agent_plugins_langchain-0.9.7.post3/foundationallm_agent_plugins_langchain.egg-info/PKG-INFO

@@ -0,0 +1,26 @@
+Metadata-Version: 2.4
+Name: foundationallm-agent-plugins-langchain
+Version: 0.9.7.post3
+Summary: FoundationaLLM Agent plugins.
+Author-email: FoundationaLLM <dev@foundationallm.ai>
+License-Expression: MIT
+Project-URL: Homepage, https://foundationallm.ai
+Project-URL: Issues, https://github.com/foundationallm/foundationallm/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+
+# FoundationaLLM Agent Plugins LangChain
+
+This package provides the FoundationaLLM agent plugins built on LangChain.
+
+To package and publish the package run the following commands (in the folder where `pyproject.toml` is located):
+
+```cmd
+python -m pip install --upgrade build
+python -m pip install --upgrade twine
+
+python -m build
+python -m twine upload dist/*
+```

foundationallm_agent_plugins_langchain-0.9.7.post3/foundationallm_agent_plugins_langchain.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+README.md
+pyproject.toml
+foundationallm_agent_plugins_langchain/__init__.py
+foundationallm_agent_plugins_langchain/workflow_plugin_manager.py
+foundationallm_agent_plugins_langchain.egg-info/PKG-INFO
+foundationallm_agent_plugins_langchain.egg-info/SOURCES.txt
+foundationallm_agent_plugins_langchain.egg-info/dependency_links.txt
+foundationallm_agent_plugins_langchain.egg-info/top_level.txt
+foundationallm_agent_plugins_langchain/_metadata/foundationallm_manifest.json
+foundationallm_agent_plugins_langchain/workflows/__init__.py
+foundationallm_agent_plugins_langchain/workflows/foundationallm_langchain_agent_workflow.py
+foundationallm_agent_plugins_langchain/workflows/foundationallm_langchain_lcel_workflow.py
+foundationallm_agent_plugins_langchain/workflows/foundationallm_langgraph_react_agent_workflow.py

foundationallm_agent_plugins_langchain-0.9.7.post3/foundationallm_agent_plugins_langchain.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

foundationallm_agent_plugins_langchain-0.9.7.post3/foundationallm_agent_plugins_langchain.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+dist
+foundationallm_agent_plugins_langchain

foundationallm_agent_plugins_langchain-0.9.7.post3/pyproject.toml

@@ -0,0 +1,24 @@
+[project]
+name = "foundationallm-agent-plugins-langchain"
+version = "0.9.7.post3"
+authors = [
+  { name="FoundationaLLM", email="dev@foundationallm.ai" },
+]
+description = "FoundationaLLM Agent plugins."
+readme = "README.md"
+requires-python = ">=3.11"
+license = "MIT"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+
+[project.urls]
+Homepage = "https://foundationallm.ai"
+Issues = "https://github.com/foundationallm/foundationallm/issues"
+
+[tool.setuptools.packages.find]
+include = ['*']
+
+[tool.setuptools.package-data]
+foundationallm_agent_plugins_langchain = ["_metadata/foundationallm_manifest.json"]

foundationallm_agent_plugins_langchain-0.9.7.post3/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+