简历工具服务器

def __init__(self, token: str):
    k = RSAKeyPair.generate()
    super().__init__(
        public_key=k.public_key, jwks_uri=None, issuer=None, audience=None
    )
    self.token = token

async def load_access_token(self, token: str) -> AccessToken | None:
    if token == self.token:
        return AccessToken(
            token=token,
            client_id="unknown",
            scopes=[],
            expires_at=None,  # No expiration for simplicity
        )
    return None

@classmethod
async def fetch_url(
    cls,
    url: str,
    user_agent: str,
    force_raw: bool = False,
) -> tuple[str, str]:
    """
    Fetch the URL and return the content in a form ready for the LLM, as well as a prefix string with status information.
    """
    from httpx import AsyncClient, HTTPError

    async with AsyncClient() as client:
        try:
            response = await client.get(
                url,
                follow_redirects=True,
                headers={"User-Agent": user_agent},
                timeout=30,
            )
        except HTTPError as e:
            raise McpError(
                ErrorData(
                    code=INTERNAL_ERROR, message=f"Failed to fetch {url}: {e!r}"
                )
            )
        if response.status_code >= 400:
            raise McpError(
                ErrorData(
                    code=INTERNAL_ERROR,
                    message=f"Failed to fetch {url} - status code {response.status_code}",
                )
            )

        page_raw = response.text

    content_type = response.headers.get("content-type", "")
    is_page_html = (
        "<html" in page_raw[:100] or "text/html" in content_type or not content_type
    )

    if is_page_html and not force_raw:
        return cls.extract_content_from_html(page_raw), ""

    return (
        page_raw,
        f"Content type {content_type} cannot be simplified to markdown, but here is the raw content:\n",
    )

@staticmethod
def extract_content_from_html(html: str) -> str:
    """Extract and convert HTML content to Markdown format.

    Args:
        html: Raw HTML content to process

    Returns:
        Simplified markdown version of the content
    """
    ret = readabilipy.simple_json.simple_json_from_html_string(
        html, use_readability=True
    )
    if not ret["content"]:
        return "<error>Page failed to be simplified from HTML</error>"
    content = markdownify.markdownify(
        ret["content"],
        heading_style=markdownify.ATX,
    )
    return content

TODO: Implement this function to:
1. Find and read your resume.
2. Convert the resume to markdown format.
3. Handle any errors gracefully.
4. Return the resume as markdown text.
"""
# TODO: Implement resume fetching logic
raise NotImplementedError("Resume tool not implemented")

content, prefix = await Fetch.fetch_url(url_str, Fetch.USER_AGENT, force_raw=raw)
original_length = len(content)
if start_index >= original_length:
    content = "<error>No more content available.</error>"
else:
    truncated_content = content[start_index : start_index + max_length]
    if not truncated_content:
        content = "<error>No more content available.</error>"
    else:
        content = truncated_content
        actual_content_length = len(truncated_content)
        remaining_content = original_length - (start_index + actual_content_length)
        # Only add the prompt to continue fetching if there is still remaining content
        if actual_content_length == max_length and remaining_content > 0:
            next_start = start_index + actual_content_length
            content += f"\n\n<error>Content truncated. Call the fetch tool with a start_index of {next_start} to get more content.</error>"
return [TextContent(type="text", text=f"{prefix}Contents of {url}:\n{content}")]

asyncio.run(main())