agent0-sdk 1.4.2__py3-none-any.whl → 1.5.1b1__py3-none-any.whl

agent0_sdk/core/indexer.py

@@ -37,12 +37,14 @@ from datetime import datetime
 
 from .models import (
     AgentId, ChainId, Address, URI, Timestamp,
-    AgentSummary, Feedback, SearchParams, SearchFeedbackParams
+    AgentSummary, Feedback, SearchFilters, SearchOptions, SearchFeedbackParams
 )
 from .web3_client import Web3Client
 
 logger = logging.getLogger(__name__)
 
+from .semantic_search_client import SemanticSearchClient
+
 
 class AgentIndexer:
     """Indexer for agent discovery and search."""
@@ -323,10 +325,25 @@ class AgentIndexer:
         registration_data: Dict[str, Any]
     ) -> AgentSummary:
         """Create agent summary from registration data."""
-        # Extract endpoints
+        # Extract endpoints (legacy/non-subgraph path)
         endpoints = registration_data.get("endpoints", [])
-        mcp = any(ep.get("name") == "MCP" for ep in endpoints)
-        a2a = any(ep.get("name") == "A2A" for ep in endpoints)
+        mcp: Optional[str] = None
+        a2a: Optional[str] = None
+        web: Optional[str] = None
+        email: Optional[str] = None
+        for ep in endpoints:
+            name = (ep.get("name") or "").upper()
+            value = ep.get("endpoint")
+            if not isinstance(value, str):
+                continue
+            if name == "MCP":
+                mcp = value
+            elif name == "A2A":
+                a2a = value
+            elif name == "WEB":
+                web = value
+            elif name == "EMAIL":
+                email = value
         
         ens = None
         did = None
@@ -352,6 +369,8 @@ class AgentIndexer:
             operators=[],  # Would be populated from contract
             mcp=mcp,
             a2a=a2a,
+            web=web,
+            email=email,
             ens=ens,
             did=did,
             walletAddress=registration_data.get("walletAddress"),
@@ -360,6 +379,8 @@ class AgentIndexer:
             mcpTools=mcp_tools,
             mcpPrompts=mcp_prompts,
             mcpResources=mcp_resources,
+            oasfSkills=[],
+            oasfDomains=[],
             active=registration_data.get("active", True),
             extras={}
         )
@@ -422,18 +443,28 @@ class AgentIndexer:
                 description=reg_file.get('description', ''),
                 owners=[agent_data.get('owner', '')],
                 operators=agent_data.get('operators', []),
-                mcp=reg_file.get('mcpEndpoint') is not None,
-                a2a=reg_file.get('a2aEndpoint') is not None,
+                mcp=reg_file.get('mcpEndpoint') or None,
+                a2a=reg_file.get('a2aEndpoint') or None,
+                web=reg_file.get('webEndpoint') or None,
+                email=reg_file.get('emailEndpoint') or None,
                 ens=reg_file.get('ens'),
                 did=reg_file.get('did'),
-                walletAddress=reg_file.get('agentWallet'),
+                walletAddress=agent_data.get('agentWallet'),
                 supportedTrusts=reg_file.get('supportedTrusts', []),
                 a2aSkills=reg_file.get('a2aSkills', []),
                 mcpTools=reg_file.get('mcpTools', []),
                 mcpPrompts=reg_file.get('mcpPrompts', []),
                 mcpResources=reg_file.get('mcpResources', []),
+                oasfSkills=reg_file.get('oasfSkills', []) or [],
+                oasfDomains=reg_file.get('oasfDomains', []) or [],
                 active=reg_file.get('active', True),
                 x402support=reg_file.get('x402Support', reg_file.get('x402support', False)),
+                createdAt=agent_data.get('createdAt'),
+                updatedAt=agent_data.get('updatedAt'),
+                lastActivity=agent_data.get('lastActivity'),
+                agentURI=agent_data.get('agentURI'),
+                agentURIType=agent_data.get('agentURIType'),
+                feedbackCount=agent_data.get('totalFeedback'),
                 extras={}
             )
             
@@ -442,540 +473,605 @@ class AgentIndexer:
 
     def search_agents(
         self,
-        params: SearchParams,
-        sort: List[str],
-        page_size: int,
-        cursor: Optional[str] = None,
-    ) -> Dict[str, Any]:
-        """Search for agents by querying the subgraph or blockchain."""
-        # Handle "all" chains shorthand
-        if params.chains == "all":
-            params.chains = self._get_all_configured_chains()
-            logger.info(f"Expanding 'all' to configured chains: {params.chains}")
-
-        # If chains are explicitly specified (even a single chain), use multi-chain path
-        # This ensures the correct subgraph client is used for the requested chain(s)
-        if params.chains and len(params.chains) > 0:
-            # Validate chains are configured
-            available_chains = set(self._get_all_configured_chains())
-            requested_chains = set(params.chains)
-            invalid_chains = requested_chains - available_chains
-
-            if invalid_chains:
-                logger.warning(
-                    f"Requested chains not configured: {invalid_chains}. "
-                    f"Available chains: {available_chains}"
-                )
-                # Filter to valid chains only
-                valid_chains = list(requested_chains & available_chains)
-                if not valid_chains:
-                    return {
-                        "items": [],
-                        "nextCursor": None,
-                        "meta": {
-                            "chains": list(requested_chains),
-                            "successfulChains": [],
-                            "failedChains": list(requested_chains),
-                            "error": f"No valid chains configured. Available: {list(available_chains)}"
-                        }
-                    }
-                params.chains = valid_chains
-
-            return asyncio.run(
-                self._search_agents_across_chains(params, sort, page_size, cursor)
+        filters: SearchFilters,
+        options: SearchOptions,
+    ) -> List[AgentSummary]:
+        """Unified search entry point (replaces all legacy search variants)."""
+        if filters.keyword and str(filters.keyword).strip():
+            return self._search_unified_with_keyword(filters, options)
+        else:
+            return self._search_unified_no_keyword(filters, options)
+
+    # -------------------------------------------------------------------------
+    # Unified search (v2)
+    # -------------------------------------------------------------------------
+
+    def _parse_sort(self, sort: Optional[List[str]], keyword_present: bool) -> tuple[str, str]:
+        default = "semanticScore:desc" if keyword_present else "updatedAt:desc"
+        spec = (sort[0] if sort and len(sort) > 0 else default) or default
+        parts = spec.split(":", 1)
+        field = parts[0] if parts and parts[0] else ("semanticScore" if keyword_present else "updatedAt")
+        direction = (parts[1] if len(parts) > 1 else "desc").lower()
+        if direction not in ("asc", "desc"):
+            direction = "desc"
+        return field, direction
+
+    def _resolve_chains(self, filters: SearchFilters, keyword_present: bool) -> List[int]:
+        if filters.chains == "all":
+            return self._get_all_configured_chains()
+        if isinstance(filters.chains, list) and len(filters.chains) > 0:
+            return filters.chains
+        if keyword_present:
+            return self._get_all_configured_chains()
+        return [self.web3_client.chain_id]
+
+    # Pagination removed: cursor helpers deleted.
+
+    def _to_unix_seconds(self, dt: Any) -> int:
+        if isinstance(dt, int):
+            return dt
+        if isinstance(dt, datetime):
+            return int(dt.timestamp())
+        s = str(dt).strip()
+        if not s:
+            raise ValueError("Empty date")
+        # If no timezone, treat as UTC by appending 'Z'
+        if not ("Z" in s or "z" in s or "+" in s or "-" in s[-6:]):
+            s = f"{s}Z"
+        return int(datetime.fromisoformat(s.replace("Z", "+00:00")).timestamp())
+
+    def _normalize_agent_ids(self, filters: SearchFilters, chains: List[int]) -> Optional[Dict[int, List[str]]]:
+        if not filters.agentIds:
+            return None
+        by_chain: Dict[int, List[str]] = {}
+        for aid in filters.agentIds:
+            s = str(aid)
+            if ":" in s:
+                chain_str = s.split(":", 1)[0]
+                try:
+                    chain_id = int(chain_str)
+                except Exception:
+                    continue
+                by_chain.setdefault(chain_id, []).append(s)
+            else:
+                if len(chains) != 1:
+                    raise ValueError("agentIds without chain prefix are only allowed when searching exactly one chain.")
+                by_chain.setdefault(chains[0], []).append(f"{chains[0]}:{s}")
+        return by_chain
+
+    def _build_where_v2(self, filters: SearchFilters, ids_for_chain: Optional[List[str]] = None) -> Dict[str, Any]:
+        base: Dict[str, Any] = {}
+        and_conditions: List[Dict[str, Any]] = []
+
+        # Default: only agents with registration files
+        if filters.hasRegistrationFile is False:
+            base["registrationFile"] = None
+        else:
+            base["registrationFile_not"] = None
+
+        if ids_for_chain:
+            base["id_in"] = ids_for_chain
+
+        if filters.walletAddress:
+            base["agentWallet"] = str(filters.walletAddress).lower()
+
+        # Feedback existence filters can be pushed down via Agent.totalFeedback when they are the ONLY feedback constraint.
+        fb = filters.feedback
+        if fb and (getattr(fb, "hasFeedback", False) or getattr(fb, "hasNoFeedback", False)):
+            has_threshold = any(
+                x is not None
+                for x in [
+                    getattr(fb, "minCount", None),
+                    getattr(fb, "maxCount", None),
+                    getattr(fb, "minValue", None),
+                    getattr(fb, "maxValue", None),
+                ]
             )
+            has_any_constraint = any(
+                [
+                    bool(getattr(fb, "hasResponse", False)),
+                    bool(getattr(fb, "fromReviewers", None)),
+                    bool(getattr(fb, "endpoint", None)),
+                    bool(getattr(fb, "tag", None)),
+                    bool(getattr(fb, "tag1", None)),
+                    bool(getattr(fb, "tag2", None)),
+                ]
+            )
+            if not has_threshold and not has_any_constraint:
+                if getattr(fb, "hasFeedback", False):
+                    base["totalFeedback_gt"] = "0"
+                if getattr(fb, "hasNoFeedback", False):
+                    base["totalFeedback"] = "0"
+
+        if filters.owners:
+            base["owner_in"] = [str(o).lower() for o in filters.owners]
+
+        if filters.operators:
+            ops = [str(o).lower() for o in filters.operators]
+            and_conditions.append({"or": [{"operators_contains": [op]} for op in ops]})
+
+        if filters.registeredAtFrom is not None:
+            base["createdAt_gte"] = self._to_unix_seconds(filters.registeredAtFrom)
+        if filters.registeredAtTo is not None:
+            base["createdAt_lte"] = self._to_unix_seconds(filters.registeredAtTo)
+        if filters.updatedAtFrom is not None:
+            base["updatedAt_gte"] = self._to_unix_seconds(filters.updatedAtFrom)
+        if filters.updatedAtTo is not None:
+            base["updatedAt_lte"] = self._to_unix_seconds(filters.updatedAtTo)
+
+        rf: Dict[str, Any] = {}
+        if filters.name:
+            rf["name_contains_nocase"] = filters.name
+        if filters.description:
+            rf["description_contains_nocase"] = filters.description
+        if filters.ensContains:
+            rf["ens_contains_nocase"] = filters.ensContains
+        if filters.didContains:
+            rf["did_contains_nocase"] = filters.didContains
+        if filters.active is not None:
+            rf["active"] = filters.active
+        if filters.x402support is not None:
+            rf["x402Support"] = filters.x402support
+
+        if filters.hasMCP is not None:
+            rf["mcpEndpoint_not" if filters.hasMCP else "mcpEndpoint"] = None
+        if filters.hasA2A is not None:
+            rf["a2aEndpoint_not" if filters.hasA2A else "a2aEndpoint"] = None
+        if filters.hasWeb is not None:
+            rf["webEndpoint_not" if filters.hasWeb else "webEndpoint"] = None
+        if filters.hasOASF is not None:
+            # Exact semantics: true iff (oasfSkills OR oasfDomains) is non-empty (via subgraph derived field).
+            rf["hasOASF"] = bool(filters.hasOASF)
+
+        if filters.mcpContains:
+            rf["mcpEndpoint_contains_nocase"] = filters.mcpContains
+        if filters.a2aContains:
+            rf["a2aEndpoint_contains_nocase"] = filters.a2aContains
+        if filters.webContains:
+            rf["webEndpoint_contains_nocase"] = filters.webContains
+
+        if rf:
+            base["registrationFile_"] = rf
+
+        def any_of_list(field: str, values: Optional[List[str]]):
+            if not values:
+                return
+            and_conditions.append({"or": [{"registrationFile_": {f"{field}_contains": [v]}} for v in values]})
+
+        any_of_list("supportedTrusts", filters.supportedTrust)
+        any_of_list("a2aSkills", filters.a2aSkills)
+        any_of_list("mcpTools", filters.mcpTools)
+        any_of_list("mcpPrompts", filters.mcpPrompts)
+        any_of_list("mcpResources", filters.mcpResources)
+        any_of_list("oasfSkills", filters.oasfSkills)
+        any_of_list("oasfDomains", filters.oasfDomains)
+
+        if filters.hasEndpoints is not None:
+            if filters.hasEndpoints:
+                and_conditions.append(
+                    {
+                        "or": [
+                            {"registrationFile_": {"webEndpoint_not": None}},
+                            {"registrationFile_": {"mcpEndpoint_not": None}},
+                            {"registrationFile_": {"a2aEndpoint_not": None}},
+                        ]
+                    }
+                )
+            else:
+                and_conditions.append({"registrationFile_": {"webEndpoint": None, "mcpEndpoint": None, "a2aEndpoint": None}})
 
-        # Use subgraph if available (preferred)
-        if self.subgraph_client:
-            return self._search_agents_via_subgraph(params, sort, page_size, cursor)
-
-        # Fallback to blockchain queries
-        return self._search_agents_via_blockchain(params, sort, page_size, cursor)
+        if not and_conditions:
+            return base
+        return {"and": [base, *and_conditions]}
 
-    async def _search_agents_across_chains(
+    def _intersect_ids(self, a: Optional[List[str]], b: Optional[List[str]]) -> Optional[List[str]]:
+        if a is None and b is None:
+            return None
+        if a is None:
+            return b or []
+        if b is None:
+            return a or []
+        bset = set(b)
+        return [x for x in a if x in bset]
+
+    def _utf8_to_hex(self, s: str) -> str:
+        return "0x" + s.encode("utf-8").hex()
+
+    def _prefilter_by_metadata(self, filters: SearchFilters, chains: List[int]) -> Optional[Dict[int, List[str]]]:
+        key = filters.hasMetadataKey or (filters.metadataValue.get("key") if isinstance(filters.metadataValue, dict) else None)
+        if not key:
+            return None
+        value_str = None
+        if isinstance(filters.metadataValue, dict):
+            value_str = filters.metadataValue.get("value")
+        value_hex = self._utf8_to_hex(str(value_str)) if value_str is not None else None
+
+        first = 1000
+        out: Dict[int, List[str]] = {}
+
+        for chain_id in chains:
+            sub = self._get_subgraph_client_for_chain(chain_id)
+            if sub is None:
+                out[chain_id] = []
+                continue
+            ids: List[str] = []
+            skip = 0
+            while True:
+                where: Dict[str, Any] = {"key": key}
+                if value_hex is not None:
+                    where["value"] = value_hex
+                rows = sub.query_agent_metadatas(where=where, first=first, skip=skip)
+                for r in rows:
+                    agent = r.get("agent") or {}
+                    aid = agent.get("id")
+                    if aid:
+                        ids.append(str(aid))
+                if len(rows) < first:
+                    break
+                skip += first
+            out[chain_id] = sorted(list(set(ids)))
+        return out
+
+    def _prefilter_by_feedback(
         self,
-        params: SearchParams,
-        sort: List[str],
-        page_size: int,
-        cursor: Optional[str] = None,
-        timeout: float = 30.0,
-    ) -> Dict[str, Any]:
-        """
-        Search agents across multiple chains in parallel.
-
-        This method is called when params.chains contains 2+ chain IDs.
-        It executes one subgraph query per chain, all in parallel using asyncio.
-
-        Args:
-            params: Search parameters
-            sort: Sort specification
-            page_size: Number of results per page
-            cursor: Pagination cursor
-            timeout: Maximum time in seconds for all chain queries (default: 30.0)
-
-        Returns:
-            {
-                "items": [agent_dict, ...],
-                "nextCursor": str or None,
-                "meta": {
-                    "chains": [chainId, ...],
-                    "successfulChains": [chainId, ...],
-                    "failedChains": [chainId, ...],
-                    "totalResults": int,
-                    "timing": {"totalMs": int}
-                }
-            }
-        """
-        import time
-        start_time = time.time()
-        # Step 1: Determine which chains to query
-        chains_to_query = params.chains if params.chains else self._get_all_configured_chains()
-
-        if not chains_to_query or len(chains_to_query) == 0:
-            logger.warning("No chains specified or configured for multi-chain query")
-            return {"items": [], "nextCursor": None, "meta": {"chains": [], "successfulChains": [], "failedChains": []}}
-
-        # Step 2: Parse pagination cursor (if any)
-        chain_cursors = self._parse_multi_chain_cursor(cursor)
-        global_offset = chain_cursors.get("_global_offset", 0)
-
-        # Step 3: Define async function for querying a single chain
-        async def query_single_chain(chain_id: int) -> Dict[str, Any]:
-            """Query one chain and return its results with metadata."""
-            try:
-                # Get subgraph client for this chain
-                subgraph_client = self._get_subgraph_client_for_chain(chain_id)
-
-                if subgraph_client is None:
-                    logger.warning(f"No subgraph client available for chain {chain_id}")
-                    return {
-                        "chainId": chain_id,
-                        "status": "unavailable",
-                        "agents": [],
-                        "error": f"No subgraph configured for chain {chain_id}"
-                    }
+        filters: SearchFilters,
+        chains: List[int],
+        candidate_ids_by_chain: Optional[Dict[int, List[str]]] = None,
+    ) -> tuple[Optional[Dict[int, List[str]]], Dict[str, Dict[str, float]]]:
+        fb = filters.feedback
+        if fb is None:
+            return None, {}
+
+        include_revoked = bool(getattr(fb, "includeRevoked", False))
+        has_threshold = any(
+            x is not None
+            for x in [
+                getattr(fb, "minCount", None),
+                getattr(fb, "maxCount", None),
+                getattr(fb, "minValue", None),
+                getattr(fb, "maxValue", None),
+            ]
+        )
+        has_any_constraint = any(
+            [
+                bool(getattr(fb, "hasResponse", False)),
+                bool(getattr(fb, "fromReviewers", None)),
+                bool(getattr(fb, "endpoint", None)),
+                bool(getattr(fb, "tag", None)),
+                bool(getattr(fb, "tag1", None)),
+                bool(getattr(fb, "tag2", None)),
+            ]
+        )
 
-                # Build WHERE clause for this chain's query
-                # (reuse existing logic from _search_agents_via_subgraph)
-                where_clause = {}
-                reg_file_where = {}
-
-                if params.name is not None:
-                    reg_file_where["name_contains"] = params.name
-                if params.active is not None:
-                    reg_file_where["active"] = params.active
-                if params.x402support is not None:
-                    reg_file_where["x402support"] = params.x402support
-                if params.mcp is not None:
-                    if params.mcp:
-                        reg_file_where["mcpEndpoint_not"] = None
-                    else:
-                        reg_file_where["mcpEndpoint"] = None
-                if params.a2a is not None:
-                    if params.a2a:
-                        reg_file_where["a2aEndpoint_not"] = None
-                    else:
-                        reg_file_where["a2aEndpoint"] = None
-                if params.ens is not None:
-                    reg_file_where["ens"] = params.ens
-                if params.did is not None:
-                    reg_file_where["did"] = params.did
-                if params.walletAddress is not None:
-                    reg_file_where["agentWallet"] = params.walletAddress
-
-                if reg_file_where:
-                    where_clause["registrationFile_"] = reg_file_where
-
-                # Owner filtering
-                if params.owners is not None and len(params.owners) > 0:
-                    normalized_owners = [owner.lower() for owner in params.owners]
-                    if len(normalized_owners) == 1:
-                        where_clause["owner"] = normalized_owners[0]
-                    else:
-                        where_clause["owner_in"] = normalized_owners
-
-                # Operator filtering
-                if params.operators is not None and len(params.operators) > 0:
-                    normalized_operators = [op.lower() for op in params.operators]
-                    where_clause["operators_contains"] = normalized_operators
-
-                # Get pagination offset for this chain (not used in multi-chain, fetch all)
-                skip = 0
-
-                # Execute subgraph query
-                agents = subgraph_client.get_agents(
-                    where=where_clause if where_clause else None,
-                    first=page_size * 3,  # Fetch extra to allow for filtering/sorting
-                    skip=skip,
-                    order_by=self._extract_order_by(sort),
-                    order_direction=self._extract_order_direction(sort)
-                )
+        # If hasNoFeedback/hasFeedback are the ONLY feedback constraint, we push them down via Agent.totalFeedback in _build_where_v2.
+        if getattr(fb, "hasNoFeedback", False) and not has_threshold and not has_any_constraint:
+            return None, {}
+        if getattr(fb, "hasFeedback", False) and not has_threshold and not has_any_constraint:
+            return None, {}
+
+        # Otherwise, hasNoFeedback requires an explicit candidate set to subtract from.
+        if getattr(fb, "hasNoFeedback", False):
+            if not candidate_ids_by_chain or not any(candidate_ids_by_chain.get(c) for c in chains):
+                raise ValueError("feedback.hasNoFeedback requires a pre-filtered candidate set (e.g. agentIds or keyword).")
+
+        first = 1000
+
+        sums: Dict[str, float] = {}
+        counts: Dict[str, int] = {}
+        matched_by_chain: Dict[int, set[str]] = {}
+
+        for chain_id in chains:
+            sub = self._get_subgraph_client_for_chain(chain_id)
+            if sub is None:
+                continue
+            candidates = (candidate_ids_by_chain or {}).get(chain_id)
+
+            base: Dict[str, Any] = {}
+            and_conditions: List[Dict[str, Any]] = []
+
+            if not include_revoked:
+                base["isRevoked"] = False
+            from_reviewers = getattr(fb, "fromReviewers", None)
+            if from_reviewers:
+                base["clientAddress_in"] = [str(a).lower() for a in from_reviewers]
+            endpoint = getattr(fb, "endpoint", None)
+            if endpoint:
+                base["endpoint_contains_nocase"] = endpoint
+            if candidates:
+                base["agent_in"] = candidates
+
+            tag1 = getattr(fb, "tag1", None)
+            tag2 = getattr(fb, "tag2", None)
+            tag = getattr(fb, "tag", None)
+            if tag1:
+                base["tag1"] = tag1
+            if tag2:
+                base["tag2"] = tag2
+            if tag:
+                and_conditions.append({"or": [{"tag1": tag}, {"tag2": tag}]})
+
+            where: Dict[str, Any] = {"and": [base, *and_conditions]} if and_conditions else base
+
+            skip = 0
+            while True:
+                rows = sub.query_feedbacks_minimal(where=where, first=first, skip=skip, order_by="createdAt", order_direction="desc")
+                for r in rows:
+                    agent = r.get("agent") or {}
+                    aid = agent.get("id")
+                    if not aid:
+                        continue
+                    if getattr(fb, "hasResponse", False):
+                        responses = r.get("responses") or []
+                        if not isinstance(responses, list) or len(responses) == 0:
+                            continue
+                    try:
+                        v = float(r.get("value"))
+                    except Exception:
+                        continue
+                    aid_s = str(aid)
+                    sums[aid_s] = sums.get(aid_s, 0.0) + v
+                    counts[aid_s] = counts.get(aid_s, 0) + 1
+                    matched_by_chain.setdefault(chain_id, set()).add(aid_s)
+                if len(rows) < first:
+                    break
+                skip += first
+
+        stats: Dict[str, Dict[str, float]] = {}
+        for aid, cnt in counts.items():
+            avg = (sums.get(aid, 0.0) / cnt) if cnt > 0 else 0.0
+            stats[aid] = {"count": float(cnt), "avg": float(avg)}
+
+        def passes(aid: str) -> bool:
+            st = stats.get(aid, {"count": 0.0, "avg": 0.0})
+            cnt = st["count"]
+            avg = st["avg"]
+            min_count = getattr(fb, "minCount", None)
+            max_count = getattr(fb, "maxCount", None)
+            min_val = getattr(fb, "minValue", None)
+            max_val = getattr(fb, "maxValue", None)
+            if min_count is not None and cnt < float(min_count):
+                return False
+            if max_count is not None and cnt > float(max_count):
+                return False
+            if min_val is not None and avg < float(min_val):
+                return False
+            if max_val is not None and avg > float(max_val):
+                return False
+            return True
 
-                logger.info(f"Chain {chain_id}: fetched {len(agents)} agents")
+        allow: Dict[int, List[str]] = {}
+        for chain_id in chains:
+            matched = matched_by_chain.get(chain_id, set())
+            candidates = (candidate_ids_by_chain or {}).get(chain_id)
 
-                return {
-                    "chainId": chain_id,
-                    "status": "success",
-                    "agents": agents,
-                    "count": len(agents),
-                }
+            if getattr(fb, "hasNoFeedback", False):
+                base_list = candidates or []
+                allow[chain_id] = [x for x in base_list if x not in matched]
+                continue
 
-            except Exception as e:
-                logger.error(f"Error querying chain {chain_id}: {e}", exc_info=True)
-                return {
-                    "chainId": chain_id,
-                    "status": "error",
-                    "agents": [],
-                    "error": str(e)
-                }
+            ids = list(matched)
+            if has_threshold:
+                ids = [x for x in ids if passes(x)]
+            elif has_any_constraint or getattr(fb, "hasFeedback", False):
+                ids = [x for x in ids if counts.get(x, 0) > 0]
 
-        # Step 4: Execute all chain queries in parallel with timeout
-        logger.info(f"Querying {len(chains_to_query)} chains in parallel: {chains_to_query}")
-        tasks = [query_single_chain(chain_id) for chain_id in chains_to_query]
+            if candidates:
+                cset = set(candidates)
+                ids = [x for x in ids if x in cset]
 
-        try:
-            chain_results = await asyncio.wait_for(
-                asyncio.gather(*tasks),
-                timeout=timeout
-            )
-        except asyncio.TimeoutError:
-            logger.error(f"Multi-chain query timed out after {timeout}s")
-            # Collect results from completed tasks
-            chain_results = []
-            for task in tasks:
-                if task.done():
-                    try:
-                        chain_results.append(task.result())
-                    except Exception as e:
-                        logger.warning(f"Task failed: {e}")
-                else:
-                    # Task didn't complete - mark as timeout
-                    chain_results.append({
-                        "chainId": None,
-                        "status": "timeout",
-                        "agents": [],
-                        "error": f"Query timed out after {timeout}s"
-                    })
-
-        # Step 5: Extract successful results and track failures
-        all_agents = []
-        successful_chains = []
-        failed_chains = []
-
-        for result in chain_results:
-            chain_id = result["chainId"]
-
-            if result["status"] == "success":
-                successful_chains.append(chain_id)
-                all_agents.extend(result["agents"])
-            else:
-                failed_chains.append(chain_id)
-                logger.warning(
-                    f"Chain {chain_id} query failed: {result.get('error', 'Unknown error')}"
-                )
+            allow[chain_id] = ids
 
-        logger.info(f"Multi-chain query: {len(successful_chains)} successful, {len(failed_chains)} failed, {len(all_agents)} total agents")
+        return allow, stats
 
-        # If ALL chains failed, raise error
-        if len(successful_chains) == 0:
-            raise ConnectionError(
-                f"All chains failed: {', '.join(str(c) for c in failed_chains)}"
-            )
+    def _search_unified_no_keyword(self, filters: SearchFilters, options: SearchOptions) -> List[AgentSummary]:
+        if not self.subgraph_client:
+            raise ValueError("Subgraph client required for searchAgents")
 
-        # Step 6: Apply cross-chain filtering (for fields not supported by subgraph WHERE clause)
-        filtered_agents = self._apply_cross_chain_filters(all_agents, params)
-        logger.info(f"After cross-chain filters: {len(filtered_agents)} agents")
+        field, direction = self._parse_sort(options.sort, False)
+        chains = self._resolve_chains(filters, False)
+        ids_by_chain = self._normalize_agent_ids(filters, chains)
+        metadata_ids_by_chain = self._prefilter_by_metadata(filters, chains)
 
-        # Step 7: Deduplicate if requested
-        deduplicated_agents = self._deduplicate_agents_cross_chain(filtered_agents, params)
-        logger.info(f"After deduplication: {len(deduplicated_agents)} agents")
+        candidate_for_feedback: Dict[int, List[str]] = {}
+        for c in chains:
+            ids0 = self._intersect_ids((ids_by_chain or {}).get(c), (metadata_ids_by_chain or {}).get(c))
+            if ids0:
+                candidate_for_feedback[c] = ids0
 
-        # Step 8: Sort across chains
-        sorted_agents = self._sort_agents_cross_chain(deduplicated_agents, sort)
-        logger.info(f"After sorting: {len(sorted_agents)} agents")
+        feedback_ids_by_chain, feedback_stats_by_id = self._prefilter_by_feedback(
+            filters, chains, candidate_for_feedback if candidate_for_feedback else None
+        )
 
-        # Step 9: Apply pagination
-        start_idx = global_offset
-        paginated_agents = sorted_agents[start_idx:start_idx + page_size]
+        order_by = field if field in ("createdAt", "updatedAt", "name", "chainId", "lastActivity", "totalFeedback") else "updatedAt"
+        if field == "feedbackCount":
+            order_by = "totalFeedback"
 
-        # Step 10: Convert to result format (keep as dicts, SDK will convert to AgentSummary)
-        results = []
-        for agent_data in paginated_agents:
-            reg_file = agent_data.get('registrationFile') or {}
+        def to_summary(agent_data: Dict[str, Any]) -> AgentSummary:
+            reg_file = agent_data.get("registrationFile") or {}
             if not isinstance(reg_file, dict):
                 reg_file = {}
-
-            result_agent = {
-                "agentId": agent_data.get('id'),
-                "chainId": agent_data.get('chainId'),
-                "name": reg_file.get('name', f"Agent {agent_data.get('agentId')}"),
-                "description": reg_file.get('description', ''),
-                "image": reg_file.get('image'),
-                "owner": agent_data.get('owner'),
-                "operators": agent_data.get('operators', []),
-                "mcp": reg_file.get('mcpEndpoint') is not None,
-                "a2a": reg_file.get('a2aEndpoint') is not None,
-                "ens": reg_file.get('ens'),
-                "did": reg_file.get('did'),
-                "walletAddress": reg_file.get('agentWallet'),
-                "supportedTrusts": reg_file.get('supportedTrusts', []),
-                "a2aSkills": reg_file.get('a2aSkills', []),
-                "mcpTools": reg_file.get('mcpTools', []),
-                "mcpPrompts": reg_file.get('mcpPrompts', []),
-                "mcpResources": reg_file.get('mcpResources', []),
-                "active": reg_file.get('active', True),
-                "x402support": reg_file.get('x402Support', reg_file.get('x402support', False)),
-                "totalFeedback": agent_data.get('totalFeedback', 0),
-                "lastActivity": agent_data.get('lastActivity'),
-                "updatedAt": agent_data.get('updatedAt'),
-                "extras": {}
-            }
-
-            # Add deployedOn if deduplication was used
-            if 'deployedOn' in agent_data:
-                result_agent['extras']['deployedOn'] = agent_data['deployedOn']
-
-            results.append(result_agent)
-
-        # Step 11: Calculate next cursor
-        next_cursor = None
-        if len(sorted_agents) > start_idx + page_size:
-            # More results available
-            next_cursor = self._create_multi_chain_cursor(
-                global_offset=start_idx + page_size
+            aid = str(agent_data.get("id", ""))
+            st = feedback_stats_by_id.get(aid) or {}
+            return AgentSummary(
+                chainId=int(agent_data.get("chainId", 0)),
+                agentId=aid,
+                name=reg_file.get("name") or aid,
+                image=reg_file.get("image"),
+                description=reg_file.get("description", "") or "",
+                owners=[agent_data.get("owner", "")] if agent_data.get("owner") else [],
+                operators=agent_data.get("operators", []) or [],
+                mcp=reg_file.get("mcpEndpoint") or None,
+                a2a=reg_file.get("a2aEndpoint") or None,
+                web=reg_file.get("webEndpoint") or None,
+                email=reg_file.get("emailEndpoint") or None,
+                ens=reg_file.get("ens"),
+                did=reg_file.get("did"),
+                walletAddress=agent_data.get("agentWallet"),
+                supportedTrusts=reg_file.get("supportedTrusts", []) or [],
+                a2aSkills=reg_file.get("a2aSkills", []) or [],
+                mcpTools=reg_file.get("mcpTools", []) or [],
+                mcpPrompts=reg_file.get("mcpPrompts", []) or [],
+                mcpResources=reg_file.get("mcpResources", []) or [],
+                oasfSkills=reg_file.get("oasfSkills", []) or [],
+                oasfDomains=reg_file.get("oasfDomains", []) or [],
+                active=bool(reg_file.get("active", False)),
+                x402support=bool(reg_file.get("x402Support", reg_file.get("x402support", False))),
+                createdAt=agent_data.get("createdAt"),
+                updatedAt=agent_data.get("updatedAt"),
+                lastActivity=agent_data.get("lastActivity"),
+                agentURI=agent_data.get("agentURI"),
+                agentURIType=agent_data.get("agentURIType"),
+                feedbackCount=agent_data.get("totalFeedback"),
+                averageValue=float(st.get("avg")) if st.get("avg") is not None else None,
+                extras={},
             )
 
-        # Step 12: Build response with metadata
-        query_time = time.time() - start_time
+        batch = 1000
+        out: List[AgentSummary] = []
+        for chain_id in chains:
+            client = self._get_subgraph_client_for_chain(chain_id)
+            if client is None:
+                continue
+            ids0 = self._intersect_ids((ids_by_chain or {}).get(chain_id), (metadata_ids_by_chain or {}).get(chain_id))
+            ids = self._intersect_ids(ids0, (feedback_ids_by_chain or {}).get(chain_id))
+            if ids is not None and len(ids) == 0:
+                continue
+            where = self._build_where_v2(filters, ids)
+
+            skip = 0
+            while True:
+                agents = client.get_agents_v2(where=where, first=batch, skip=skip, order_by=order_by, order_direction=direction)
+                for a in agents:
+                    out.append(to_summary(a))
+                if len(agents) < batch:
+                    break
+                skip += batch
+
+        reverse = direction == "desc"
+
+        def sort_key(a: AgentSummary):
+            if field == "name":
+                return (a.name or "").lower()
+            v = getattr(a, field, None)
+            if v is None and field == "totalFeedback":
+                v = getattr(a, "feedbackCount", None)
+            if v is None:
+                return 0.0
+            try:
+                return float(v)
+            except Exception:
+                return 0.0
+
+        return sorted(out, key=sort_key, reverse=reverse)
 
-        return {
-            "items": results,
-            "nextCursor": next_cursor,
-            "meta": {
-                "chains": chains_to_query,
-                "successfulChains": successful_chains,
-                "failedChains": failed_chains,
-                "totalResults": len(sorted_agents),
-                "pageResults": len(results),
-                "timing": {
-                    "totalMs": int(query_time * 1000),
-                    "averagePerChainMs": int(query_time * 1000 / len(chains_to_query)) if chains_to_query else 0,
-                }
-            }
-        }
+    def _search_unified_with_keyword(self, filters: SearchFilters, options: SearchOptions) -> List[AgentSummary]:
+        field, direction = self._parse_sort(options.sort, True)
+        chains = self._resolve_chains(filters, True)
 
-    def _search_agents_via_subgraph(
-        self,
-        params: SearchParams,
-        sort: List[str],
-        page_size: int,
-        cursor: Optional[str] = None,
-    ) -> Dict[str, Any]:
-        """Search for agents using the subgraph."""
-        # Build subgraph query filters
-        where_clause = {}
-        reg_file_where = {}
-        
-        if params.name is not None:
-            reg_file_where["name_contains"] = params.name
-        if params.active is not None:
-            reg_file_where["active"] = params.active
-        if params.x402support is not None:
-            reg_file_where["x402support"] = params.x402support
-        if params.mcp is not None:
-            if params.mcp:
-                reg_file_where["mcpEndpoint_not"] = None
-            else:
-                reg_file_where["mcpEndpoint"] = None
-        if params.a2a is not None:
-            if params.a2a:
-                reg_file_where["a2aEndpoint_not"] = None
-            else:
-                reg_file_where["a2aEndpoint"] = None
-        if params.ens is not None:
-            reg_file_where["ens"] = params.ens
-        if params.did is not None:
-            reg_file_where["did"] = params.did
-        if params.walletAddress is not None:
-            reg_file_where["agentWallet"] = params.walletAddress
-
-        if reg_file_where:
-            where_clause["registrationFile_"] = reg_file_where
-
-        # Owner filtering
-        if params.owners is not None and len(params.owners) > 0:
-            # Normalize addresses to lowercase for case-insensitive matching
-            normalized_owners = [owner.lower() for owner in params.owners]
-            if len(normalized_owners) == 1:
-                where_clause["owner"] = normalized_owners[0]
-            else:
-                where_clause["owner_in"] = normalized_owners
-
-        # Operator filtering 
-        if params.operators is not None and len(params.operators) > 0:
-            # Normalize addresses to lowercase for case-insensitive matching
-            normalized_operators = [op.lower() for op in params.operators]
-            # For operators (array field), use contains to check if any operator matches
-            where_clause["operators_contains"] = normalized_operators
-        
-        # Calculate pagination
-        skip = 0
-        if cursor:
+        client = SemanticSearchClient()
+        semantic_results = client.search(
+            str(filters.keyword),
+            min_score=options.semanticMinScore,
+            top_k=options.semanticTopK,
+        )
+
+        allowed = set(chains)
+        semantic_results = [r for r in semantic_results if r.chainId in allowed]
+        ids_by_chain: Dict[int, List[str]] = {}
+        score_by_id: Dict[str, float] = {}
+        for r in semantic_results:
+            ids_by_chain.setdefault(r.chainId, []).append(r.agentId)
+            score_by_id[r.agentId] = r.score
+
+        fetched: List[AgentSummary] = []
+
+        metadata_ids_by_chain = self._prefilter_by_metadata(filters, chains)
+        feedback_ids_by_chain, feedback_stats_by_id = self._prefilter_by_feedback(filters, chains, ids_by_chain)
+
+        # Query agents by id_in chunks and apply remaining filters via where.
+        chunk_size = 500
+        for chain_id in chains:
+            sub = self._get_subgraph_client_for_chain(chain_id)
+            ids = ids_by_chain.get(chain_id, [])
+            if sub is None:
+                continue
             try:
-                skip = int(cursor)
-            except ValueError:
-                skip = 0
-        
-        # Determine sort
-        order_by = "createdAt"
-        order_direction = "desc"
-        if sort and len(sort) > 0:
-            sort_field = sort[0].split(":")
-            if len(sort_field) >= 1:
-                order_by = sort_field[0]
-            if len(sort_field) >= 2:
-                order_direction = sort_field[1]
-        
-        try:
-            agents = self.subgraph_client.get_agents(
-                where=where_clause if where_clause else None,
-                first=page_size,
-                skip=skip,
-                order_by=order_by,
-                order_direction=order_direction
-            )
-            
-            results = []
-            for agent in agents:
-                reg_file = agent.get('registrationFile') or {}
-                # Ensure reg_file is a dict
-                if not isinstance(reg_file, dict):
-                    reg_file = {}
-                    
-                agent_data = {
-                    "agentId": agent.get('id'),
-                    "chainId": agent.get('chainId'),
-                    "name": reg_file.get('name', f"Agent {agent.get('agentId')}"),
-                    "description": reg_file.get('description', ''),
-                    "image": reg_file.get('image'),
-                    "owner": agent.get('owner'),
-                    "operators": agent.get('operators', []),
-                    "mcp": reg_file.get('mcpEndpoint') is not None,
-                    "a2a": reg_file.get('a2aEndpoint') is not None,
-                    "ens": reg_file.get('ens'),
-                    "did": reg_file.get('did'),
-                    "walletAddress": reg_file.get('agentWallet'),
-                    "supportedTrusts": reg_file.get('supportedTrusts', []),
-                    "a2aSkills": reg_file.get('a2aSkills', []),
-                    "mcpTools": reg_file.get('mcpTools', []),
-                    "mcpPrompts": reg_file.get('mcpPrompts', []),
-                    "mcpResources": reg_file.get('mcpResources', []),
-                    "active": reg_file.get('active', True),
-                    "x402support": reg_file.get('x402Support', reg_file.get('x402support', False)),
-                    "totalFeedback": agent.get('totalFeedback', 0),
-                    "lastActivity": agent.get('lastActivity'),
-                    "updatedAt": agent.get('updatedAt'),
-                    "extras": {}
-                }
-                
-                if params.chains is not None:
-                    if agent_data["chainId"] not in params.chains:
+                for i in range(0, len(ids), chunk_size):
+                    chunk = ids[i : i + chunk_size]
+                    ids2 = self._intersect_ids(chunk, (metadata_ids_by_chain or {}).get(chain_id))
+                    ids3 = self._intersect_ids(ids2, (feedback_ids_by_chain or {}).get(chain_id))
+                    if ids3 is not None and len(ids3) == 0:
                         continue
-                if params.supportedTrust is not None:
-                    if not any(trust in agent_data["supportedTrusts"] for trust in params.supportedTrust):
+                    if ids3 is not None and len(ids3) == 0:
                         continue
-                
-                results.append(agent_data)
-            
-            next_cursor = str(skip + len(results)) if len(results) == page_size else None
-            return {"items": results, "nextCursor": next_cursor}
-            
-        except Exception as e:
-            logger.warning(f"Subgraph search failed: {e}")
-            return {"items": [], "nextCursor": None}
-    
-    def _search_agents_via_blockchain(
-        self,
-        params: SearchParams,
-        sort: List[str],
-        page_size: int,
-        cursor: Optional[str] = None,
-    ) -> Dict[str, Any]:
-        """Search for agents by querying the blockchain (fallback)."""
-        return {"items": [], "nextCursor": None}
+                    where = self._build_where_v2(filters, ids3)
+                    agents = sub.get_agents_v2(where=where, first=len(ids3 or []), skip=0, order_by="updatedAt", order_direction="desc")
+                    for a in agents:
+                        reg_file = a.get("registrationFile") or {}
+                        if not isinstance(reg_file, dict):
+                            reg_file = {}
+                        aid = str(a.get("id", ""))
+                        st = feedback_stats_by_id.get(aid) or {}
+                        fetched.append(
+                            AgentSummary(
+                                chainId=int(a.get("chainId", 0)),
+                                agentId=aid,
+                                name=reg_file.get("name") or aid,
+                                image=reg_file.get("image"),
+                                description=reg_file.get("description", "") or "",
+                                owners=[a.get("owner", "")] if a.get("owner") else [],
+                                operators=a.get("operators", []) or [],
+                                mcp=reg_file.get("mcpEndpoint") or None,
+                                a2a=reg_file.get("a2aEndpoint") or None,
+                                web=reg_file.get("webEndpoint") or None,
+                                email=reg_file.get("emailEndpoint") or None,
+                                ens=reg_file.get("ens"),
+                                did=reg_file.get("did"),
+                                walletAddress=a.get("agentWallet"),
+                                supportedTrusts=reg_file.get("supportedTrusts", []) or [],
+                                a2aSkills=reg_file.get("a2aSkills", []) or [],
+                                mcpTools=reg_file.get("mcpTools", []) or [],
+                                mcpPrompts=reg_file.get("mcpPrompts", []) or [],
+                                mcpResources=reg_file.get("mcpResources", []) or [],
+                                oasfSkills=reg_file.get("oasfSkills", []) or [],
+                                oasfDomains=reg_file.get("oasfDomains", []) or [],
+                                active=bool(reg_file.get("active", False)),
+                                x402support=bool(reg_file.get("x402Support", reg_file.get("x402support", False))),
+                                createdAt=a.get("createdAt"),
+                                updatedAt=a.get("updatedAt"),
+                                lastActivity=a.get("lastActivity"),
+                                agentURI=a.get("agentURI"),
+                                agentURIType=a.get("agentURIType"),
+                                feedbackCount=a.get("totalFeedback"),
+                                semanticScore=float(score_by_id.get(aid, 0.0)),
+                                averageValue=float(st.get("avg")) if st.get("avg") is not None else None,
+                                extras={},
+                            )
+                        )
+            except Exception:
+                continue
+
+        # Default keyword sorting: semanticScore desc, unless overridden.
+        sort_field = field if options.sort and len(options.sort) > 0 else "semanticScore"
+        sort_dir = direction if options.sort and len(options.sort) > 0 else "desc"
+
+        def sort_key(agent: AgentSummary):
+            v = getattr(agent, sort_field, None)
+            if v is None:
+                return 0
+            if sort_field == "name":
+                return (agent.name or "").lower()
+            try:
+                return float(v)
+            except Exception:
+                return 0
 
-    def _apply_filters(self, agents: List[Dict[str, Any]], params: SearchParams) -> List[Dict[str, Any]]:
-        """Apply search filters to agents."""
-        filtered = agents
-        
-        if params.chains is not None:
-            filtered = [a for a in filtered if a.get("chainId") in params.chains]
-        
-        if params.name is not None:
-            filtered = [a for a in filtered if params.name.lower() in a.get("name", "").lower()]
-        
-        if params.description is not None:
-            # This would use semantic search with embeddings
-            filtered = [a for a in filtered if params.description.lower() in a.get("description", "").lower()]
-        
-        if params.owners is not None:
-            filtered = [a for a in filtered if any(owner in params.owners for owner in a.get("owners", []))]
-        
-        if params.operators is not None:
-            filtered = [a for a in filtered if any(op in params.operators for op in a.get("operators", []))]
-        
-        if params.mcp is not None:
-            filtered = [a for a in filtered if a.get("mcp") == params.mcp]
-        
-        if params.a2a is not None:
-            filtered = [a for a in filtered if a.get("a2a") == params.a2a]
-        
-        if params.ens is not None:
-            filtered = [a for a in filtered if a.get("ens") and params.ens.lower() in a.get("ens", "").lower()]
-        
-        if params.did is not None:
-            filtered = [a for a in filtered if a.get("did") == params.did]
-        
-        if params.walletAddress is not None:
-            filtered = [a for a in filtered if a.get("walletAddress") == params.walletAddress]
-        
-        if params.supportedTrust is not None:
-            filtered = [a for a in filtered if any(trust in params.supportedTrust for trust in a.get("supportedTrusts", []))]
-        
-        if params.a2aSkills is not None:
-            filtered = [a for a in filtered if any(skill in params.a2aSkills for skill in a.get("a2aSkills", []))]
-        
-        if params.mcpTools is not None:
-            filtered = [a for a in filtered if any(tool in params.mcpTools for tool in a.get("mcpTools", []))]
-        
-        if params.mcpPrompts is not None:
-            filtered = [a for a in filtered if any(prompt in params.mcpPrompts for prompt in a.get("mcpPrompts", []))]
-        
-        if params.mcpResources is not None:
-            filtered = [a for a in filtered if any(resource in params.mcpResources for resource in a.get("mcpResources", []))]
-        
-        if params.active is not None:
-            filtered = [a for a in filtered if a.get("active") == params.active]
-        
-        if params.x402support is not None:
-            filtered = [a for a in filtered if a.get("x402support") == params.x402support]
-        
-        return filtered
+        fetched.sort(key=sort_key, reverse=(sort_dir == "desc"))
+        return fetched
 
-    def _apply_sorting(self, agents: List[AgentSummary], sort: List[str]) -> List[AgentSummary]:
-        """Apply sorting to agents."""
-        def sort_key(agent):
-            key_values = []
-            for sort_field in sort:
-                field, direction = sort_field.split(":", 1)
-                if hasattr(agent, field):
-                    value = getattr(agent, field)
-                    if direction == "desc":
-                        value = -value if isinstance(value, (int, float)) else value
-                    key_values.append(value)
-            return key_values
-        
-        return sorted(agents, key=sort_key)
+    # Pagination removed: legacy cursor-based multi-chain agent search deleted.
+
+    # Pagination removed: legacy cursor-based agent search helpers deleted.
 
     def get_feedback(
         self,
@@ -1116,8 +1212,6 @@ class AgentIndexer:
         minValue: Optional[float] = None,
         maxValue: Optional[float] = None,
         include_revoked: bool = False,
-        first: int = 100,
-        skip: int = 0,
         agents: Optional[List[AgentId]] = None,
     ) -> List[Feedback]:
         """Search feedback via subgraph.
@@ -1186,8 +1280,6 @@ class AgentIndexer:
                 minValue=minValue,
                 maxValue=maxValue,
                 include_revoked=include_revoked,
-                first=first,
-                skip=skip,
                 subgraph_client=subgraph_client,
             )
         
@@ -1208,8 +1300,6 @@ class AgentIndexer:
         minValue: Optional[float],
         maxValue: Optional[float],
         include_revoked: bool,
-        first: int,
-        skip: int,
         subgraph_client: Optional[Any] = None,
     ) -> List[Feedback]:
         """Search feedback using subgraph."""
@@ -1238,34 +1328,39 @@ class AgentIndexer:
             includeRevoked=include_revoked
         )
         
-        # Query subgraph
-        feedbacks_data = client.search_feedback(
-            params=params,
-            first=first,
-            skip=skip,
-            order_by="createdAt",
-            order_direction="desc"
-        )
-        
-        # Map to Feedback objects
         feedbacks = []
-        for fb_data in feedbacks_data:
-            # Parse agentId from feedback ID
-            feedback_id = fb_data['id']
-            parts = feedback_id.split(':')
-            if len(parts) >= 2:
-                agent_id_str = f"{parts[0]}:{parts[1]}"
-                client_addr = parts[2] if len(parts) > 2 else ""
-                feedback_idx = int(parts[3]) if len(parts) > 3 else 1
-            else:
-                agent_id_str = feedback_id
-                client_addr = ""
-                feedback_idx = 1
-            
-            feedback = self._map_subgraph_feedback_to_model(
-                fb_data, agent_id_str, client_addr, feedback_idx
+        batch = 1000
+        skip = 0
+        while True:
+            feedbacks_data = client.search_feedback(
+                params=params,
+                first=batch,
+                skip=skip,
+                order_by="createdAt",
+                order_direction="desc",
             )
-            feedbacks.append(feedback)
+
+            for fb_data in feedbacks_data:
+                # Parse agentId from feedback ID
+                feedback_id = fb_data['id']
+                parts = feedback_id.split(':')
+                if len(parts) >= 2:
+                    agent_id_str = f"{parts[0]}:{parts[1]}"
+                    client_addr = parts[2] if len(parts) > 2 else ""
+                    feedback_idx = int(parts[3]) if len(parts) > 3 else 1
+                else:
+                    agent_id_str = feedback_id
+                    client_addr = ""
+                    feedback_idx = 1
+
+                feedback = self._map_subgraph_feedback_to_model(
+                    fb_data, agent_id_str, client_addr, feedback_idx
+                )
+                feedbacks.append(feedback)
+
+            if len(feedbacks_data) < batch:
+                break
+            skip += batch
         
         return feedbacks
     
@@ -1320,15 +1415,12 @@ class AgentIndexer:
         since: Optional[Timestamp] = None,
         until: Optional[Timestamp] = None,
         sort: List[str] = None,
-        page_size: int = 100,
-        cursor: Optional[str] = None,
     ) -> Dict[str, Any]:
         """Get reputation summary for an agent."""
         # This would aggregate feedback data
         # For now, return empty result
         return {
             "groups": [],
-            "nextCursor": None
         }
 
     def get_reputation_map(
@@ -1591,7 +1683,7 @@ class AgentIndexer:
     def _apply_cross_chain_filters(
         self,
         agents: List[Dict[str, Any]],
-        params: SearchParams
+        params: SearchFilters
     ) -> List[Dict[str, Any]]:
         """
         Apply filters that couldn't be expressed in subgraph WHERE clause.
@@ -1656,7 +1748,7 @@ class AgentIndexer:
     def _deduplicate_agents_cross_chain(
         self,
         agents: List[Dict[str, Any]],
-        params: SearchParams
+        params: SearchFilters
     ) -> List[Dict[str, Any]]:
         """
         Deduplicate agents across chains (if requested).
@@ -1669,42 +1761,8 @@ class AgentIndexer:
         - Keep the first instance encountered
         - Add 'deployedOn' array with all chain IDs where this agent exists
         """
-        # Check if deduplication requested
-        if not params.deduplicate_cross_chain:
-            return agents
-
-        # Group agents by identity key
-        seen = {}
-        deduplicated = []
-
-        for agent in agents:
-            # Create identity key: (owner, name, description)
-            # This identifies "the same agent" across chains
-            owner = agent.get('owner', '').lower()
-            reg_file = agent.get('registrationFile', {})
-            name = reg_file.get('name', '')
-            description = reg_file.get('description', '')
-
-            identity_key = (owner, name, description)
-
-            if identity_key not in seen:
-                # First time seeing this agent
-                seen[identity_key] = agent
-
-                # Add deployedOn array
-                agent['deployedOn'] = [agent['chainId']]
-
-                deduplicated.append(agent)
-            else:
-                # Already seen this agent on another chain
-                # Add this chain to deployedOn array
-                seen[identity_key]['deployedOn'].append(agent['chainId'])
-
-        logger.info(
-            f"Deduplication: {len(agents)} agents → {len(deduplicated)} unique agents"
-        )
-
-        return deduplicated
+        # Deduplication across chains was part of an older API surface; the unified search does not deduplicate.
+        return agents
 
     def _sort_agents_cross_chain(
         self,
@@ -1764,55 +1822,7 @@ class AgentIndexer:
 
         return sorted(agents, key=get_sort_key, reverse=reverse)
 
-    def _parse_multi_chain_cursor(self, cursor: Optional[str]) -> Dict[int, int]:
-        """
-        Parse multi-chain cursor into per-chain offsets.
-
-        Cursor format (JSON):
-        {
-            "11155111": 50,  # Ethereum Sepolia offset
-            "84532": 30,     # Base Sepolia offset
-            "_global_offset": 100  # Total items returned so far
-        }
-
-        Returns:
-            Dict mapping chainId → offset (default 0)
-        """
-        if not cursor:
-            return {}
-
-        try:
-            cursor_data = json.loads(cursor)
-
-            # Validate format
-            if not isinstance(cursor_data, dict):
-                logger.warning(f"Invalid cursor format: {cursor}, using empty")
-                return {}
-
-            return cursor_data
-
-        except json.JSONDecodeError as e:
-            logger.warning(f"Failed to parse cursor: {e}, using empty")
-            return {}
-
-    def _create_multi_chain_cursor(
-        self,
-        global_offset: int,
-    ) -> str:
-        """
-        Create multi-chain cursor for next page.
-
-        Args:
-            global_offset: Total items returned so far
-
-        Returns:
-            JSON string cursor
-        """
-        cursor_data = {
-            "_global_offset": global_offset
-        }
-
-        return json.dumps(cursor_data)
+    # Pagination removed: multi-chain cursor helpers deleted.
 
     def _extract_order_by(self, sort: List[str]) -> str:
         """Extract order_by field from sort specification."""