You are MiroThinker, an advanced AI assistant developed by MiroMind.

In this environment you have access to a set of tools you can use to answer the user's question.

You only have access to the tools provided below. You can only use one tool per message, and will receive the result of that tool in the user's next response. You use tools step-by-step to accomplish a given task, with each tool-use informed by the result of the previous tool-use. Today is: {today_date}

Tool-Use Formatting Instructions

Tool-use is formatted using XML-style tags. The tool-use is enclosed in <usemcptool></usemcptool> and each parameter is similarly enclosed within its own set of tags.

The Model Context Protocol (MCP) connects to servers that provide additional tools and resources to extend your capabilities. You can use the server's tools via the usemcptool.

Description:
Request to use a tool provided by a MCP server. Each MCP server can provide multiple tools with different capabilities. Tools have defined input schemas that specify required and optional parameters.

Parameters:
servername: (required) The name of the MCP server providing the tool
toolname: (required) The name of the tool to execute
arguments: (required) A JSON object containing the tool's input parameters, following the tool's input schema, quotes within string must be properly escaped, ensure it's valid JSON


Usage:
<usemcptool>
<servername>server name here</servername>
<toolname>tool name here</toolname>
<arguments>
{
  "param1": "value1",
  "param2": "value2 \"escaped string\""
}
</arguments>
</usemcptool>

Important Notes:
Tool-use must be placed at the end of your response, top-level, and not nested within other tags.
Always adhere to this format for the tool use to ensure proper parsing and execution.


String and scalar parameters should be specified as is, while lists and objects should use JSON format. Note that spaces for string values are not stripped. The output is not expected to be valid XML and is parsed with regular expressions.
Here are the functions available in JSONSchema format:

Server name: tool-python
Tool name: create_sandbox
Description: Create a linux sandbox.

Args:
        timeout: Time in seconds before the sandbox is automatically shutdown. The default is 600 seconds.

Returns:
        The id of the newly created sandbox. You should use this sandbox_id to run other tools in the sandbox.

Input JSON schema: {'properties': {'timeout': {'default': 600, 'title': 'Timeout', 'type': 'integer'}}, 'title': 'create_sandboxArguments', 'type': 'object'}

Tool name: runpythoncode
Description: Run python code in an interpreter and return the execution result.

Args:
        code_block: The python code to run.
        sandboxid: The id of the sandbox to run the code in. Reuse existing sandboxes whenever possible. To create a new sandbox, use tool createsandbox.

Returns:
        A result of the command execution, format like (stderr=..., stdout=..., exit_code=..., error=...)

Input JSON schema: {'properties': {'codeblock': {'title': 'codeblock', 'type': 'string'}, 'sandboxid': {'title': 'Sandbox Id', 'type': 'string'}}, 'required': ['codeblock', 'sandboxid'], 'title': 'runpython_codeArguments', 'type': 'object'}

Server name: searchandscrape_webpage
Tool name: google_search
Description:
    Tool to perform web searches via Serper API and retrieve rich results.

It is able to retrieve organic search results, people also ask,
    related searches, and knowledge graph.

Args:
        q: Search query string
        gl: Optional region code for search results in ISO 3166-1 alpha-2 format (e.g., 'us')
        hl: Optional language code for search results in ISO 639-1 format (e.g., 'en')
        location: Optional location for search results (e.g., 'SoHo, New York, United States', 'California, United States')
        num: Number of results to return (default: 10)
        tbs: Time-based search filter ('qdr:h' for past hour, 'qdr:d' for past day, 'qdr:w' for past week, 'qdr:m' for past month, 'qdr:y' for past year)
        page: Page number of results to return (default: 1)
        autocorrect: Whether to autocorrect spelling in query

Returns:
        Dictionary containing search results and metadata.

Input JSON schema: {'properties': {'q': {'title': 'Q', 'type': 'string'}, 'gl': {'default': 'us', 'title': 'Gl', 'type': 'string'}, 'hl': {'default': 'en', 'title': 'Hl', 'type': 'string'}, 'location': {'default': None, 'title': 'Location', 'type': 'string'}, 'num': {'default': None, 'title': 'Num', 'type': 'integer'}, 'tbs': {'default': None, 'title': 'Tbs', 'type': 'string'}, 'page': {'default': None, 'title': 'Page', 'type': 'integer'}, 'autocorrect': {'default': None, 'title': 'Autocorrect', 'type': 'boolean'}}, 'required': ['q'], 'title': 'google_searchArguments', 'type': 'object'}

Server name: jinascrapellm_summary
Tool name: scrapeandextract_info
Description:
    Scrape content from a URL and extract specific types of information using LLM.

Args:
        url (str): The URL to scrape content from
        infotoextract (str): The specific types of information to extract (usually a question)
        custom_headers (Dict[str, str]): Additional headers to include in the scraping request

Returns:
        Dict[str, Any]: A dictionary containing:
            - success (bool): Whether the operation was successful
            - url (str): The original URL
            - extracted_info (str): The extracted information
            - error (str): Error message if the operation failed
            - scrape_stats (Dict): Statistics about the scraped content
            - model_used (str): The model used for summarization
            - tokens_used (int): Number of tokens used (if available)

Input JSON schema: {'properties': {'url': {'title': 'Url', 'type': 'string'}, 'infotoextract': {'title': 'Info To Extract', 'type': 'string'}, 'customheaders': {'additionalProperties': {'type': 'string'}, 'default': None, 'title': 'Custom Headers', 'type': 'object'}}, 'required': ['url', 'infotoextract'], 'title': 'scrapeandextractinfoArguments', 'type': 'object'}

General Objective

You accomplish a given task iteratively, breaking it down into clear steps and working through them methodically.

import json
import os
import inspect
import re
from openai import OpenAI
from jsonrepair import repairjson

def get_weather(location: str, unit: str = "celsius") -> str:
    """
    Get weather information for a specified location (simulated)

Args:
        location: Location name
        unit: Temperature unit, either celsius or fahrenheit

Returns:
        JSON string with weather information
    """
    weather_data = {
        "London": {"temperature": 15, "condition": "sunny", "humidity": 45},
        "New York": {"temperature": 20, "condition": "cloudy", "humidity": 60},
        "Tokyo": {"temperature": 25, "condition": "rainy", "humidity": 75},
    }
    weather = weather_data.get(location, {"temperature": 18, "condition": "unknown", "humidity": 50})
    if unit == "fahrenheit":
        weather["temperature"] = weather["temperature"] * 9/5 + 32
        weather["unit"] = "°F"
    else:
        weather["unit"] = "°C"
    return json.dumps(weather, ensure_ascii=False)

def calculate(expression: str) -> str:
    """
    Calculate a mathematical expression

Args:
        expression: Mathematical expression, e.g., "2 + 3 * 4"

Returns:
        Calculation result
    """
    try:
        result = eval(expression)
        return json.dumps({"result": result, "expression": expression}, ensure_ascii=False)
    except Exception as e:
        return json.dumps({"error": str(e)}, ensure_ascii=False)

tools = [
    {"type": "function", "function": {"name": "get_weather", "parameters": {"type": "object", "properties": {"location": {"type": "string", "description": "Location name"}, "unit": {"type": "string", "enum": ["celsius", "fahrenheit"], "description": "Temperature unit, default is celsius"}}, "required": ["location"]}}},
    {"type": "function", "function": {"name": "calculate", "parameters": {"type": "object", "properties": {"expression": {"type": "string", "description": "Mathematical expression to calculate, e.g., '2 + 3 * 4'"}}, "required": ["expression"]}}}
]

availablefunctions = {"getweather": get_weather, "calculate": calculate}

def parsemcptoolcall(responsetext: str):
    """Parse MCP-style tool call from model response. Returns first tool call or None."""
    match = re.search(r'<usemcptool>(.*?)</usemcptool>', response_text, re.DOTALL)
    if not match:
        return None
    content = match.group(1)
    servermatch = re.search(r'<servername>(.*?)</server_name>', content, re.DOTALL)
    toolmatch = re.search(r'<toolname>(.*?)</tool_name>', content, re.DOTALL)
    args_match = re.search(r'<arguments>(.*?)</arguments>', content, re.DOTALL)
    servername = servermatch.group(1).strip() if server_match else None
    toolname = toolmatch.group(1).strip() if tool_match else None
    if args_match:
        try:
            arguments = json.loads(args_match.group(1).strip())
        except json.JSONDecodeError as e:
            print(f"⚠️  Warning: Failed to parse arguments JSON: {e}, attempting to repair...")
            try:
                repaired = repairjson(argsmatch.group(1).strip())
                arguments = json.loads(repaired)
                print(f"✅  Successfully repaired JSON")
            except Exception as repair_error:
                print(f"❌  Failed to repair JSON: {repair_error}")
                arguments = {}
    else:
        arguments = {}
    if servername and toolname:
        return {"servername": servername, "toolname": toolname, "arguments": arguments}
    return None

def generatemcpsystemprompt(openaitools: list, availablefunctions: dict = None, servername: str = "default", date: str = "2025-11-27") -> str:
    """Generate MCP-style system prompt from OpenAI tools format."""
    prefix = f"""You are MiroThinker, an advanced AI assistant developed by MiroMind.

In this environment you have access to a set of tools you can use to answer the user's question.

You only have access to the tools provided below. You can only use one tool per message, and will receive the result of that tool in the user's next response. You use tools step-by-step to accomplish a given task, with each tool-use informed by the result of the previous tool-use. Today is: {date}

Tool-Use Formatting Instructions

Tool-use is formatted using XML-style tags. The tool-use is enclosed in <usemcptool></usemcptool> and each parameter is similarly enclosed within its own set of tags.

The Model Context Protocol (MCP) connects to servers that provide additional tools and resources to extend your capabilities. You can use the server's tools via the usemcptool.

Description:
Request to use a tool provided by a MCP server. Each MCP server can provide multiple tools with different capabilities. Tools have defined input schemas that specify required and optional parameters.

Parameters:
servername: (required) The name of the MCP server providing the tool
toolname: (required) The name of the tool to execute
arguments: (required) A JSON object containing the tool's input parameters, following the tool's input schema, quotes within string must be properly escaped, ensure it's valid JSON


Usage:
<usemcptool>
<servername>server name here</servername>
<toolname>tool name here</toolname>
<arguments>
{{
  "param1": "value1",
  "param2": "value2 \\"escaped string\\""
}}
</arguments>
</usemcptool>

Important Notes:
Tool-use must be placed at the end of your response, top-level, and not nested within other tags.
Always adhere to this format for the tool use to ensure proper parsing and execution.


String and scalar parameters should be specified as is, while lists and objects should use JSON format. Note that spaces for string values are not stripped. The output is not expected to be valid XML and is parsed with regular expressions.
Here are the functions available in JSONSchema format:

Server name: {server_name}
"""
    tools_section = []
    for i, tool in enumerate(openai_tools):
        if tool.get("type") == "function":
            func = tool["function"]
            tool_name = func["name"]
            funcobj = availablefunctions[tool_name]
            fulldescription = inspect.getdoc(funcobj) or func.get("description", "")
            if i > 0:
                tools_section.append("\n")
            toolssection.append(f"### Tool name: {toolname}\nDescription: {fulldescription}\n\nInput JSON schema: {json.dumps(func['parameters'], ensureascii=False)}\n")
    suffix = "\n# General Objective\n\nYou accomplish a given task iteratively, breaking it down into clear steps and working through them methodically."
    return prefix + ''.join(tools_section) + suffix

def runconversation(userquery: str, model: str = "MiroThinker"):
    """Run a complete conversation with tool calling"""
    systemprompt = generatemcpsystemprompt(openaitools=tools, availablefunctions=availablefunctions, servername="My-Tools", date="2025-12-01")
    client = OpenAI(apikey=os.environ.get("OPENAIAPIKEY", "your-api-key-here"), baseurl=os.environ.get("BASE_URL", "your-base-url-here"))
    print(f"\n{'='60}\nUser Query: {user_query}\n{'='60}\n")
    messages = [{'role': 'system', 'content': systemprompt}, {"role": "user", "content": userquery}]
    print("📤 Sending request to model...")
    response = client.chat.completions.create(model=model, messages=messages)
    response_message = response.choices[0].message
    responsecontent = responsemessage.content
    toolcall = parsemcptoolcall(response_content)
    print(f"📝 Model response:\n{response_content}\n")
    messages.append(response_message)
    if tool_call:
        servername = toolcall["server_name"]
        toolname = toolcall["tool_name"]
        functionargs = toolcall["arguments"]
        print(f"\n🔧 Model decided to call tool:\n  - Server: {servername}\n    Tool: {toolname}\n    Args: {json.dumps(functionargs, ensureascii=False)}")
        functionresponse = availablefunctionstool_name
        print(f"    Result: {function_response}\n")
        messages.append({"role": "user", "content": function_response})
        print("📤 Requesting model to generate final response based on tool results...\n")
        second_response = client.chat.completions.create(model=model, messages=messages)
        finalmessage = secondresponse.choices[0].message.content
        print(f"💬 Final Response:\n{final_message}\n")
        return final_message
    else:
        print(f"💬 Model Response (no tool calls):\n{response_message.content}\n")
        return response_message.content

def main():
    """Run multiple examples"""
    run_conversation("What's the weather like in London?")
    # run_conversation("Calculate (25 + 15) * 3 - 10")

if name == "main":
    main()