WikipediaPageLoadTool

def content_search(self, query: str) -> Union[list[Document], str]:
    """
    Executes a Wikipedia search and returns page content plus metadata.

    Args:
        query (str): The search term to query Wikipedia.

    Returns:
        Union[list[Document], str]:
            - list[Document]: Documents with up to `truncate` characters of page text
              and metadata if pages are found.
            - str: Error message if the search fails or no pages are found.

    Notes:
        - Errors are caught internally and returned as strings.
        - If no matching pages have text content, returns
          "No good Wikipedia Search Result was found".
    """
    try:
        if self.verbose:
            print(f"INFO\t [{self.tool_name}] search query='{query[:MAX_QUERY_LENGTH]}' top_k={self.top_k}")
        search_results = self.wiki_cli.search(query[:MAX_QUERY_LENGTH], limit=self.top_k)
        docs: list[Document] = []
        for item in search_results:
            page = self.wiki_cli.get_page(item["title"])
            # Only process pages that exist and have text content.
            if page is not None and page.text:
                document = Document(
                    page_content=page.text[: self.truncate],
                    metadata={
                        "source": f"https://{self.language}.wikipedia.org/?curid={item['pageid']}",
                        "title": item["title"],
                        "pageid": str(item["pageid"]),
                        "timestamp": str(item["timestamp"]),
                        "wordcount": str(item["wordcount"]),
                        "size": str(item["size"]),
                    },
                )
                docs.append(document)
        if not docs:
            return "No good Wikipedia Search Result was found"
        return docs

    except Exception as e:
        return f"wikipedia search failed: {str(e)}"

def register_for_llm(self, agent: "ConversableAgent") -> None:
    """Registers the tool for use with a ConversableAgent's language model (LLM).

    This method registers the tool so that it can be invoked by the agent during
    interactions with the language model.

    Args:
        agent (ConversableAgent): The agent to which the tool will be registered.
    """
    if self._func_schema:
        agent.update_tool_signature(self._func_schema, is_remove=False)
    else:
        agent.register_for_llm()(self)

def register_for_execution(self, agent: "ConversableAgent") -> None:
    """Registers the tool for direct execution by a ConversableAgent.

    This method registers the tool so that it can be executed by the agent,
    typically outside of the context of an LLM interaction.

    Args:
        agent (ConversableAgent): The agent to which the tool will be registered.
    """
    agent.register_for_execution()(self)

def register_tool(self, agent: "ConversableAgent") -> None:
    """Register a tool to be both proposed and executed by an agent.

    Equivalent to calling both `register_for_llm` and `register_for_execution` with the same agent.

    Note: This will not make the agent recommend and execute the call in the one step. If the agent
    recommends the tool, it will need to be the next agent to speak in order to execute the tool.

    Args:
        agent (ConversableAgent): The agent to which the tool will be registered.
    """
    self.register_for_llm(agent)
    self.register_for_execution(agent)