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

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/config.py

@@ -70,7 +70,7 @@ def set_current_theme_name(theme_name: str | None):
             else:
                 print(f"Warning: Theme 'random' specified, but no themes found in {THEMES_DIR}. Using default: {DEFAULT_THEME_NAME}")
                 # resolved_theme remains DEFAULT_THEME_NAME
-        elif theme_name in [t.value for t in OutputTheme] or theme_name in list_available_themes():
+        elif theme_name in list_available_themes():
             resolved_theme = theme_name
         else:
             print(f"Warning: Invalid theme name provided ('{theme_name}'). Using default: {DEFAULT_THEME_NAME}")

flock/webapp/app/main.py

@@ -149,18 +149,70 @@ app.include_router(registry_viewer.router, prefix="/ui/api/registry", tags=["UI
 
 def generate_theme_css_web(theme_name: str | None) -> str:
     if not THEME_LOADER_AVAILABLE or THEMES_DIR is None: return ""
-    active_theme_name = theme_name or get_current_theme_name() or DEFAULT_THEME_NAME
-    theme_filename = f"{active_theme_name}.toml"
-    theme_path = THEMES_DIR / theme_filename
-    if not theme_path.exists():
-        logger.warning(f"Theme file not found: {theme_path}. Using default: {DEFAULT_THEME_NAME}.toml")
-        theme_path = THEMES_DIR / f"{DEFAULT_THEME_NAME}.toml"
-        active_theme_name = DEFAULT_THEME_NAME
+
+    chosen_theme_name_input = theme_name or get_current_theme_name() or DEFAULT_THEME_NAME
+
+    # Sanitize the input to get only the filename component
+    sanitized_name_part = Path(chosen_theme_name_input).name
+    # Ensure we have a stem
+    theme_stem_candidate = sanitized_name_part
+    if theme_stem_candidate.endswith(".toml"):
+        theme_stem_candidate = theme_stem_candidate[:-5]
+
+    effective_theme_filename = f"{theme_stem_candidate}.toml"
+    _theme_to_load_stem = theme_stem_candidate # This will be the name of the theme we attempt to load
+
+    try:
+        resolved_themes_dir = THEMES_DIR.resolve(strict=True) # Ensure THEMES_DIR itself is valid
+        prospective_theme_path = resolved_themes_dir / effective_theme_filename
+
+        # Resolve the prospective path
+        resolved_theme_path = prospective_theme_path.resolve()
+
+        # Validate:
+        # 1. Path is still within the resolved THEMES_DIR
+        # 2. The final filename component of the resolved path matches the intended filename
+        #    (guards against symlinks or normalization changing the name unexpectedly)
+        # 3. The file exists
+        if (
+            str(resolved_theme_path).startswith(str(resolved_themes_dir)) and
+            resolved_theme_path.name == effective_theme_filename and
+            resolved_theme_path.is_file() # is_file checks existence too
+        ):
+            theme_path = resolved_theme_path
+        else:
+            logger.warning(
+                f"Validation failed or theme '{effective_theme_filename}' not found in '{resolved_themes_dir}'. "
+                f"Attempted path: '{prospective_theme_path}'. Resolved to: '{resolved_theme_path}'. "
+                f"Falling back to default theme: {DEFAULT_THEME_NAME}.toml"
+            )
+            _theme_to_load_stem = DEFAULT_THEME_NAME
+            theme_path = resolved_themes_dir / f"{DEFAULT_THEME_NAME}.toml"
+            if not theme_path.is_file():
+                logger.error(f"Default theme file '{theme_path}' not found. No theme CSS will be generated.")
+                return ""
+    except FileNotFoundError: # THEMES_DIR does not exist
+        logger.error(f"Themes directory '{THEMES_DIR}' not found. Falling back to default theme.")
+        _theme_to_load_stem = DEFAULT_THEME_NAME
+        # Attempt to use a conceptual default path if THEMES_DIR was bogus, though it's unlikely to succeed
+        theme_path = Path(f"{DEFAULT_THEME_NAME}.toml") # This won't be in THEMES_DIR if THEMES_DIR is bad
+        if not theme_path.exists(): # Check existence without assuming a base directory
+             logger.error(f"Default theme file '{DEFAULT_THEME_NAME}.toml' not found at root or THEMES_DIR is inaccessible. No theme CSS.")
+             return ""
+    except Exception as e:
+        logger.error(f"Error during theme path resolution for '{effective_theme_filename}': {e}. Falling back to default.")
+        _theme_to_load_stem = DEFAULT_THEME_NAME
+        theme_path = THEMES_DIR / f"{DEFAULT_THEME_NAME}.toml" if THEMES_DIR else Path(f"{DEFAULT_THEME_NAME}.toml")
         if not theme_path.exists():
-            logger.warning(f"Default theme file not found: {theme_path}. No theme CSS.")
+            logger.error(f"Default theme file '{theme_path}' not found after error. No theme CSS.")
             return ""
-    try: theme_dict = load_theme_from_file(str(theme_path))
-    except Exception as e: logger.error(f"Error loading theme {theme_path}: {e}"); return ""
+
+    try:
+        theme_dict = load_theme_from_file(str(theme_path))
+        logger.debug(f"Successfully loaded theme '{_theme_to_load_stem}' from '{theme_path}'")
+    except Exception as e:
+        logger.error(f"Error loading theme file '{theme_path}' (intended: '{_theme_to_load_stem}.toml'): {e}")
+        return ""
 
     pico_vars = alacritty_to_pico(theme_dict)
     if not pico_vars: return ""
@@ -429,16 +481,57 @@ async def htmx_env_add(request: Request, var_name: str = Form(...), var_value: s
 
 @app.get("/ui/htmx/theme-preview", response_class=HTMLResponse, tags=["UI HTMX Partials"])
 async def htmx_theme_preview(request: Request, theme: str = Query(None)):
-    theme_name = theme or get_current_theme_name() or DEFAULT_THEME_NAME
+    if not THEME_LOADER_AVAILABLE:
+        return HTMLResponse("<p>Theme loading functionality is not available.</p>", status_code=500)
+    if THEMES_DIR is None or not THEMES_DIR.exists():
+        return HTMLResponse("<p>Themes directory is not configured or does not exist.</p>", status_code=500)
+
+    chosen_theme_name_input = theme or get_current_theme_name() or DEFAULT_THEME_NAME
+
+    # Sanitize the input to get only the filename component
+    sanitized_name_part = Path(chosen_theme_name_input).name
+    # Ensure we have a stem
+    theme_stem_from_input = sanitized_name_part
+    if theme_stem_from_input.endswith(".toml"):
+        theme_stem_from_input = theme_stem_from_input[:-5]
+
+    theme_filename_to_load = f"{theme_stem_from_input}.toml"
+    theme_name_for_display = theme_stem_from_input # Use the sanitized stem for display/logging
+
     try:
-        theme_path = THEMES_DIR / f"{theme_name}.toml" if THEMES_DIR else None
-        if not (theme_path and theme_path.exists()): return HTMLResponse("<p>Theme not found.</p>")
+        resolved_themes_dir = THEMES_DIR.resolve(strict=True)
+        theme_path_candidate = resolved_themes_dir / theme_filename_to_load
+        resolved_theme_path = theme_path_candidate.resolve()
+
+        if not str(resolved_theme_path).startswith(str(resolved_themes_dir)) or \
+           resolved_theme_path.name != theme_filename_to_load:
+            logger.warning(f"Invalid theme path access attempt for '{theme_name_for_display}'. "
+                           f"Original input: '{chosen_theme_name_input}', Sanitized filename: '{theme_filename_to_load}', "
+                           f"Attempted path: '{theme_path_candidate}', Resolved to: '{resolved_theme_path}'")
+            return HTMLResponse(f"<p>Invalid theme name or path for '{theme_name_for_display}'.</p>", status_code=400)
+
+        if not resolved_theme_path.is_file():
+            logger.info(f"Theme preview: Theme file '{theme_filename_to_load}' not found at '{resolved_theme_path}'.")
+            return HTMLResponse(f"<p>Theme '{theme_name_for_display}' not found.</p>", status_code=404)
+
+        theme_path = resolved_theme_path
         theme_data = load_theme_from_file(str(theme_path))
-    except Exception as e: return HTMLResponse(f"<p>Error loading theme: {e}</p>")
+        logger.debug(f"Successfully loaded theme '{theme_name_for_display}' for preview from '{theme_path}'")
+
+    except FileNotFoundError: # For THEMES_DIR.resolve(strict=True)
+        logger.error(f"Themes directory '{THEMES_DIR}' not found during preview for '{theme_name_for_display}'.")
+        return HTMLResponse("<p>Themes directory not found.</p>", status_code=500)
+    except Exception as e:
+        logger.error(f"Error loading theme '{theme_name_for_display}' for preview (path: '{theme_path_candidate if 'theme_path_candidate' in locals() else 'unknown'}'): {e}")
+        return HTMLResponse(f"<p>Error loading theme '{theme_name_for_display}': {e}</p>", status_code=500)
+
     css_vars = alacritty_to_pico(theme_data)
-    css_vars_str = ":root {\n" + "\n".join([f"  {k}: {v};" for k, v in css_vars.items()]) + "\n}"
+    if not css_vars:
+        return HTMLResponse(f"<p>Could not convert theme '{theme_name_for_display}' to CSS variables.</p>")
+
+    css_vars_str = ":root {\n" + "\\n".join([f"  {k}: {v};" for k, v in css_vars.items()]) + "\\n}"
     main_colors = [("Background", css_vars.get("--pico-background-color")), ("Text", css_vars.get("--pico-color")), ("Primary", css_vars.get("--pico-primary")), ("Secondary", css_vars.get("--pico-secondary")), ("Muted", css_vars.get("--pico-muted-color"))]
-    return templates.TemplateResponse("partials/_theme_preview.html", {"request": request, "theme_name": theme_name, "css_vars_str": css_vars_str, "main_colors": main_colors})
+    return templates.TemplateResponse("partials/_theme_preview.html", {"request": request, "theme_name": theme_name_for_display, "css_vars_str": css_vars_str, "main_colors": main_colors})
 
 @app.post("/ui/apply-theme", tags=["UI Actions"])
 async def apply_theme(request: Request, theme: str = Form(...)):

flock/workflow/activities.py

@@ -27,6 +27,7 @@ async def run_agent(context: FlockContext) -> dict:
     # Start a top-level span for the entire run_agent activity.
     with tracer.start_as_current_span("run_agent") as span:
         registry = get_registry()
+
         previous_agent_name = ""
         if isinstance(context, dict):
             context = FlockContext.from_dict(context)

{flock_core-0.4.0b46.dist-info → flock_core-0.4.0b48.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flock-core
-Version: 0.4.0b46
+Version: 0.4.0b48
 Summary: Declarative LLM Orchestration at Scale
 Author-email: Andre Ratzenberger <andre.ratzenberger@whiteduck.de>
 License-File: LICENSE
@@ -8,22 +8,20 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.10
-Requires-Dist: azure-search-documents>=11.5.2
 Requires-Dist: chromadb>=0.6.3
 Requires-Dist: cloudpickle>=3.1.1
 Requires-Dist: datasets>=3.2.0
 Requires-Dist: devtools>=0.12.2
-Requires-Dist: dspy==2.6.16
-Requires-Dist: duckduckgo-search>=7.3.2
+Requires-Dist: dspy==2.6.23
 Requires-Dist: fastapi>=0.115.8
 Requires-Dist: httpx>=0.28.1
 Requires-Dist: inspect-ai>=0.3.88
-Requires-Dist: litellm==1.63.7
+Requires-Dist: litellm==1.69.3
 Requires-Dist: loguru>=0.7.3
 Requires-Dist: matplotlib>=3.10.0
 Requires-Dist: msgpack>=1.1.0
-Requires-Dist: nltk>=3.9.1
 Requires-Dist: notion-client>=2.3.0
+Requires-Dist: openai==1.75.0
 Requires-Dist: opentelemetry-api>=1.30.0
 Requires-Dist: opentelemetry-exporter-jaeger-proto-grpc>=1.21.0
 Requires-Dist: opentelemetry-exporter-jaeger>=1.21.0
@@ -50,13 +48,26 @@ Requires-Dist: toml>=0.10.2
 Requires-Dist: tqdm>=4.67.1
 Requires-Dist: uvicorn>=0.34.0
 Requires-Dist: zep-python>=2.0.2
-Provides-Extra: all
-Requires-Dist: docling>=2.18.0; extra == 'all'
-Requires-Dist: markdownify>=0.14.1; extra == 'all'
-Requires-Dist: tavily-python>=0.5.0; extra == 'all'
-Provides-Extra: tools
-Requires-Dist: markdownify>=0.14.1; extra == 'tools'
-Requires-Dist: tavily-python>=0.5.0; extra == 'tools'
+Provides-Extra: all-tools
+Requires-Dist: azure-identity>=1.23.0; extra == 'all-tools'
+Requires-Dist: azure-search-documents>=11.5.2; extra == 'all-tools'
+Requires-Dist: azure-storage-blob>=12.25.1; extra == 'all-tools'
+Requires-Dist: docling>=2.18.0; extra == 'all-tools'
+Requires-Dist: duckduckgo-search>=7.3.2; extra == 'all-tools'
+Requires-Dist: markdownify>=0.14.1; extra == 'all-tools'
+Requires-Dist: nltk>=3.9.1; extra == 'all-tools'
+Requires-Dist: tavily-python>=0.5.0; extra == 'all-tools'
+Provides-Extra: azure-tools
+Requires-Dist: azure-identity>=1.23.0; extra == 'azure-tools'
+Requires-Dist: azure-search-documents>=11.5.2; extra == 'azure-tools'
+Requires-Dist: azure-storage-blob>=12.25.1; extra == 'azure-tools'
+Provides-Extra: basic-tools
+Requires-Dist: docling>=2.18.0; extra == 'basic-tools'
+Requires-Dist: duckduckgo-search>=7.3.2; extra == 'basic-tools'
+Requires-Dist: markdownify>=0.14.1; extra == 'basic-tools'
+Requires-Dist: tavily-python>=0.5.0; extra == 'basic-tools'
+Provides-Extra: llm-tools
+Requires-Dist: nltk>=3.9.1; extra == 'llm-tools'
 Description-Content-Type: text/markdown
 
 <p align="center">