symbolicai 1.4.0__py3-none-any.whl → 1.5.0__py3-none-any.whl

symai/__init__.py

@@ -33,7 +33,7 @@ os.environ["TOKENIZERS_PARALLELISM"] = "false"
 # Create singleton instance
 config_manager = settings.SymAIConfig()
 
-SYMAI_VERSION = "1.4.0"
+SYMAI_VERSION = "1.5.0"
 __version__ = SYMAI_VERSION
 __root_dir__ = config_manager.config_dir
 

symai/backend/engines/scrape/engine_requests.py

@@ -9,6 +9,7 @@ service disruption.
 
 import io
 import logging
+import random
 import re
 from typing import Any, ClassVar
 from urllib.parse import parse_qsl, urlencode, urljoin, urlparse, urlunparse
@@ -17,7 +18,9 @@ import requests
 import trafilatura
 from bs4 import BeautifulSoup
 from pdfminer.high_level import extract_text
+from requests.adapters import HTTPAdapter
 from requests.structures import CaseInsensitiveDict
+from urllib3.util.retry import Retry
 
 from ....symbol import Result
 from ....utils import UserMessage
@@ -80,24 +83,49 @@ class RequestsEngine(Engine):
         "none": "None",
     }
 
-    def __init__(self, timeout=15, verify_ssl=True, user_agent=None):
+    USER_AGENT_POOL: ClassVar[list[str]] = [
+        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+        "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:121.0) Gecko/20100101 Firefox/121.0",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:121.0) Gecko/20100101 Firefox/121.0",
+        "Mozilla/5.0 (X11; Linux x86_64; rv:121.0) Gecko/20100101 Firefox/121.0",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.2 Safari/605.1.15",
+        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36 Edg/120.0.0.0",
+    ]
+
+    def __init__(self, timeout=15, verify_ssl=True, user_agent=None, retries=3, backoff_factor=0.5, retry_status_codes=(500, 502, 503, 504)):
         """
         Args:
             timeout: Seconds to wait for network operations before aborting.
             verify_ssl: Toggle for TLS certificate verification.
-            user_agent: Optional override for the default desktop Chrome UA.
+            user_agent: Optional override for user agent rotation.
+            retries: Number of retries for failed requests (default: 3).
+            backoff_factor: Multiplier for exponential backoff (default: 0.5).
+            retry_status_codes: HTTP status codes to retry on (default: 500, 502, 503, 504).
         """
         super().__init__()
         self.timeout = timeout
         self.verify_ssl = verify_ssl
         self.name = self.__class__.__name__
-
-        headers = dict(self.DEFAULT_HEADERS)
-        if user_agent:
-            headers["User-Agent"] = user_agent
+        self._user_agent_override = user_agent
 
         self.session = requests.Session()
-        self.session.headers.update(headers)
+        self.session.headers.update({k: v for k, v in self.DEFAULT_HEADERS.items() if k != "User-Agent"})
+
+        retry_strategy = Retry(
+            total=retries,
+            backoff_factor=backoff_factor,
+            status_forcelist=retry_status_codes,
+            allowed_methods=["GET", "HEAD"],
+        )
+        adapter = HTTPAdapter(max_retries=retry_strategy)
+        self.session.mount("http://", adapter)
+        self.session.mount("https://", adapter)
+
+    def _get_user_agent(self) -> str:
+        """Return user agent: override if set, otherwise random from pool."""
+        return self._user_agent_override or random.choice(self.USER_AGENT_POOL)
 
     def _maybe_set_bypass_cookies(self, url: str):
         netloc = urlparse(url).hostname
@@ -232,7 +260,7 @@ class RequestsEngine(Engine):
         # Avoid loops
         if target == resp.url:
             return resp
-        return self.session.get(target, timeout=timeout, allow_redirects=True)
+        return self.session.get(target, timeout=timeout, allow_redirects=True, headers={"User-Agent": self._get_user_agent()})
 
     def _fetch_with_playwright(
         self,
@@ -259,7 +287,7 @@ class RequestsEngine(Engine):
 
         timeout_seconds = timeout if timeout is not None else self.timeout
         timeout_ms = max(int(timeout_seconds * 1000), 0)
-        user_agent = self.session.headers.get("User-Agent")
+        user_agent = self._get_user_agent()
 
         parsed = urlparse(url)
         hostname = parsed.hostname or ""
@@ -348,7 +376,8 @@ class RequestsEngine(Engine):
             )
         else:
             resp = self.session.get(
-                clean_url, timeout=self.timeout, allow_redirects=True, verify=self.verify_ssl
+                clean_url, timeout=self.timeout, allow_redirects=True, verify=self.verify_ssl,
+                headers={"User-Agent": self._get_user_agent()}
             )
         resp.raise_for_status()
 

symai/backend/engines/search/__init__.py

@@ -0,0 +1,13 @@
+from .engine_firecrawl import FirecrawlEngine
+from .engine_parallel import ParallelEngine
+
+SEARCH_ENGINE_MAPPING = {
+    "firecrawl": FirecrawlEngine,
+    "parallel": ParallelEngine,
+}
+
+__all__ = [
+    "SEARCH_ENGINE_MAPPING",
+    "FirecrawlEngine",
+    "ParallelEngine",
+]

symai/backend/engines/search/engine_firecrawl.py

@@ -0,0 +1,333 @@
+import json
+import logging
+from copy import deepcopy
+from dataclasses import dataclass
+from typing import Any
+from urllib.parse import parse_qsl, urlencode, urlsplit, urlunsplit
+
+from firecrawl import Firecrawl
+from firecrawl.v2.types import ScrapeOptions
+
+from ....symbol import Result
+from ....utils import UserMessage
+from ...base import Engine
+from ...settings import SYMAI_CONFIG
+
+logging.getLogger("requests").setLevel(logging.ERROR)
+logging.getLogger("urllib3").setLevel(logging.ERROR)
+logging.getLogger("httpx").setLevel(logging.ERROR)
+
+TRACKING_KEYS = {
+    "utm_source",
+    "utm_medium",
+    "utm_campaign",
+    "utm_term",
+    "utm_content",
+}
+
+
+@dataclass
+class Citation:
+    id: int
+    title: str
+    url: str
+    start: int
+    end: int
+
+    def __hash__(self):
+        return hash((self.url,))
+
+
+class FirecrawlSearchResult(Result):
+    def __init__(
+        self, value: dict[str, Any] | Any, max_chars_per_result: int | None = None, **kwargs
+    ) -> None:
+        raw_dict = value.model_dump() if hasattr(value, "model_dump") else value
+        super().__init__(raw_dict, **kwargs)
+        self._citations: list[Citation] = []
+        self._max_chars_per_result = max_chars_per_result
+        try:
+            text, citations = self._build_text_and_citations(raw_dict)
+            self._value = text
+            self._citations = citations
+        except Exception as e:
+            self._value = None
+            UserMessage(f"Failed to parse Firecrawl search response: {e}", raise_with=ValueError)
+
+    def _build_text_and_citations(self, data: dict[str, Any]) -> tuple[str, list[Citation]]:
+        results = []
+        for source in ["web", "news", "images"]:
+            source_data = data.get(source) or []
+            results.extend(source_data)
+
+        if not results:
+            return "", []
+
+        parts = []
+        citations = []
+        cursor = 0
+
+        for idx, item in enumerate(results, 1):
+            # Handle both SearchResultWeb (url/title at top level) and Document (url/title in metadata)
+            metadata = item.get("metadata") or {}
+            url = item.get("url") or metadata.get("url") or metadata.get("source_url") or ""
+            title = item.get("title") or metadata.get("title") or ""
+
+            if not url:
+                continue
+
+            # Check if this is a scraped result (has markdown content)
+            markdown = item.get("markdown", "")
+            if markdown:
+                content = markdown
+                if self._max_chars_per_result and len(content) > self._max_chars_per_result:
+                    content = content[: self._max_chars_per_result] + "..."
+                result_text = f"{title}\n{url}\n{content}"
+            else:
+                description = (
+                    item.get("description")
+                    or item.get("snippet")
+                    or metadata.get("description")
+                    or ""
+                )
+                result_text = f"{title}\n{url}"
+                if description:
+                    if self._max_chars_per_result and len(description) > self._max_chars_per_result:
+                        description = description[: self._max_chars_per_result] + "..."
+                    result_text += f"\n{description}"
+
+            if parts:
+                parts.append("\n\n")
+                cursor += 2
+
+            parts.append(result_text)
+            cursor += len(result_text)
+
+            marker = f"[{idx}]"
+            start = cursor
+            parts.append(marker)
+            cursor += len(marker)
+
+            citations.append(Citation(id=idx, title=title, url=url, start=start, end=cursor))
+
+        text = "".join(parts)
+        return text, citations
+
+    def __str__(self) -> str:
+        if isinstance(self._value, str) and self._value:
+            return self._value
+        try:
+            return json.dumps(self.raw, indent=2)
+        except TypeError:
+            return str(self.raw)
+
+    def _repr_html_(self) -> str:
+        if isinstance(self._value, str) and self._value:
+            return f"<pre>{self._value}</pre>"
+        try:
+            return f"<pre>{json.dumps(self.raw, indent=2)}</pre>"
+        except Exception:
+            return f"<pre>{self.raw!s}</pre>"
+
+    def get_citations(self) -> list[Citation]:
+        return self._citations
+
+
+class FirecrawlExtractResult(Result):
+    """Result wrapper for Firecrawl scrape API responses."""
+
+    def __init__(self, value: Any, **kwargs) -> None:
+        raw_dict = value.model_dump() if hasattr(value, "model_dump") else value
+        super().__init__(raw_dict, **kwargs)
+        try:
+            self._value = self._extract_content(raw_dict)
+        except Exception as e:
+            self._value = None
+            UserMessage(f"Failed to parse Firecrawl scrape response: {e}", raise_with=ValueError)
+
+    def _extract_content(self, data: dict[str, Any]) -> str:
+        content = data.get("markdown") or data.get("html") or data.get("raw_html")
+        if content:
+            return str(content)
+        json_data = data.get("json")
+        if json_data:
+            return json.dumps(json_data, indent=2)
+        return ""
+
+    def __str__(self) -> str:
+        try:
+            return str(self._value or "")
+        except Exception:
+            return ""
+
+    def _repr_html_(self) -> str:
+        try:
+            return f"<pre>{self._value or ''}</pre>"
+        except Exception:
+            return "<pre></pre>"
+
+
+class FirecrawlEngine(Engine):
+    def __init__(self, api_key: str | None = None):
+        super().__init__()
+        self.config = deepcopy(SYMAI_CONFIG)
+        self.api_key = api_key or self.config.get("SEARCH_ENGINE_API_KEY")
+        self.model = self.config.get("SEARCH_ENGINE_MODEL")
+        self.name = self.__class__.__name__
+
+        if not self.api_key:
+            UserMessage(
+                "Firecrawl API key not found. Set SEARCH_ENGINE_API_KEY in config or environment.",
+                raise_with=ValueError,
+            )
+
+        try:
+            self.client = Firecrawl(api_key=self.api_key)
+        except Exception as e:
+            UserMessage(f"Failed to initialize Firecrawl client: {e}", raise_with=ValueError)
+
+    def id(self) -> str:
+        if (
+            self.config.get("SEARCH_ENGINE_API_KEY")
+            and str(self.config.get("SEARCH_ENGINE_MODEL", "")).lower() == "firecrawl"
+        ):
+            return "search"
+        return super().id()
+
+    def command(self, *args, **kwargs):
+        super().command(*args, **kwargs)
+        if "SEARCH_ENGINE_API_KEY" in kwargs:
+            self.api_key = kwargs["SEARCH_ENGINE_API_KEY"]
+        if "SEARCH_ENGINE_MODEL" in kwargs:
+            self.model = kwargs["SEARCH_ENGINE_MODEL"]
+
+    def _normalize_url(self, url: str) -> str:
+        parts = urlsplit(url)
+        filtered_query = [
+            (k, v)
+            for k, v in parse_qsl(parts.query, keep_blank_values=True)
+            if k not in TRACKING_KEYS and not k.lower().startswith("utm_")
+        ]
+        query = urlencode(filtered_query, doseq=True)
+        return urlunsplit((parts.scheme, parts.netloc, parts.path, query, parts.fragment))
+
+    def _search(self, query: str, kwargs: dict[str, Any]):
+        if not query:
+            UserMessage(
+                "FirecrawlEngine._search requires a non-empty query.", raise_with=ValueError
+            )
+
+        max_chars_per_result = kwargs.get("max_chars_per_result")
+
+        # Build search kwargs
+        search_kwargs = {}
+        if "limit" in kwargs:
+            search_kwargs["limit"] = kwargs["limit"]
+        if "location" in kwargs:
+            search_kwargs["location"] = kwargs["location"]
+        if "tbs" in kwargs:
+            search_kwargs["tbs"] = kwargs["tbs"]
+        if "sources" in kwargs:
+            search_kwargs["sources"] = kwargs["sources"]
+        if "categories" in kwargs:
+            search_kwargs["categories"] = kwargs["categories"]
+        if "timeout" in kwargs:
+            search_kwargs["timeout"] = kwargs["timeout"]
+
+        # Build scrape options for search results content
+        scrape_opts = {}
+        if "formats" in kwargs:
+            scrape_opts["formats"] = kwargs["formats"]
+        if "proxy" in kwargs:
+            scrape_opts["proxy"] = kwargs["proxy"]
+        if "only_main_content" in kwargs:
+            scrape_opts["only_main_content"] = kwargs["only_main_content"]
+        if "scrape_location" in kwargs:
+            scrape_opts["location"] = kwargs["scrape_location"]
+        if "include_tags" in kwargs:
+            scrape_opts["include_tags"] = kwargs["include_tags"]
+        if "exclude_tags" in kwargs:
+            scrape_opts["exclude_tags"] = kwargs["exclude_tags"]
+
+        if scrape_opts:
+            search_kwargs["scrape_options"] = ScrapeOptions(**scrape_opts)
+
+        try:
+            result = self.client.search(query, **search_kwargs)
+        except Exception as e:
+            UserMessage(f"Failed to call Firecrawl Search API: {e}", raise_with=ValueError)
+
+        raw = result.model_dump() if hasattr(result, "model_dump") else result
+        return [FirecrawlSearchResult(result, max_chars_per_result=max_chars_per_result)], {
+            "raw_output": raw
+        }
+
+    def _extract(self, url: str, kwargs: dict[str, Any]):
+        normalized_url = self._normalize_url(url)
+
+        # Build scrape kwargs
+        scrape_kwargs = {"formats": kwargs.get("formats", ["markdown"])}
+        if "only_main_content" in kwargs:
+            scrape_kwargs["only_main_content"] = kwargs["only_main_content"]
+        if "timeout" in kwargs:
+            scrape_kwargs["timeout"] = kwargs["timeout"]
+        if "proxy" in kwargs:
+            scrape_kwargs["proxy"] = kwargs["proxy"]
+        if "location" in kwargs:
+            scrape_kwargs["location"] = kwargs["location"]
+        if "max_age" in kwargs:
+            scrape_kwargs["max_age"] = kwargs["max_age"]
+        if "store_in_cache" in kwargs:
+            scrape_kwargs["store_in_cache"] = kwargs["store_in_cache"]
+        if "actions" in kwargs:
+            scrape_kwargs["actions"] = kwargs["actions"]
+        if "headers" in kwargs:
+            scrape_kwargs["headers"] = kwargs["headers"]
+        if "include_tags" in kwargs:
+            scrape_kwargs["include_tags"] = kwargs["include_tags"]
+        if "exclude_tags" in kwargs:
+            scrape_kwargs["exclude_tags"] = kwargs["exclude_tags"]
+        if "wait_for" in kwargs:
+            scrape_kwargs["wait_for"] = kwargs["wait_for"]
+        if "mobile" in kwargs:
+            scrape_kwargs["mobile"] = kwargs["mobile"]
+
+        try:
+            result = self.client.scrape(normalized_url, **scrape_kwargs)
+        except Exception as e:
+            UserMessage(f"Failed to call Firecrawl Scrape API: {e}", raise_with=ValueError)
+
+        raw = result.model_dump() if hasattr(result, "model_dump") else result
+        return [FirecrawlExtractResult(result)], {"raw_output": raw, "final_url": normalized_url}
+
+    def forward(self, argument):
+        kwargs = argument.kwargs
+        url = argument.prop.url or kwargs.get("url")
+        if url:
+            return self._extract(str(url), kwargs)
+
+        raw_query = argument.prop.prepared_input
+        if raw_query is None:
+            raw_query = argument.prop.query
+
+        query = str(raw_query or "").strip() if raw_query else ""
+        if not query:
+            UserMessage(
+                "FirecrawlEngine.forward requires at least one non-empty query or url.",
+                raise_with=ValueError,
+            )
+
+        return self._search(query, kwargs)
+
+    def prepare(self, argument):
+        url = argument.kwargs.get("url") or argument.prop.url
+        if url:
+            argument.prop.prepared_input = str(url)
+            return
+
+        query = argument.prop.query
+        if isinstance(query, list):
+            argument.prop.prepared_input = " ".join(str(q) for q in query if q)
+            return
+
+        argument.prop.prepared_input = str(query or "").strip()

symai/backend/engines/search/engine_parallel.py

@@ -66,7 +66,7 @@ class Citation:
         return hash((self.url,))
 
 
-class SearchResult(Result):
+class ParallelSearchResult(Result):
     def __init__(self, value: dict[str, Any] | Any, **kwargs) -> None:
         super().__init__(value, **kwargs)
         if isinstance(value, dict) and value.get("error"):
@@ -286,7 +286,7 @@ class SearchResult(Result):
         return self._citations
 
 
-class ExtractResult(Result):
+class ParallelExtractResult(Result):
     """Result wrapper for Parallel Extract API responses."""
 
     def __init__(self, value: dict[str, Any] | Any, **kwargs) -> None:
@@ -485,7 +485,7 @@ class ParallelEngine(Engine):
             )
         except Exception as e:
             UserMessage(f"Failed to call Parallel Search API: {e}", raise_with=ValueError)
-        return [SearchResult(result)], {"raw_output": result}
+        return [ParallelSearchResult(result)], {"raw_output": result}
 
     def _task(self, queries: list[str], kwargs: dict[str, Any]):
         processor_name = self._coerce_processor(kwargs.get("processor"))
@@ -521,7 +521,7 @@ class ParallelEngine(Engine):
         result = self._fetch_task_result(run.run_id, timeout=timeout, api_timeout=api_timeout)
 
         payload = self._task_result_to_search_payload(result)
-        return [SearchResult(payload)], {
+        return [ParallelSearchResult(payload)], {
             "raw_output": result,
             "task_output": payload.get("task_output"),
             "task_output_type": payload.get("task_output_type"),
@@ -699,7 +699,7 @@ class ParallelEngine(Engine):
             )
         except Exception as e:
             UserMessage(f"Failed to call Parallel Extract API: {e}", raise_with=ValueError)
-        return [ExtractResult(result)], {"raw_output": result, "final_url": url}
+        return [ParallelExtractResult(result)], {"raw_output": result, "final_url": url}
 
     def forward(self, argument):
         kwargs = argument.kwargs

symai/components.py

@@ -1508,12 +1508,18 @@ class DynamicEngine(Expression):
         """Create an engine instance based on the model name."""
         # Deferred to avoid components <-> neurosymbolic engine circular imports.
         from .backend.engines.neurosymbolic import ENGINE_MAPPING  # noqa
-        from .backend.engines.neurosymbolic.engine_cerebras import CerebrasEngine  # noqa
+        from .backend.engines.search import SEARCH_ENGINE_MAPPING  # noqa
 
         try:
+            # Check neurosymbolic engines first
             engine_class = ENGINE_MAPPING.get(self.model)
-            if engine_class is None and self.model.startswith("cerebras:"):
-                engine_class = CerebrasEngine
+
+            # Check search engines
+            if engine_class is None:
+                engine_class = SEARCH_ENGINE_MAPPING.get(self.model)
+                if engine_class is not None:
+                    return engine_class(api_key=self.api_key)
+
             if engine_class is None:
                 UserMessage(f"Unsupported model '{self.model}'", raise_with=ValueError)
             return engine_class(api_key=self.api_key, model=self.model)

symai/extended/interfaces/firecrawl.py

@@ -0,0 +1,30 @@
+from ... import core
+from ...backend.engines.search.engine_firecrawl import FirecrawlExtractResult, FirecrawlSearchResult
+from ...symbol import Expression, Symbol
+
+
+class firecrawl(Expression):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.name = self.__class__.__name__
+
+    def search(self, query: Symbol, **kwargs) -> FirecrawlSearchResult:
+        query = self._to_symbol(query)
+
+        @core.search(query=query.value, **kwargs)
+        def _func(_) -> FirecrawlSearchResult:
+            pass
+
+        return _func(self)
+
+    def scrape(self, url: str, **kwargs) -> FirecrawlExtractResult:
+        symbol = self._to_symbol(url)
+        options = dict(kwargs)
+        options.pop("query", None)
+        options["url"] = symbol.value
+
+        @core.search(query="", **options)
+        def _func(_, *_args, **_inner_kwargs) -> FirecrawlExtractResult:
+            return None
+
+        return _func(self)

symai/extended/interfaces/parallel.py

@@ -1,5 +1,5 @@
 from ... import core
-from ...backend.engines.search.engine_parallel import ExtractResult, SearchResult
+from ...backend.engines.search.engine_parallel import ParallelExtractResult, ParallelSearchResult
 from ...symbol import Expression, Symbol
 
 
@@ -8,23 +8,23 @@ class parallel(Expression):
         super().__init__(*args, **kwargs)
         self.name = self.__class__.__name__
 
-    def search(self, query: Symbol, **kwargs) -> SearchResult:
+    def search(self, query: Symbol, **kwargs) -> ParallelSearchResult:
         query = self._to_symbol(query)
 
         @core.search(query=query.value, **kwargs)
-        def _func(_) -> SearchResult:
+        def _func(_) -> ParallelSearchResult:
             pass
 
         return _func(self)
 
-    def scrape(self, url: str, **kwargs) -> ExtractResult:
+    def scrape(self, url: str, **kwargs) -> ParallelExtractResult:
         symbol = self._to_symbol(url)
         options = dict(kwargs)
         options.pop("query", None)
         options["url"] = symbol.value
 
         @core.search(query="", **options)
-        def _func(_, *_args, **_inner_kwargs) -> ExtractResult:
+        def _func(_, *_args, **_inner_kwargs) -> ParallelExtractResult:
             return None
 
         return _func(self)

symai/functional.py

@@ -498,10 +498,9 @@ class EngineRepository:
     def get(engine_name: str, *_args, **_kwargs):
         self = EngineRepository()
         # First check if we're in the context manager that dynamically changes models
-        if engine_name == "neurosymbolic":
-            engine = self.get_dynamic_engine_instance()
-            if engine is not None:
-                return engine
+        dynamic_engine = self.get_dynamic_engine_instance()
+        if dynamic_engine is not None and engine_name in ("neurosymbolic", "search"):
+            return dynamic_engine
 
         # Otherwise, fallback to normal lookup:
         if engine_name not in self._engines:

{symbolicai-1.4.0.dist-info → symbolicai-1.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: symbolicai
-Version: 1.4.0
+Version: 1.5.0
 Summary: A Neurosymbolic Perspective on Large Language Models
 Author-email: Marius-Constantin Dinu <marius@extensity.ai>, Leoveanu-Condrei Claudiu <leo@extensity.ai>
 License: BSD 3-Clause License
@@ -113,6 +113,7 @@ Requires-Dist: openai-whisper>=20240930; extra == "whisper"
 Requires-Dist: numba>=0.62.1; extra == "whisper"
 Requires-Dist: llvmlite>=0.45.1; extra == "whisper"
 Provides-Extra: search
+Requires-Dist: firecrawl-py>=4.12.0; extra == "search"
 Requires-Dist: parallel-web>=0.3.3; extra == "search"
 Provides-Extra: serpapi
 Requires-Dist: google_search_results>=2.4.2; extra == "serpapi"

{symbolicai-1.4.0.dist-info → symbolicai-1.5.0.dist-info}/RECORD

@@ -1,13 +1,13 @@
 symai/TERMS_OF_SERVICE.md,sha256=HN42UXVI_wAVDHjMShzy_k7xAsbjXaATNeMKcIte_eg,91409
-symai/__init__.py,sha256=s7UwW7LIsUjcCHapKxUsO0MhWH-98vO3gPUhsNxOZW8,18530
+symai/__init__.py,sha256=qlqkm2OjRqXtKhIBltfB9zx0kBf4V4ygckH1RHVPAVE,18530
 symai/chat.py,sha256=DCEbmZ96wv-eitAVt6-oF6PT3JM3cT59Iy3r2Hucd_M,14100
-symai/components.py,sha256=s10kLvwAOjSBQQohoHGtAIKs0UHHCd_HhiRvMbNtIH0,64685
+symai/components.py,sha256=XL1whwdZd6HCl0viUuXca_7d8no_xxfTGZsqE1hhwqI,64845
 symai/constraints.py,sha256=ljjB9p0qK4DrDl_u5G_Y-Y6WAH5ZHANIqLLxRtwcORs,1980
 symai/context.py,sha256=4M69MJOeWSdPTr2Y9teoNTs-nEvpzcAcr7900UgORXA,189
 symai/core.py,sha256=gI9qvTT0Skq2D0izdhAoN3RdwBtWei59KO52mKN1Sos,70420
 symai/core_ext.py,sha256=lS_BZNeUGmNhhXR-F3dFLF26_nZHq3NVaAwa4vAbkTQ,8937
 symai/exceptions.py,sha256=BxpxI8q3-7Uh_Kg9Xi2PhF6RR6CofxV1h8R07j4v47U,165
-symai/functional.py,sha256=C0UrpN0vJTTwS-yqLg91InjHWaQCHo6XPtxiN6wQb7c,21441
+symai/functional.py,sha256=GqBs5FZPVZ3iVJ-MlO0Zvkf7cNSDgVhkt3tsL82kFrM,21457
 symai/imports.py,sha256=P5WsamkfKxsK3fs8vlrFpC6CIv5WVpMIMNue9DKJGnE,16126
 symai/interfaces.py,sha256=Z8CDdarnOVa67GCLljKjxQojDH9MhhPKBQFb0pi2WfY,3458
 symai/memory.py,sha256=Cd60UyeJk7SHNBWEYOLrmUXQy54GzQsu3Mjh0lfNQOY,3716
@@ -59,9 +59,11 @@ symai/backend/engines/neurosymbolic/engine_openai_gptX_reasoning.py,sha256=yWiCT
 symai/backend/engines/neurosymbolic/engine_openai_responses.py,sha256=J3P7WcQhxWSPK99uZuLClpIDlLRqLJFWYwDJHrBKox4,17830
 symai/backend/engines/ocr/engine_apilayer.py,sha256=UpC3oHBdSM6wlPVqxwMkemBd-Y0ReVwc270O_EVbRD0,2267
 symai/backend/engines/output/engine_stdout.py,sha256=BWNXACl5U-WYIJnT1pZNwZsTRMzP1XzA0A7o693mmyQ,899
-symai/backend/engines/scrape/engine_requests.py,sha256=yyVFT9JrZ4S6v5U_cykef-tn5iWGl1MAdpqnDaQ70TA,13821
+symai/backend/engines/scrape/engine_requests.py,sha256=uXQ8PGeRN2OyM0_ioEI61rkv5PqSBE0wayAJNS7s8ZA,15819
+symai/backend/engines/search/__init__.py,sha256=iW6kEBOZ-gUiPYfcIWupNgewiqLrFOBGJ643kqwQFoM,274
+symai/backend/engines/search/engine_firecrawl.py,sha256=M_nxXBtvudNqRR4gTC5dXoJzf_9ofrMScYXzaGVTmaM,11990
 symai/backend/engines/search/engine_openai.py,sha256=hAEu3vPZzLTvgmNc4BSZDTcNb4ek4xYeOf8xgti2zRs,14248
-symai/backend/engines/search/engine_parallel.py,sha256=vhRavd_LStk6grV1aDZiHWfW9v1uDnCLX0BT8smiV84,27008
+symai/backend/engines/search/engine_parallel.py,sha256=voMmeJZ5bf1x3pt7uxMJu84z6VLLG0-ZfgFUWvhM-vI,27048
 symai/backend/engines/search/engine_perplexity.py,sha256=rXnZjMCSiIRuJcNSchE58-f9zWJmYpkKMHONF_XwGnk,4100
 symai/backend/engines/search/engine_serpapi.py,sha256=ZJJBnEDoLjkpxWt_o4vFZanwqojH8ZFBWmWNnEaIbww,3618
 symai/backend/engines/speech_to_text/engine_local_whisper.py,sha256=EOUh2GCeEhZ2Av72i_AZ4NSj9e46Pl7Ft6sIErFy6FI,8387
@@ -106,6 +108,7 @@ symai/extended/interfaces/clip.py,sha256=l6vjEq3cF-wDX9cRPulyiKpDFQB8QI2609GcGtv
 symai/extended/interfaces/console.py,sha256=qeAnG80f95ArADjfpk57AaDA1cHUQSkaUrau2zGNSKs,637
 symai/extended/interfaces/dall_e.py,sha256=SSF1K17SzA-lpdHVtsfHbwRCP6XJxWqsNdXoWwcBYjw,551
 symai/extended/interfaces/file.py,sha256=1_BXHKsHm78MmBeRolA_fFWFTLuA6on7Le-ZF4S_1ds,457
+symai/extended/interfaces/firecrawl.py,sha256=hGA5WxiW6EN5LNsfBSlsYzASgvz9e515TWrHGHcE21s,955
 symai/extended/interfaces/flux.py,sha256=LTY_I9UtIxnh3Nc4cBPQhQ6upB6CVZIhc1uOnFpxEIo,532
 symai/extended/interfaces/gpt_image.py,sha256=Jk5-9og440eZeRAhKmjdyhwP22wX58q0NcFuVhIFWZQ,718
 symai/extended/interfaces/input.py,sha256=CFMLf2j_a-rZ1ApaEwfgqZmWVS7_1yj_u6iiqtiOGPs,456
@@ -115,7 +118,7 @@ symai/extended/interfaces/naive_scrape.py,sha256=KPjTSBXSCr5zwHwIPgF-VwLSTD2OjVc
 symai/extended/interfaces/naive_vectordb.py,sha256=fm7DBMYYnSx7Ma7eNnCmuOVyQwNGnkiDR31oV-qNrJA,1348
 symai/extended/interfaces/ocr.py,sha256=MMxgp8ZKoM44doJPZzzrBVh2VxChs6faFu2uFYnbzfU,563
 symai/extended/interfaces/openai_search.py,sha256=UvnSihdfIwybrLDz2A-yt92aklHEHIvh0pt0hp1Dpis,528
-symai/extended/interfaces/parallel.py,sha256=3QL3B-HJd1mCd1XsV8Ha_63TQZi-rlA0OJjUXB3p3UU,899
+symai/extended/interfaces/parallel.py,sha256=kWRcrs_vTPvZDDhKjl1Hp94ltZeiYH7K8l9zOy5jd-I,947
 symai/extended/interfaces/perplexity.py,sha256=vSUl8CfBsFhFrzxws9Lf8WgfhsoPatJf7eYRfihKRG4,529
 symai/extended/interfaces/pinecone.py,sha256=NA2t1pNQf-G-HSeewEO8jqGnitD3huBV5bucIM9vgi4,1075
 symai/extended/interfaces/python.py,sha256=EcxXQwrlhjGOS5SkRoa_cVt069vu_INDD9DIfbnUses,418
@@ -163,9 +166,9 @@ symai/server/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
 symai/server/huggingface_server.py,sha256=wSAVqFiKQsCu5UB2YYVpxJBhJ7GgQBBfePxNi265yP8,9039
 symai/server/llama_cpp_server.py,sha256=-WPTNB2cbnwtnpES4AtPM__MCasDKl83jr94JGS9tmI,2144
 symai/server/qdrant_server.py,sha256=l4r4rz29c7cO1dapXO0LQ4sHW4WF44keuz7j8v5azMc,9854
-symbolicai-1.4.0.dist-info/licenses/LICENSE,sha256=9vRFudlJ1ghVfra5lcCUIYQCqnZSYcBLjLHbGRsrQCs,1505
-symbolicai-1.4.0.dist-info/METADATA,sha256=dlAY-AhPA52x_fmXU-i7h6rA-M1Mf0qJ00OeOUyplGs,23676
-symbolicai-1.4.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-symbolicai-1.4.0.dist-info/entry_points.txt,sha256=JV5sdydIfUZdDF6QBEQHiZHod6XNPjCjpWQrXh7gTAw,261
-symbolicai-1.4.0.dist-info/top_level.txt,sha256=bOoIDfpDIvCQtQgXcwVKJvxAKwsxpxo2IL4z92rNJjw,6
-symbolicai-1.4.0.dist-info/RECORD,,
+symbolicai-1.5.0.dist-info/licenses/LICENSE,sha256=9vRFudlJ1ghVfra5lcCUIYQCqnZSYcBLjLHbGRsrQCs,1505
+symbolicai-1.5.0.dist-info/METADATA,sha256=gQLPEUb1pW2VPNqCtgN-WcXeSQnfUJAWx0KTAN3vnJw,23731
+symbolicai-1.5.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+symbolicai-1.5.0.dist-info/entry_points.txt,sha256=JV5sdydIfUZdDF6QBEQHiZHod6XNPjCjpWQrXh7gTAw,261
+symbolicai-1.5.0.dist-info/top_level.txt,sha256=bOoIDfpDIvCQtQgXcwVKJvxAKwsxpxo2IL4z92rNJjw,6
+symbolicai-1.5.0.dist-info/RECORD,,