flowcept 0.9.17__py3-none-any.whl → 0.9.19__py3-none-any.whl

flowcept/agents/agent_client.py

@@ -1,4 +1,6 @@
 import asyncio
+import json
+import re
 from typing import Dict, List, Callable
 
 from flowcept.configs import AGENT_HOST, AGENT_PORT
@@ -48,10 +50,14 @@ def run_tool(
                 result: List[TextContent] = await session.call_tool(tool_name, arguments=kwargs)
                 actual_result = []
                 for r in result.content:
-                    if isinstance(r, str):
-                        actual_result.append(r)
-                    else:
-                        actual_result.append(r.text)
+                    text = r if isinstance(r, str) else r.text
+                    try:
+                        json.loads(text)
+                        actual_result.append(text)
+                    except Exception:
+                        match = re.search(r"Error code:\\s*(\\d+)", text)
+                        code = int(match.group(1)) if match else 400
+                        actual_result.append(json.dumps({"code": code, "result": text, "tool_name": tool_name}))
 
                 return actual_result
 

flowcept/agents/agents_utils.py

@@ -1,4 +1,6 @@
 import os
+import re
+import unicodedata
 from typing import Union, Dict
 
 from flowcept.flowceptor.consumers.agent.base_agent_context_manager import BaseAgentContextManager
@@ -137,8 +139,8 @@ def build_llm_model(
     if _service_provider == "sambanova":
         from langchain_community.llms.sambanova import SambaStudio
 
-        os.environ["SAMBASTUDIO_URL"] = AGENT.get("llm_server_url")
-        os.environ["SAMBASTUDIO_API_KEY"] = AGENT.get("api_key")
+        os.environ["SAMBASTUDIO_URL"] = os.environ.get("SAMBASTUDIO_URL", AGENT.get("llm_server_url"))
+        os.environ["SAMBASTUDIO_API_KEY"] = os.environ.get("SAMBASTUDIO_API_KEY", AGENT.get("api_key"))
 
         llm = SambaStudio(model_kwargs=_model_kwargs)
     elif _service_provider == "azure":
@@ -153,7 +155,16 @@ def build_llm_model(
         from langchain_openai import ChatOpenAI
 
         api_key = os.environ.get("OPENAI_API_KEY", AGENT.get("api_key", None))
-        llm = ChatOpenAI(openai_api_key=api_key, **model_kwargs)
+        base_url = os.environ.get("OPENAI_BASE_URL", AGENT.get("llm_server_url") or None)
+        org = os.environ.get("OPENAI_ORG_ID", AGENT.get("organization", None))
+
+        init_kwargs = {"api_key": api_key}
+        if base_url:
+            init_kwargs["base_url"] = base_url
+        if org:
+            init_kwargs["organization"] = org
+
+        llm = ChatOpenAI(**init_kwargs, **_model_kwargs)
     elif _service_provider == "google":
         if "claude" in _model_kwargs["model"]:
             api_key = os.environ.get("GOOGLE_API_KEY", AGENT.get("api_key", None))
@@ -166,22 +177,6 @@ def build_llm_model(
             from flowcept.agents.llms.gemini25 import Gemini25LLM
 
             llm = Gemini25LLM(**_model_kwargs)
-    elif _service_provider == "openai":
-        from langchain_openai import ChatOpenAI
-
-        api_key = os.environ.get("OPENAI_API_KEY", AGENT.get("api_key"))
-        base_url = os.environ.get("OPENAI_BASE_URL", AGENT.get("llm_server_url") or None)  # optional
-        org = os.environ.get("OPENAI_ORG_ID", AGENT.get("organization", None))  # optional
-
-        init_kwargs = {"api_key": api_key}
-        if base_url:
-            init_kwargs["base_url"] = base_url
-        if org:
-            init_kwargs["organization"] = org
-
-        # IMPORTANT: use the merged kwargs so `model` and temps flow through
-        llm = ChatOpenAI(**init_kwargs, **_model_kwargs)
-
     else:
         raise Exception("Currently supported providers are sambanova, openai, azure, and google.")
     if track_tools:
@@ -194,3 +189,43 @@ def build_llm_model(
             if tool_task:
                 llm.parent_task_id = tool_task.task_id
     return llm
+
+
+def normalize_message(user_msg: str) -> str:
+    """
+    Normalize a user message into a canonical, comparison-friendly form.
+
+    The function standardizes text by trimming whitespace, applying Unicode
+    normalization, normalizing dash characters, collapsing repeated whitespace,
+    removing trailing punctuation that does not affect semantics, and converting
+    the result to lowercase.
+
+    Parameters
+    ----------
+    user_msg : str
+        Raw user input message.
+
+    Returns
+    -------
+    str
+        Normalized message suitable for matching, comparison, or hashing.
+    """
+    # 1) Strip leading/trailing whitespace
+    user_msg = user_msg.strip()
+
+    # 2) Unicode normalize to avoid weird characters (like fancy quotes, dashes)
+    user_msg = unicodedata.normalize("NFKC", user_msg)
+
+    # 3) Normalize dashes commonly used in chemistry (C–H, C—H, etc.)
+    user_msg = user_msg.replace("–", "-").replace("—", "-")
+
+    # 4) Collapse multiple spaces / newlines into a single space
+    user_msg = re.sub(r"\s+", " ", user_msg)
+
+    # 5) Remove trailing punctuation that doesn't change semantics
+    #    e.g., "?", "!", "." at the VERY end
+    user_msg = re.sub(r"[?!.\s]+$", "", user_msg)
+
+    user_msg = user_msg.lower()
+
+    return user_msg

flowcept/agents/flowcept_agent.py

@@ -1,29 +1,133 @@
+import json
+import os
 from threading import Thread
-from time import sleep
 
 from flowcept.agents import check_liveness
+from flowcept.agents.agents_utils import ToolResult
+from flowcept.agents.tools.general_tools import prompt_handler
 from flowcept.agents.agent_client import run_tool
-from flowcept.agents.flowcept_ctx_manager import mcp_flowcept
-from flowcept.configs import AGENT_HOST, AGENT_PORT
-from flowcept.flowcept_api.flowcept_controller import Flowcept
+from flowcept.agents.flowcept_ctx_manager import mcp_flowcept, ctx_manager
+from flowcept.commons.flowcept_logger import FlowceptLogger
+from flowcept.configs import AGENT_HOST, AGENT_PORT, DUMP_BUFFER_PATH, MQ_ENABLED
+from flowcept.flowceptor.consumers.agent.base_agent_context_manager import BaseAgentContextManager
+from uuid import uuid4
 
 import uvicorn
 
 
-def main():
+class FlowceptAgent:
     """
-    Start the MCP server.
+    Flowcept agent server wrapper with optional offline buffer loading.
     """
-    f = Flowcept(start_persistence=False, save_workflow=False, check_safe_stops=False).start()
-    f.logger.info(f"This section's workflow_id={Flowcept.current_workflow_id}")
 
-    def run():
-        uvicorn.run(mcp_flowcept.streamable_http_app, host=AGENT_HOST, port=AGENT_PORT, lifespan="on")
+    def __init__(self, buffer_path: str | None = None):
+        """
+        Initialize a FlowceptAgent.
+
+        Parameters
+        ----------
+        buffer_path : str or None
+            Optional path to a JSONL buffer file. When MQ is disabled, the agent
+            loads this file once at startup.
+        """
+        self.buffer_path = buffer_path
+        self.logger = FlowceptLogger()
+        self._server_thread: Thread | None = None
+        self._server = None
+
+    def _load_buffer_once(self) -> int:
+        """
+        Load messages from a JSONL buffer file into the agent context.
+
+        Returns
+        -------
+        int
+            Number of messages loaded.
+        """
+        path = self.buffer_path or DUMP_BUFFER_PATH
+        if not os.path.exists(path):
+            raise FileNotFoundError(f"Buffer file not found: {path}")
+
+        count = 0
+        self.logger.info(f"Loading agent buffer from {path}")
+        if ctx_manager.agent_id is None:
+            agent_id = str(uuid4())
+            BaseAgentContextManager.agent_id = agent_id
+            ctx_manager.agent_id = agent_id
+        with open(path, "r") as handle:
+            for line in handle:
+                line = line.strip()
+                if not line:
+                    continue
+                msg_obj = json.loads(line)
+                ctx_manager.message_handler(msg_obj)
+                count += 1
+        self.logger.info(f"Loaded {count} messages from buffer.")
+        return count
+
+    def _run_server(self):
+        """Run the MCP server (blocking call)."""
+        config = uvicorn.Config(mcp_flowcept.streamable_http_app, host=AGENT_HOST, port=AGENT_PORT, lifespan="on")
+        self._server = uvicorn.Server(config)
+        self._server.run()
+
+    def start(self):
+        """
+        Start the agent server in a background thread.
+
+        Returns
+        -------
+        FlowceptAgent
+            The current instance.
+        """
+        if not MQ_ENABLED:
+            self._load_buffer_once()
+
+        self._server_thread = Thread(target=self._run_server, daemon=False)
+        self._server_thread.start()
+        self.logger.info(f"Flowcept agent server started on {AGENT_HOST}:{AGENT_PORT}")
+        return self
 
-    Thread(target=run).start()
-    sleep(2)
+    def stop(self):
+        """Stop the agent server and wait briefly for shutdown."""
+        if self._server is not None:
+            self._server.should_exit = True
+        if self._server_thread is not None:
+            self._server_thread.join(timeout=5)
+
+    def wait(self):
+        """Block until the server thread exits."""
+        if self._server_thread is not None:
+            self._server_thread.join()
+
+    def query(self, message: str) -> ToolResult:
+        """
+        Send a prompt to the agent's main router tool and return the response.
+        """
+        try:
+            resp = run_tool(tool_name=prompt_handler, kwargs={"message": message})[0]
+        except Exception as e:
+            return ToolResult(code=400, result=f"Error executing tool prompt_handler: {e}", tool_name="prompt_handler")
+
+        try:
+            return ToolResult(**json.loads(resp))
+        except Exception as e:
+            return ToolResult(
+                code=499,
+                result=f"Could not parse tool response as JSON: {resp}",
+                extra=str(e),
+                tool_name="prompt_handler",
+            )
+
+
+def main():
+    """
+    Start the MCP server.
+    """
+    agent = FlowceptAgent().start()
     # Wake up tool call
     print(run_tool(check_liveness, host=AGENT_HOST, port=AGENT_PORT)[0])
+    agent.wait()
 
 
 if __name__ == "__main__":

flowcept/agents/flowcept_ctx_manager.py

@@ -1,6 +1,9 @@
 from flowcept.agents.dynamic_schema_tracker import DynamicSchemaTracker
 from flowcept.agents.tools.in_memory_queries.pandas_agent_utils import load_saved_df
 from flowcept.commons.flowcept_dataclasses.task_object import TaskObject
+from flowcept.commons.flowcept_logger import FlowceptLogger
+from flowcept.commons.vocabulary import Status
+from flowcept.configs import AGENT
 from mcp.server.fastmcp import FastMCP
 
 import json
@@ -12,11 +15,12 @@ import pandas as pd
 
 from flowcept.flowceptor.consumers.agent.base_agent_context_manager import BaseAgentContextManager, BaseAppContext
 
-
-from flowcept.agents import agent_client
 from flowcept.commons.task_data_preprocess import summarize_task
 
 
+AGENT_DEBUG = AGENT.get("debug", False)
+
+
 @dataclass
 class FlowceptAppContext(BaseAppContext):
     """
@@ -39,6 +43,39 @@ class FlowceptAppContext(BaseAppContext):
     tracker_config: Dict | None
     custom_guidance: List[str] | None
 
+    def __init__(self):
+        self.logger = FlowceptLogger()
+        self.reset_context()
+
+    def reset_context(self):
+        """
+        Reset the agent's context to a clean state, initializing a new QA setup.
+        """
+        self.tasks = []
+        self.task_summaries = []
+        self.critical_tasks = []
+        self.df = pd.DataFrame()
+        self.tasks_schema = {}
+        self.value_examples = {}
+        self.custom_guidance = []
+        self.tracker_config = {}
+
+        if AGENT_DEBUG:
+            from flowcept.commons.flowcept_logger import FlowceptLogger
+
+            FlowceptLogger().warning("Running agent in DEBUG mode!")
+            df_path = "/tmp/current_agent_df.csv"
+            if os.path.exists(df_path):
+                self.logger.warning("Going to load df into context")
+                df = load_saved_df(df_path)
+                self.df = df
+            if os.path.exists("/tmp/current_tasks_schema.json"):
+                with open("/tmp/current_tasks_schema.json") as f:
+                    self.tasks_schema = json.load(f)
+            if os.path.exists("/tmp/value_examples.json"):
+                with open("/tmp/value_examples.json") as f:
+                    self.value_examples = json.load(f)
+
 
 class FlowceptAgentContextManager(BaseAgentContextManager):
     """
@@ -61,12 +98,12 @@ class FlowceptAgentContextManager(BaseAgentContextManager):
     """
 
     def __init__(self):
-        self.context: FlowceptAppContext = None
+        self.context = FlowceptAppContext()
         self.tracker_config = dict(max_examples=3, max_str_len=50)
         self.schema_tracker = DynamicSchemaTracker(**self.tracker_config)
         self.msgs_counter = 0
         self.context_chunk_size = 1  # Should be in the settings
-        super().__init__()
+        super().__init__(allow_mq_disabled=True)
 
     def message_handler(self, msg_obj: Dict):
         """
@@ -82,7 +119,6 @@ class FlowceptAgentContextManager(BaseAgentContextManager):
         bool
             True if the message was handled successfully.
         """
-        print("Received:", msg_obj)
         msg_type = msg_obj.get("type", None)
         if msg_type == "task":
             task_msg = TaskObject.from_dict(msg_obj)
@@ -90,8 +126,68 @@ class FlowceptAgentContextManager(BaseAgentContextManager):
                 self.logger.info(f"Going to ignore our own LLM messages: {task_msg}")
                 return True
 
-            self.msgs_counter += 1
             self.logger.debug("Received task msg!")
+            if task_msg.subtype == "call_agent_task":
+                from flowcept.instrumentation.task_capture import FlowceptTask
+
+                if task_msg.activity_id == "reset_user_context":
+                    self.context.reset_context()
+                    self.msgs_counter = 0
+                    if self._mq_dao is None:
+                        self.logger.warning("MQ is disabled; skipping reset_user_context response message.")
+                    else:
+                        FlowceptTask(
+                            agent_id=self.agent_id,
+                            generated={"msg": "Provenance Agent reset context."},
+                            subtype="agent_task",
+                            activity_id="reset_user_context",
+                        ).send()
+                    return True
+                elif task_msg.activity_id == "provenance_query":
+                    self.logger.info("Received a prov query message!")
+                    query_text = task_msg.used.get("query")
+                    from flowcept.agents import ToolResult
+                    from flowcept.agents.tools.general_tools import prompt_handler
+                    from flowcept.agents.agent_client import run_tool
+
+                    resp = run_tool(tool_name=prompt_handler, kwargs={"message": query_text})[0]
+
+                    try:
+                        error = None
+                        status = Status.FINISHED
+                        tool_result = ToolResult(**json.loads(resp))
+                        if tool_result.result_is_str():
+                            generated = {"text": tool_result.result}
+                        else:
+                            generated = tool_result.result
+                    except Exception as e:
+                        status = Status.ERROR
+                        error = f"Could not convert the following into a ToolResult:\n{resp}\nException: {e}"
+                        generated = {"text": str(resp)}
+                    if self._mq_dao is None:
+                        self.logger.warning("MQ is disabled; skipping provenance_query response message.")
+                    else:
+                        FlowceptTask(
+                            agent_id=self.agent_id,
+                            generated=generated,
+                            stderr=error,
+                            status=status,
+                            subtype="agent_task",
+                            activity_id="provenance_query_response",
+                        ).send()
+
+                    return True
+
+            elif (
+                task_msg.subtype == "agent_task"
+                and task_msg.agent_id is not None
+                and task_msg.agent_id == self.agent_id
+            ):
+                self.logger.info(f"Ignoring agent tasks from myself: {task_msg}")
+                return True
+
+            self.msgs_counter += 1
+
             self.context.tasks.append(msg_obj)
 
             task_summary = summarize_task(msg_obj, logger=self.logger)
@@ -110,12 +206,10 @@ class FlowceptAgentContextManager(BaseAgentContextManager):
                         ]
                     )
                 except Exception as e:
-                    self.logger.error(
-                        f"Could not add these tasks to buffer!\n"
-                        f"{
-                            self.context.task_summaries[self.msgs_counter - self.context_chunk_size : self.msgs_counter]
-                        }"
-                    )
+                    task_slice = self.context.task_summaries[
+                        self.msgs_counter - self.context_chunk_size : self.msgs_counter
+                    ]
+                    self.logger.error(f"Could not add these tasks to buffer!\n{task_slice}")
                     self.logger.exception(e)
 
                 # self.monitor_chunk()
@@ -136,46 +230,22 @@ class FlowceptAgentContextManager(BaseAgentContextManager):
         Perform LLM-based analysis on the current chunk of task messages and send the results.
         """
         self.logger.debug(f"Going to begin LLM job! {self.msgs_counter}")
-        result = agent_client.run_tool("analyze_task_chunk")
+        from flowcept.agents.agent_client import run_tool
+
+        result = run_tool("analyze_task_chunk")
         if len(result):
             content = result[0].text
             if content != "Error executing tool":
-                msg = {"type": "flowcept_agent", "info": "monitor", "content": content}
-                self._mq_dao.send_message(msg)
-                self.logger.debug(str(content))
+                if self._mq_dao is None:
+                    self.logger.warning("MQ is disabled; skipping monitor message.")
+                else:
+                    msg = {"type": "flowcept_agent", "info": "monitor", "content": content}
+                    self._mq_dao.send_message(msg)
+                    self.logger.debug(str(content))
             else:
                 self.logger.error(content)
 
-    def reset_context(self):
-        """
-        Reset the agent's context to a clean state, initializing a new QA setup.
-        """
-        self.context = FlowceptAppContext(
-            tasks=[],
-            task_summaries=[],
-            critical_tasks=[],
-            df=pd.DataFrame(),
-            tasks_schema={},
-            value_examples={},
-            custom_guidance=[],
-            tracker_config=self.tracker_config,
-        )
-        DEBUG = True  # TODO debugging!
-        if DEBUG:
-            self.logger.warning("Running agent in DEBUG mode!")
-            df_path = "/tmp/current_agent_df.csv"
-            if os.path.exists(df_path):
-                self.logger.warning("Going to load df into context")
-                df = load_saved_df(df_path)
-                self.context.df = df
-            if os.path.exists("/tmp/current_tasks_schema.json"):
-                with open("/tmp/current_tasks_schema.json") as f:
-                    self.context.tasks_schema = json.load(f)
-            if os.path.exists("/tmp/value_examples.json"):
-                with open("/tmp/value_examples.json") as f:
-                    self.context.value_examples = json.load(f)
-
 
 # Exporting the ctx_manager and the mcp_flowcept
 ctx_manager = FlowceptAgentContextManager()
-mcp_flowcept = FastMCP("FlowceptAgent", require_session=False, lifespan=ctx_manager.lifespan, stateless_http=True)
+mcp_flowcept = FastMCP("FlowceptAgent", lifespan=ctx_manager.lifespan, stateless_http=True)

flowcept/agents/gui/gui_utils.py

@@ -351,10 +351,28 @@ def exec_st_plot_code(code, result_df, st_module):
     >>> code = "st.line_chart(result)"
     >>> exec_st_plot_code(code, df, st)
     """
-    print("Plot code \n", code)
+    # 1) Make a copy of result_df and rename columns with dots
+    plot_df = result_df.copy()
+    col_map = {}
+
+    for col in plot_df.columns:
+        if "." in col:
+            new_col = col.replace(".", "_")
+            col_map[col] = new_col
+            plot_df.rename(columns={col: new_col}, inplace=True)
+
+    # 2) Rewrite the code so column names match the renamed columns
+    sanitized_code = code
+    for old, new in col_map.items():
+        # replace only inside quotes: 'generated.bd_enthalpy' → 'generated_bd_enthalpy'
+        sanitized_code = sanitized_code.replace(f"'{old}'", f"'{new}'")
+        sanitized_code = sanitized_code.replace(f'"{old}"', f'"{new}"')
+
+    print("SANITIZED CODE:\n", sanitized_code)
+    print(f"Renamed DF columms: {plot_df}")
     exec(
-        code,
-        {"result": result_df, "st": st_module, "plt": __import__("matplotlib.pyplot"), "alt": __import__("altair")},
+        sanitized_code,
+        {"result": plot_df, "st": st_module, "plt": __import__("matplotlib.pyplot"), "alt": __import__("altair")},
     )
 
 

flowcept/agents/prompts/general_prompts.py

@@ -28,7 +28,7 @@ ROUTING_PROMPT = (
     # "- in_context_query: if the user asks questions about tasks or data in running workflow (or a workflow that ran recently) or if the user mentions the in-memory 'df' or a dataframe.\n"
     # "- historical_prov_query: if the user wants to query historical provenance data\n"
     "- in_chat_query: if the user appears to be asking about something that has said recently in this chat.\n"
-    "- unknown: if you don't know.\n"
+    "- in_context_query: if you don't know.\n"
     "Respond with only the route label."
     "User message is below:\n "
 )