flock-core 0.4.0b46__py3-none-any.whl → 0.4.0b49__py3-none-any.whl

flock/{core/tools/dev_tools/github.py → tools/github_tools.py}

@@ -9,7 +9,7 @@ from flock.core.logging.trace_and_logged import traced_and_logged
 
 
 @traced_and_logged
-def create_user_stories_as_github_issue(title: str, body: str) -> str:
+def github_create_user_stories_as_github_issue(title: str, body: str) -> str:
     github_pat = os.getenv("GITHUB_PAT")
     github_repo = os.getenv("GITHUB_REPO")
 
@@ -31,7 +31,7 @@ def create_user_stories_as_github_issue(title: str, body: str) -> str:
 
 
 @traced_and_logged
-def upload_readme(content: str):
+def github_upload_readme(content: str):
     GITHUB_USERNAME = os.getenv("GITHUB_USERNAME")
     REPO_NAME = os.getenv("GITHUB_REPO")
     GITHUB_TOKEN = os.getenv("GITHUB_PAT")
@@ -82,7 +82,7 @@ def upload_readme(content: str):
 
 
 @traced_and_logged
-def create_files(file_paths) -> str:
+def github_create_files(file_paths) -> str:
     """Create multiple files in a GitHub repository with a predefined content.
 
     This function iterates over a list of file paths (relative to the repository root) and creates

flock/{core/tools → tools}/markdown_tools.py

@@ -5,7 +5,7 @@ from flock.core.logging.trace_and_logged import traced_and_logged
 
 
 @traced_and_logged
-def split_markdown_by_headers(
+def markdown_split_by_headers(
     markdown_text: str, min_header_level: int = 1, max_header_level: int = 2
 ) -> list[dict[str, Any]]:
     if not markdown_text:
@@ -58,7 +58,7 @@ def split_markdown_by_headers(
 
 
 @traced_and_logged
-def extract_code_blocks(
+def markdown_extract_code_blocks(
     markdown_text: str, language: str = None
 ) -> list[dict[str, str]]:
     if not markdown_text:
@@ -92,7 +92,7 @@ def extract_code_blocks(
 
 
 @traced_and_logged
-def extract_links(markdown_text: str) -> list[dict[str, str]]:
+def markdown_extract_links(markdown_text: str) -> list[dict[str, str]]:
     if not markdown_text:
         return []
 
@@ -104,7 +104,7 @@ def extract_links(markdown_text: str) -> list[dict[str, str]]:
 
 
 @traced_and_logged
-def extract_tables(markdown_text: str) -> list[dict[str, Any]]:
+def markdown_extract_tables(markdown_text: str) -> list[dict[str, Any]]:
     if not markdown_text:
         return []
 
@@ -193,3 +193,13 @@ def markdown_to_plain_text(markdown_text: str) -> str:
     text = re.sub(r"\n{3,}", "\n\n", text)
 
     return text.strip()
+
+
+
+@traced_and_logged
+def extract_links_from_markdown(markdown: str, url: str) -> list:
+    # Regular expression to find all markdown links
+    link_pattern = re.compile(r"\[([^\]]+)\]\(([^)]+)\)")
+    links = link_pattern.findall(markdown)
+    return [url + link[1] for link in links]
+

flock/tools/system_tools.py

@@ -0,0 +1,9 @@
+from flock.core.logging.trace_and_logged import traced_and_logged
+
+
+@traced_and_logged
+def get_current_time() -> str:
+    import datetime
+
+    time = datetime.datetime.now().isoformat()
+    return time

flock/{core/tools/llm_tools.py → tools/text_tools.py}

@@ -21,12 +21,12 @@ except LookupError:
 
 
 @traced_and_logged
-def split_by_sentences(text: str) -> list[str]:
+def text_split_by_sentences(text: str) -> list[str]:
     return nltk.sent_tokenize(text)
 
 
 @traced_and_logged
-def split_by_characters(
+def text_split_by_characters(
     text: str, chunk_size: int = 4000, overlap: int = 200
 ) -> list[str]:
     if chunk_size <= 0:
@@ -71,7 +71,7 @@ def split_by_characters(
 
 
 @traced_and_logged
-def split_by_tokens(
+def text_split_by_tokens(
     text: str,
     tokenizer: Callable[[str], list[str]],
     max_tokens: int = 1024,
@@ -90,7 +90,7 @@ def split_by_tokens(
 
 
 @traced_and_logged
-def split_by_separator(text: str, separator: str = "\n\n") -> list[str]:
+def text_split_by_separator(text: str, separator: str = "\n\n") -> list[str]:
     if not text:
         return []
 
@@ -99,7 +99,7 @@ def split_by_separator(text: str, separator: str = "\n\n") -> list[str]:
 
 
 @traced_and_logged
-def recursive_text_splitter(
+def text_recursive_splitter(
     text: str,
     chunk_size: int = 4000,
     separators: list[str] = ["\n\n", "\n", ". ", ", ", " ", ""],
@@ -114,7 +114,7 @@ def recursive_text_splitter(
     if not separators:
         return [
             text[:chunk_size],
-            *recursive_text_splitter(text[chunk_size:], chunk_size, separators),
+            *text_recursive_splitter(text[chunk_size:], chunk_size, separators),
         ]
 
     separator = separators[0]
@@ -122,7 +122,7 @@ def recursive_text_splitter(
 
     if separator == "":
         # If we're at the character level, just split by characters
-        return split_by_characters(text, chunk_size=chunk_size, overlap=0)
+        return text_split_by_characters(text, chunk_size=chunk_size, overlap=0)
 
     splits = text.split(separator)
     separator_len = len(separator) if keep_separator else 0
@@ -147,7 +147,7 @@ def recursive_text_splitter(
                 current_length = 0
 
             # Recursively split this large piece
-            smaller_chunks = recursive_text_splitter(
+            smaller_chunks = text_recursive_splitter(
                 split, chunk_size, new_separators, keep_separator
             )
             result.extend(smaller_chunks)
@@ -169,10 +169,10 @@ def recursive_text_splitter(
 
 
 @traced_and_logged
-def chunk_text_for_embedding(
+def text_chunking_for_embedding(
     text: str, file_name: str, chunk_size: int = 1000, overlap: int = 100
 ) -> list[dict[str, Any]]:
-    chunks = split_by_characters(text, chunk_size=chunk_size, overlap=overlap)
+    chunks = text_split_by_characters(text, chunk_size=chunk_size, overlap=overlap)
 
     # Create metadata for each chunk
     result = []
@@ -190,7 +190,7 @@ def chunk_text_for_embedding(
 
 
 @traced_and_logged
-def split_code_by_functions(code: str) -> list[dict[str, Any]]:
+def text_split_code_by_functions(code: str) -> list[dict[str, Any]]:
     if not code:
         return []
 
@@ -238,7 +238,7 @@ def split_code_by_functions(code: str) -> list[dict[str, Any]]:
 
 
 @traced_and_logged
-def count_tokens(text: str, model: str = "gpt-3.5-turbo") -> int:
+def text_count_tokens(text: str, model: str = "gpt-3.5-turbo") -> int:
     """Count tokens using tiktoken."""
     if not text:
         return 0
@@ -272,11 +272,11 @@ def count_tokens(text: str, model: str = "gpt-3.5-turbo") -> int:
 
     except ImportError:
         # Fallback to character-based estimation if tiktoken is not installed
-        return count_tokens_estimate(text, model)
+        return text_count_tokens_estimate(text, model)
 
 
 @traced_and_logged
-def count_tokens_estimate(text: str, model: str = "gpt-3.5-turbo") -> int:
+def text_count_tokens_estimate(text: str, model: str = "gpt-3.5-turbo") -> int:
     """Estimate token count for different models."""
     if not text:
         return 0
@@ -297,7 +297,7 @@ def count_tokens_estimate(text: str, model: str = "gpt-3.5-turbo") -> int:
 
 
 @traced_and_logged
-def truncate_to_token_limit(
+def text_truncate_to_token_limit(
     text: str, max_tokens: int = 4000, model: str = "gpt-3.5-turbo"
 ) -> str:
     if not text:
@@ -327,7 +327,7 @@ def truncate_to_token_limit(
 
     except ImportError:
         # Fallback to the character-based method if tiktoken is not available
-        estimated_tokens = count_tokens_estimate(text, model)
+        estimated_tokens = text_count_tokens_estimate(text, model)
 
         if estimated_tokens <= max_tokens:
             return text
@@ -353,7 +353,7 @@ def truncate_to_token_limit(
 
 
 @traced_and_logged
-def extract_keywords(text: str, top_n: int = 10) -> list[str]:
+def text_extract_keywords(text: str, top_n: int = 10) -> list[str]:
     if not text:
         return []
 
@@ -489,7 +489,7 @@ def extract_keywords(text: str, top_n: int = 10) -> list[str]:
 
 
 @traced_and_logged
-def clean_text(
+def text_clean_text(
     text: str,
     remove_urls: bool = True,
     remove_html: bool = True,
@@ -518,7 +518,7 @@ def clean_text(
 
 
 @traced_and_logged
-def format_chat_history(
+def text_format_chat_history(
     messages: list[dict[str, str]],
     format_type: str = "text",
     system_prefix: str = "System: ",
@@ -567,7 +567,7 @@ def format_chat_history(
 
 
 @traced_and_logged
-def extract_json_from_text(text: str) -> dict[str, Any] | None:
+def text_extract_json_from_text(text: str) -> dict[str, Any] | None:
     if not text:
         return None
 
@@ -599,7 +599,7 @@ def extract_json_from_text(text: str) -> dict[str, Any] | None:
 
 
 @traced_and_logged
-def calculate_text_hash(text: str, algorithm: str = "sha256") -> str:
+def text_calculate_hash(text: str, algorithm: str = "sha256") -> str:
     if not text:
         return ""
 
@@ -614,7 +614,7 @@ def calculate_text_hash(text: str, algorithm: str = "sha256") -> str:
 
 
 @traced_and_logged
-def format_table_from_dicts(data: list[dict[str, Any]]) -> str:
+def text_format_table_from_dicts(data: list[dict[str, Any]]) -> str:
     if not data:
         return ""
 
@@ -649,7 +649,7 @@ def format_table_from_dicts(data: list[dict[str, Any]]) -> str:
 
 
 @traced_and_logged
-def detect_language(text: str) -> str:
+def text_detect_language(text: str) -> str:
     """Simple language detection"""
     if not text or len(text.strip()) < 10:
         return "unknown"
@@ -734,7 +734,7 @@ def detect_language(text: str) -> str:
 
 
 @traced_and_logged
-def tiktoken_split(
+def text_tiktoken_split(
     text: str,
     model: str = "gpt-3.5-turbo",
     chunk_size: int = 1000,
@@ -783,6 +783,28 @@ def tiktoken_split(
         return chunks
     except ImportError:
         # Fallback to character-based chunking if tiktoken is not available
-        return split_by_characters(
+        return text_split_by_characters(
             text, chunk_size=chunk_size * 4, overlap=overlap * 4
         )
+
+
+@traced_and_logged
+def text_count_words(text: str) -> int:
+    if not text:
+        return 0
+    return len(text.split())
+
+
+@traced_and_logged
+def text_extract_urls(text: str) -> list[str]:
+    if not text:
+        return []
+    # A more robust regex might be needed for complex cases
+    return re.findall(r"http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@.&+]|[!*\(\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+", text)
+
+
+@traced_and_logged
+def text_extract_numbers(text: str) -> list[float]:
+    if not text:
+        return []
+    return [float(num) for num in re.findall(r"[-+]?\d*\.?\d+", text)]

flock/tools/web_tools.py

@@ -0,0 +1,90 @@
+
+import importlib
+import os
+from typing import Literal
+
+from flock.core.logging.trace_and_logged import traced_and_logged
+
+
+@traced_and_logged
+def web_search_tavily(query: str):
+    if importlib.util.find_spec("tavily") is not None:
+        from tavily import TavilyClient
+
+        client = TavilyClient(api_key=os.getenv("TAVILY_API_KEY"))
+        try:
+            response = client.search(query, include_answer=True)  # type: ignore
+            return response
+        except Exception:
+            raise
+    else:
+        raise ImportError(
+            "Optional tool dependencies not installed. Install with 'pip install flock-core[tools]'."
+        )
+
+
+@traced_and_logged
+def web_search_duckduckgo(
+    keywords: str, search_type: Literal["news", "web"] = "web"
+):
+    try:
+        if importlib.util.find_spec("duckduckgo_search") is not None:
+            from duckduckgo_search import DDGS
+
+            if search_type == "news":
+                response = DDGS().news(keywords)
+            else:
+                response = DDGS().text(keywords)
+
+                return response
+        else:
+            raise ImportError(
+                "Optional tool dependencies not installed. Install with 'pip install flock-core[tools]'."
+            )
+    except Exception:
+        raise
+
+
+@traced_and_logged
+def web_search_bing(keywords: str):
+    try:
+        import httpx
+
+        subscription_key = os.environ["BING_SEARCH_V7_SUBSCRIPTION_KEY"]
+        endpoint = "https://api.bing.microsoft.com/v7.0/search"
+
+        # Query term(s) to search for.
+        query = keywords
+
+        # Construct a request
+        mkt = "en-US"
+        params = {"q": query, "mkt": mkt}
+        headers = {"Ocp-Apim-Subscription-Key": subscription_key}
+
+        response = httpx.get(endpoint, headers=headers, params=params)
+        response.raise_for_status()
+        search_results = response.json()
+        return search_results["webPages"]
+    except Exception:
+        raise
+
+@traced_and_logged
+def web_content_as_markdown(url: str) -> str:
+    if (
+        importlib.util.find_spec("httpx") is not None
+        and importlib.util.find_spec("markdownify") is not None
+    ):
+        import httpx
+        from markdownify import markdownify as md
+
+        try:
+            response = httpx.get(url)
+            response.raise_for_status()
+            markdown = md(response.text)
+            return markdown
+        except Exception:
+            raise
+    else:
+        raise ImportError(
+            "Optional tool dependencies not installed. Install with 'pip install flock-core[tools]'."
+        )

flock/{core/tools → tools}/zendesk_tools.py

@@ -12,7 +12,7 @@ HEADERS = {
 }
 
 
-def get_tickets(number_of_tickets: int = 10) -> list[dict]:
+def zendesk_get_tickets(number_of_tickets: int = 10) -> list[dict]:
     """Get all tickets."""
     ZENDESK_SUBDOMAIN = os.getenv("ZENDESK_SUBDOMAIN_TICKET")
     BASE_URL = f"https://{ZENDESK_SUBDOMAIN}.zendesk.com"
@@ -31,7 +31,7 @@ def get_tickets(number_of_tickets: int = 10) -> list[dict]:
     return all_tickets
 
 
-def get_ticket_by_id(ticket_id: str) -> dict:
+def zendesk_get_ticket_by_id(ticket_id: str) -> dict:
     """Get a ticket by ID."""
     ZENDESK_SUBDOMAIN = os.getenv("ZENDESK_SUBDOMAIN_TICKET")
     BASE_URL = f"https://{ZENDESK_SUBDOMAIN}.zendesk.com"
@@ -42,7 +42,7 @@ def get_ticket_by_id(ticket_id: str) -> dict:
         return response.json()["ticket"]
 
 
-def get_comments_by_ticket_id(ticket_id: str) -> list[dict]:
+def zendesk_get_comments_by_ticket_id(ticket_id: str) -> list[dict]:
     """Get all comments for a ticket."""
     ZENDESK_SUBDOMAIN = os.getenv("ZENDESK_SUBDOMAIN_TICKET")
     BASE_URL = f"https://{ZENDESK_SUBDOMAIN}.zendesk.com"
@@ -53,7 +53,7 @@ def get_comments_by_ticket_id(ticket_id: str) -> list[dict]:
         return response.json()["comments"]
 
 
-def get_article_by_id(article_id: str) -> dict:
+def zendesk_get_article_by_id(article_id: str) -> dict:
     """Get an article by ID."""
     ZENDESK_LOCALE = os.getenv("ZENDESK_ARTICLE_LOCALE")
     ZENDESK_SUBDOMAIN = os.getenv("ZENDESK_SUBDOMAIN_ARTICLE")
@@ -67,7 +67,7 @@ def get_article_by_id(article_id: str) -> dict:
         return response.json()["article"]
 
 
-def get_articles() -> list[dict]:
+def zendesk_get_articles() -> list[dict]:
     """Get all articles."""
     ZENDESK_LOCALE = os.getenv("ZENDESK_ARTICLE_LOCALE")
     ZENDESK_SUBDOMAIN = os.getenv("ZENDESK_SUBDOMAIN_ARTICLE")
@@ -79,7 +79,7 @@ def get_articles() -> list[dict]:
         return response.json()["articles"]
 
 
-def search_articles(query: str) -> list[dict]:
+def zendesk_search_articles(query: str) -> list[dict]:
     """Search Zendesk Help Center articles using a query string."""
     ZENDESK_LOCALE = os.getenv("ZENDESK_ARTICLE_LOCALE")  # e.g., "en-us"
     ZENDESK_SUBDOMAIN = os.getenv("ZENDESK_SUBDOMAIN_ARTICLE")

flock/webapp/app/api/execution.py

@@ -1,9 +1,14 @@
 # src/flock/webapp/app/api/execution.py
 import json
 from pathlib import Path
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
-from fastapi import APIRouter, Depends, Request  # Added Depends
+from fastapi import (  # Ensure Form and HTTPException are imported
+    APIRouter,
+    Depends,
+    Form,
+    Request,
+)
 from fastapi.responses import HTMLResponse
 from fastapi.templating import Jinja2Templates
 
@@ -11,6 +16,12 @@ if TYPE_CHECKING:
     from flock.core.flock import Flock
 
 
+from flock.core.flock import (
+    Flock as ConcreteFlock,  # For creating Flock instance
+)
+from flock.core.logging.logging import (
+    get_logger as get_flock_logger,  # For logging within the new endpoint
+)
 from flock.core.util.spliter import parse_schema
 
 # Import the dependency to get the current Flock instance
@@ -97,19 +108,23 @@ async def htmx_run_flock(
     # We retrieve current_flock from app_state inside the service or before calling if needed for validation here
 
     # It's better to get flock from app_state here to validate before calling service
-    current_flock: Flock | None = getattr(request.app.state, 'flock_instance', None)
+    current_flock_from_state: Flock | None = getattr(request.app.state, 'flock_instance', None)
+    logger = get_flock_logger("webapp.execution.regular_run") # Standard logger
 
-    if not current_flock:
+    if not current_flock_from_state:
+        logger.error("HTMX Run (Regular): No Flock loaded in app_state.")
         return HTMLResponse("<p class='error'>No Flock loaded to run.</p>")
 
     form_data = await request.form()
     start_agent_name = form_data.get("start_agent_name")
 
     if not start_agent_name:
+        logger.warning("HTMX Run (Regular): Starting agent not selected.")
         return HTMLResponse("<p class='error'>Starting agent not selected.</p>")
 
-    agent = current_flock.agents.get(start_agent_name)
+    agent = current_flock_from_state.agents.get(start_agent_name)
     if not agent:
+        logger.error(f"HTMX Run (Regular): Agent '{start_agent_name}' not found in Flock '{current_flock_from_state.name}'.")
         return HTMLResponse(
             f"<p class='error'>Agent '{start_agent_name}' not found in the current Flock.</p>"
         )
@@ -119,46 +134,131 @@ async def htmx_run_flock(
         try:
             parsed_spec = parse_schema(agent.input)
             for name, type_str, _ in parsed_spec:
-                form_field_name = f"agent_input_{name}" # Matches the name in _dynamic_input_form_content.html
+                form_field_name = f"agent_input_{name}"
                 raw_value = form_data.get(form_field_name)
-
                 if raw_value is None and "bool" in type_str.lower(): inputs[name] = False; continue
                 if raw_value is None: inputs[name] = None; continue
-
-                if "int" in type_str.lower():
-                    try: inputs[name] = int(raw_value)
-                    except ValueError: return HTMLResponse(f"<p class='error'>Invalid integer for '{name}'.</p>")
-                elif "float" in type_str.lower():
-                    try: inputs[name] = float(raw_value)
-                    except ValueError: return HTMLResponse(f"<p class='error'>Invalid float for '{name}'.</p>")
-                elif "bool" in type_str.lower():
-                    inputs[name] = raw_value.lower() in ["true", "on", "1", "yes"]
-                elif "list" in type_str.lower() or "dict" in type_str.lower():
-                    try: inputs[name] = json.loads(raw_value)
-                    except json.JSONDecodeError: return HTMLResponse(f"<p class='error'>Invalid JSON for '{name}'.</p>")
+                if "int" in type_str.lower(): inputs[name] = int(raw_value)
+                elif "float" in type_str.lower(): inputs[name] = float(raw_value)
+                elif "bool" in type_str.lower(): inputs[name] = raw_value.lower() in ["true", "on", "1", "yes"]
+                elif "list" in type_str.lower() or "dict" in type_str.lower(): inputs[name] = json.loads(raw_value)
                 else: inputs[name] = raw_value
-        except Exception as e:
-            return HTMLResponse(f"<p class='error'>Error processing inputs for {start_agent_name}: {e}</p>")
+        except ValueError as ve:
+            logger.error(f"HTMX Run (Regular): Input parsing error for agent '{start_agent_name}': {ve}", exc_info=True)
+            return HTMLResponse(f"<p class='error'>Invalid input format: {ve!s}</p>")
+        except Exception as e_parse:
+            logger.error(f"HTMX Run (Regular): Error processing inputs for '{start_agent_name}': {e_parse}", exc_info=True)
+            return HTMLResponse(f"<p class='error'>Error processing inputs for {start_agent_name}: {e_parse}</p>")
 
     try:
-        # Pass request.app.state to the service function
+        logger.info(f"HTMX Run (Regular): Executing agent '{start_agent_name}' from Flock '{current_flock_from_state.name}' via service.")
         result_data = await run_current_flock_service(start_agent_name, inputs, request.app.state)
+    except Exception as e_run:
+        logger.error(f"HTMX Run (Regular): Error during service execution for '{start_agent_name}': {e_run}", exc_info=True)
+        return templates.TemplateResponse(
+            "partials/_results_display.html",
+            {"request": request, "result_data": {"error": f"Error during execution: {e_run!s}"}},
+        )
+
+    # Process and serialize result for template
+    try:
+        processed_result = pydantic_to_dict(result_data)
+        try: json.dumps(processed_result)
+        except (TypeError, ValueError) as ser_e:
+            processed_result = f"Error: Result contains non-serializable data: {ser_e!s}\nOriginal result preview: {str(result_data)[:500]}..."
+            logger.warning(f"HTMX Run (Regular): Serialization issue: {processed_result}")
+    except Exception as proc_e:
+        processed_result = f"Error: Failed to process result data: {proc_e!s}"
+        logger.error(f"HTMX Run (Regular): Result processing error: {processed_result}", exc_info=True)
+
+    return templates.TemplateResponse(
+        "partials/_results_display.html",
+        {"request": request, "result_data": processed_result},
+    )
+
+
+# --- NEW ENDPOINT FOR SHARED RUNS ---
+@router.post("/htmx/run-shared", response_class=HTMLResponse)
+async def htmx_run_shared_flock(
+    request: Request,
+    share_id: str = Form(...), # Expect share_id from the form
+    # flock_definition_str: str = Form(...), # No longer needed
+    # start_agent_name from form is still required implicitly via form_data.get()
+    # No DI for current_flock, as we are using the one from app.state via share_id
+):
+    shared_logger = get_flock_logger("webapp.execution.shared_run_stateful")
+    form_data = await request.form()
+    start_agent_name = form_data.get("start_agent_name")
 
+    if not start_agent_name:
+        shared_logger.warning("HTMX Run Shared (Stateful): Starting agent name not provided in form.")
+        return HTMLResponse("<p class='error'>Critical error: Starting agent name missing from shared run form.</p>")
+
+    shared_logger.info(f"HTMX Run Shared (Stateful): Attempting to execute agent '{start_agent_name}' using pre-loaded Flock for share_id '{share_id}'.")
+
+    inputs = {}
+    result_data: Any = None
+    temp_flock: ConcreteFlock | None = None
+
+    try:
+        # Retrieve the pre-loaded Flock instance from app.state
+        shared_flocks_store = getattr(request.app.state, 'shared_flocks', {})
+        temp_flock = shared_flocks_store.get(share_id)
+
+        if not temp_flock:
+            shared_logger.error(f"HTMX Run Shared: Flock instance for share_id '{share_id}' not found in app.state.")
+            return HTMLResponse(f"<p class='error'>Shared session not found or expired. Please try accessing the shared link again.</p>")
+
+        shared_logger.info(f"HTMX Run Shared: Successfully retrieved pre-loaded Flock '{temp_flock.name}' for agent '{start_agent_name}' (share_id: {share_id}).")
+
+        agent = temp_flock.agents.get(start_agent_name)
+        if not agent:
+            shared_logger.error(f"HTMX Run Shared: Agent '{start_agent_name}' not found in shared Flock '{temp_flock.name}'.")
+            return HTMLResponse(f"<p class='error'>Agent '{start_agent_name}' not found in the provided shared Flock definition.</p>")
+
+        # Parse inputs for the agent from the temporary flock
+        if agent.input and isinstance(agent.input, str):
+            parsed_spec = parse_schema(agent.input)
+            for name, type_str, _ in parsed_spec:
+                form_field_name = f"agent_input_{name}" # Name used in shared_run_page.html
+                raw_value = form_data.get(form_field_name)
+
+                # Input type conversion (consistent with the other endpoint)
+                if raw_value is None and "bool" in type_str.lower(): inputs[name] = False; continue
+                if raw_value is None: inputs[name] = None; continue
+                if "int" in type_str.lower(): inputs[name] = int(raw_value)
+                elif "float" in type_str.lower(): inputs[name] = float(raw_value)
+                elif "bool" in type_str.lower(): inputs[name] = raw_value.lower() in ["true", "on", "1", "yes"]
+                elif "list" in type_str.lower() or "dict" in type_str.lower(): inputs[name] = json.loads(raw_value)
+                else: inputs[name] = raw_value
+
+        shared_logger.info(f"HTMX Run Shared: Executing agent '{start_agent_name}' in pre-loaded Flock '{temp_flock.name}'. Inputs: {list(inputs.keys())}")
+        result_data = await temp_flock.run_async(start_agent=start_agent_name, input=inputs, box_result=False)
+        shared_logger.info(f"HTMX Run Shared: Agent '{start_agent_name}' executed. Result keys: {list(result_data.keys()) if isinstance(result_data, dict) else 'N/A'}")
+
+        # Process and serialize result for template (same logic as other endpoint)
         try:
-            result_data = pydantic_to_dict(result_data)
-            try: json.dumps(result_data)
+            processed_result = pydantic_to_dict(result_data)
+            try: json.dumps(processed_result)
             except (TypeError, ValueError) as ser_e:
-                result_data = f"Error: Result contains non-serializable data: {ser_e!s}\nOriginal result: {result_data!s}"
+                processed_result = f"Error: Result contains non-serializable data: {ser_e!s}\nOriginal result preview: {str(result_data)[:500]}..."
+                shared_logger.warning(f"HTMX Run Shared: Serialization issue: {processed_result}")
         except Exception as proc_e:
-            result_data = f"Error: Failed to process result data: {proc_e!s}"
+            processed_result = f"Error: Failed to process result data: {proc_e!s}"
+            shared_logger.error(f"HTMX Run Shared: Result processing error: {processed_result}", exc_info=True)
 
         return templates.TemplateResponse(
             "partials/_results_display.html",
-            {"request": request, "result_data": result_data},
+            {"request": request, "result_data": processed_result},
         )
-    except Exception as e:
-        error_message = f"Error during execution: {e!s}"
+
+    except ValueError as ve: # Catch specific input parsing errors
+        shared_logger.error(f"HTMX Run Shared: Input parsing error for agent '{start_agent_name}': {ve}", exc_info=True)
+        return HTMLResponse(f"<p class='error'>Invalid input format: {ve!s}</p>")
+    except Exception as e_general:
+        error_message = f"An unexpected error occurred during shared execution: {e_general!s}"
+        shared_logger.error(f"HTMX Run Shared: General error for agent '{start_agent_name}': {e_general}", exc_info=True)
         return templates.TemplateResponse(
             "partials/_results_display.html",
-            {"request": request, "result_data": error_message}, # Display error in the same partial
+            {"request": request, "result_data": {"error": error_message } },
         )