From acec2f133186dbb9e12ab13e2295509bb78ed6b4 Mon Sep 17 00:00:00 2001 From: Ransford Okpoti Date: Wed, 22 Oct 2025 12:07:03 +0000 Subject: [PATCH 1/3] mathxpert with tools integration - Provides the freedom to explore all the models available from the providers - Handling of multiple tools calling simultaneously - Efficiently run tools in parallel - Tool response, i.e. the `plot_function`, that does not require going back to the LLM - Uses the inbuilt logging package to allow the control of the verbosity of the logging, set to a higher level, like INFO, to reduce the noisy output --- ...ranskills-week2-mathxpert-with-tools.ipynb | 1119 +++++++++++++++++ 1 file changed, 1119 insertions(+) create mode 100644 week2/community-contributions/ranskills-week2-mathxpert-with-tools.ipynb diff --git a/week2/community-contributions/ranskills-week2-mathxpert-with-tools.ipynb b/week2/community-contributions/ranskills-week2-mathxpert-with-tools.ipynb new file mode 100644 index 0000000..b058bf3 --- /dev/null +++ b/week2/community-contributions/ranskills-week2-mathxpert-with-tools.ipynb @@ -0,0 +1,1119 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "fe12c203-e6a6-452c-a655-afb8a03a4ff5", + "metadata": {}, + "source": [ + "# Week 2 exercise\n", + "\n", + "## MathXpert with tools integration\n", + "\n", + "- Provides the freedom to explore all the models available from the providers\n", + "- Handling of multiple tools calling simultaneously\n", + "- Efficiently run tools in parallel\n", + "- Tool response, i.e. the `plot_function`, that does not require going back to the LLM\n", + "- Uses the inbuilt logging package to allow the control of the verbosity of the logging, set to a higher level, like INFO, to reduce the noisy output" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "c1070317-3ed9-4659-abe3-828943230e03", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import os\n", + "import json\n", + "import logging\n", + "from enum import StrEnum\n", + "from getpass import getpass\n", + "from types import SimpleNamespace\n", + "from typing import Callable\n", + "\n", + "from dotenv import load_dotenv\n", + "from openai import OpenAI\n", + "import ipywidgets as widgets\n", + "from IPython.display import display, clear_output, Latex\n", + "import gradio as gr\n", + "\n", + "load_dotenv(override=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "99901b80", + "metadata": {}, + "outputs": [], + "source": [ + "logging.basicConfig(level=logging.WARNING)\n", + "\n", + "logger = logging.getLogger('mathxpert')\n", + "logger.setLevel(logging.DEBUG)" + ] + }, + { + "cell_type": "markdown", + "id": "f169118a-645e-44e1-9a98-4f561adfbb08", + "metadata": {}, + "source": [ + "## Free Cloud Providers\n", + "\n", + "Grab your free API Keys from these generous sites:\n", + "\n", + "- https://openrouter.ai/\n", + "- https://ollama.com/\n", + "\n", + ">**NOTE**: If you do not have a key for any provider, simply press ENTER to move on" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "4a456906-915a-4bfd-bb9d-57e505c5093f", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:mathxpert:✅ OLLAMA_API_KEY provided\n", + "INFO:mathxpert:✅ OPENROUTER_API_KEY provided\n" + ] + } + ], + "source": [ + "class Provider(StrEnum):\n", + " OLLAMA = 'Ollama'\n", + " OPENROUTER = 'OpenRouter'\n", + "\n", + "clients: dict[Provider, OpenAI] = {}\n", + "models: dict[Provider, list[str]] = {\n", + " Provider.OLLAMA: [],\n", + " Provider.OPENROUTER: [],\n", + "}\n", + "\n", + "DEFAULT_PROVIDER = Provider.OLLAMA\n", + "\n", + "selection_state: dict[Provider, str | None] = {\n", + " Provider.OLLAMA: 'gpt-oss:20b',\n", + " Provider.OPENROUTER: 'openai/gpt-oss-20b:free',\n", + "}\n", + "\n", + "def get_secret_in_google_colab(env_name: str) -> str:\n", + " try:\n", + " from google.colab import userdata\n", + " return userdata.get(env_name)\n", + " except Exception:\n", + " return ''\n", + " \n", + "\n", + "def get_secret(env_name: str) -> str:\n", + " '''Gets the value from the environment(s), otherwise ask the user for it if not set'''\n", + " key = os.environ.get(env_name) or get_secret_in_google_colab(env_name)\n", + "\n", + " if not key:\n", + " key = getpass(f'Enter {env_name}:').strip()\n", + "\n", + " if key:\n", + " logger.info(f'✅ {env_name} provided')\n", + " else:\n", + " logger.warning(f'❌ {env_name} not provided')\n", + " return key.strip()\n", + "\n", + "\n", + "if api_key := get_secret('OLLAMA_API_KEY'):\n", + " clients[Provider.OLLAMA] = OpenAI(api_key=api_key, base_url='https://ollama.com/v1')\n", + "\n", + "if api_key := get_secret('OPENROUTER_API_KEY'):\n", + " clients[Provider.OPENROUTER] = OpenAI(api_key=api_key, base_url='https://openrouter.ai/api/v1')\n", + "\n", + "available_providers = [str(p) for p in clients.keys()]" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "aae1579b-7a02-459d-81c6-0f775d2a1410", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "DEBUG:mathxpert:Pick Ollama from ['Ollama', 'OpenRouter']\n", + "DEBUG:mathxpert:Pick gpt-oss:20b from ['glm-4.6', 'kimi-k2:1t', 'qwen3-coder:480b', 'deepseek-v3.1:671b', 'gpt-oss:120b', 'gpt-oss:20b', 'qwen3-vl:235b']\n", + "INFO:mathxpert:ℹ️ Provider: Ollama Model: gpt-oss:20b, Client: \n" + ] + } + ], + "source": [ + "selected_provider, selected_model, client = '', '', None\n", + "\n", + "\n", + "def get_desired_value_or_first_item(desire, options) -> str | None:\n", + " logger.debug(f'Pick {desire} from {options}')\n", + " selected = desire if desire in options else None\n", + " if selected:\n", + " return selected\n", + "\n", + " return options[0] if options else None\n", + " \n", + "try:\n", + " selected_provider = get_desired_value_or_first_item(DEFAULT_PROVIDER, available_providers)\n", + " client = clients.get(selected_provider)\n", + "except Exception:\n", + " logger.warning(f'❌ no provider configured and everything else from here will FAIL 🤦, I know you know this already.')\n", + "\n", + "def load_models_if_needed(client: OpenAI, selected_provider):\n", + " global selected_model, models\n", + "\n", + " if client and not models.get(selected_provider):\n", + " logging.info(f'📡 Fetching {selected_provider} models...')\n", + " \n", + " models[selected_provider] = [model.id for model in client.models.list()]\n", + " selected_model = get_desired_value_or_first_item(\n", + " selection_state[selected_provider], \n", + " models[selected_provider],\n", + " )\n", + "\n", + "load_models_if_needed(client, selected_provider)\n", + "\n", + "logger.info(f'ℹ️ Provider: {selected_provider} Model: {selected_model}, Client: {client}')" + ] + }, + { + "cell_type": "markdown", + "id": "e04675c2-1b81-4187-868c-c7112cd77e37", + "metadata": {}, + "source": [ + "## Prompt" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "a8d7923c-5f28-4c30-8556-342d7c8497c1", + "metadata": {}, + "outputs": [], + "source": [ + "def get_messages(question: str) -> list[dict[str, str]]:\n", + " \"\"\"Generate messages for the chat models.\"\"\"\n", + "\n", + " system_prompt = r'''\n", + " You are MathXpert, an expert Mathematician who makes math fun to learn by relating concepts to real \n", + " practical usage to whip up the interest in learners.\n", + " \n", + " Explain step-by-step thoroughly how to solve a math problem. \n", + " - ALWAYS use `$$...$$` for mathematical expressions.\n", + " - NEVER use square brackets `[...]` to delimit math.\n", + " - Example: Instead of \"[x = 2]\", write \"$$x = 2$$\".\n", + " - You may use `\\\\[4pt]` inside matrices for spacing.\n", + " '''\n", + "\n", + " return [\n", + " {'role': 'system', 'content': system_prompt },\n", + " {'role': 'user', 'content': question},\n", + " ]" + ] + }, + { + "cell_type": "markdown", + "id": "caa51866-f433-4b9a-ab20-fff5fc3b7d63", + "metadata": {}, + "source": [ + "## Tools" + ] + }, + { + "cell_type": "markdown", + "id": "a24c659a-5937-43b1-bb95-c0342f2786a9", + "metadata": {}, + "source": [ + "### Tools Definitions" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "3f302f47-9a67-4410-ba16-56fa5a731c66", + "metadata": {}, + "outputs": [], + "source": [ + "from pydantic import BaseModel, Field\n", + "from openai.types.shared_params import FunctionDefinition\n", + "import sympy as sp\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import io\n", + "import base64\n", + "import random\n", + "\n", + "class ToolInput(BaseModel):\n", + " pass\n", + " \n", + "class GetCurrentDateTimeInput(ToolInput):\n", + " timezone: str = Field(default=\"UTC\", description=\"Timezone name, e.g., 'UTC' or 'Africa/Accra'\")\n", + "\n", + "\n", + "def get_current_datetime(req: GetCurrentDateTimeInput):\n", + " '''Returns the current date and time in the specified timezone.'''\n", + " from zoneinfo import ZoneInfo\n", + "\n", + " try:\n", + " from datetime import datetime\n", + " tz = ZoneInfo(req.timezone)\n", + " dt = datetime.now(tz)\n", + " return {\n", + " \"date\": dt.strftime(\"%Y-%m-%d\"),\n", + " \"time\": dt.strftime(\"%H:%M:%S %Z\"),\n", + " } \n", + " except:\n", + " return {\"error\": f\"Invalid timezone: {req.timezone}\"}\n", + "\n", + "\n", + "class GetTemperatureInput(ToolInput):\n", + " pass\n", + "\n", + "def get_temperature(req: GetTemperatureInput) -> float:\n", + " '''Returns the current temperature in degree celsius'''\n", + " return random.randint(-30, 70)\n", + "\n", + "\n", + "class PlotFunctionInput(ToolInput):\n", + " expression: str = Field(description=\"Mathematical expression to plot, e.g., 'sin(x)'\")\n", + " x_min: float = Field(default=-10, description=\"Minimum x value\")\n", + " x_max: float = Field(default=10, description=\"Maximum x value\")\n", + "\n", + "\n", + "def plot_function(req: PlotFunctionInput) -> dict[str, any]:\n", + " '''Plots a mathematical function and returns image data.'''\n", + " try:\n", + " x = sp.symbols('x')\n", + " expr = sp.sympify(req.expression)\n", + " lambdified = sp.lambdify(x, expr, 'numpy')\n", + " \n", + " x_vals = np.linspace(req.x_min, req.x_max, 400)\n", + " y_vals = lambdified(x_vals)\n", + " \n", + " plt.figure(figsize=(10, 6))\n", + " plt.plot(x_vals, y_vals, 'b-', linewidth=2)\n", + " plt.grid(True, alpha=0.3)\n", + " plt.title(f\"Plot of ${sp.latex(expr)}$\", fontsize=14)\n", + " plt.xlabel('x', fontsize=12)\n", + " plt.ylabel('f(x)', fontsize=12)\n", + " \n", + "\n", + " buf = io.BytesIO()\n", + " plt.savefig(buf, format='png', dpi=100, bbox_inches='tight')\n", + " plt.close()\n", + " buf.seek(0)\n", + " img_str = base64.b64encode(buf.read()).decode()\n", + " \n", + " return {\n", + " \"plot_image\": f\"data:image/png;base64,{img_str}\",\n", + " \"expression\": req.expression,\n", + " \"x_range\": [req.x_min, req.x_max]\n", + " }\n", + " except Exception as e:\n", + " return {\"error\": f\"Could not plot function: {str(e)}\"}\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "fae3ef71-f6cd-4894-ae55-9f4f8dd2a1cd", + "metadata": {}, + "source": [ + "### Tools registration & execution" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "4f18bc9f-f8d1-4208-a3d7-e4e911034572", + "metadata": {}, + "outputs": [], + "source": [ + "from concurrent.futures import ThreadPoolExecutor\n", + "\n", + "class ToolManager:\n", + " def __init__(self):\n", + " self._tools = []\n", + " self._tools_map: dict[str, tuple[Callable, ToolInput]] = {}\n", + "\n", + " def register_tool[T: ToolInput](self, fn: Callable, fn_input: T):\n", + " self._tools.append({\n", + " \"type\": \"function\",\n", + " \"function\": FunctionDefinition(\n", + " name=fn.__name__,\n", + " description=fn.__doc__,\n", + " parameters=fn_input.model_json_schema() if fn_input else None,\n", + " )\n", + " })\n", + " \n", + " self._tools_map[fn.__name__] = (fn, fn_input)\n", + "\n", + " def _run_single_tool(self, tool_call) -> dict[str, str] | None:\n", + " if not tool_call.id:\n", + " return None\n", + " \n", + " fn, fn_input = self._tools_map.get(tool_call.function.name)\n", + " args = tool_call.function.arguments\n", + " try:\n", + " if args:\n", + " result = fn(fn_input(**json.loads(args))) if fn_input else fn()\n", + " else:\n", + " result = fn(fn_input()) if fn_input else fn()\n", + " \n", + " logger.debug(f'Tool run result: {result}')\n", + " \n", + " return {\n", + " 'role': 'tool',\n", + " 'tool_call_id': tool_call.id,\n", + " 'content': json.dumps(result),\n", + " }\n", + " except Exception as e:\n", + " logger.error(f'Tool execution failed: {e}', extra={'name': tool_call.function.name})\n", + " return None\n", + "\n", + " def run(self, tool_calls) -> list[dict[str, str]]:\n", + " if not tool_calls:\n", + " return []\n", + "\n", + " logger.debug(tool_calls)\n", + "\n", + " tool_messages = []\n", + " \n", + " with ThreadPoolExecutor() as executor:\n", + " futures = [executor.submit(self._run_single_tool, tool_call) for tool_call in tool_calls]\n", + " \n", + " for future in futures:\n", + " result = future.result()\n", + " if result:\n", + " tool_messages.append(result)\n", + " \n", + " return tool_messages\n", + "\n", + " @property\n", + " def tools(self) -> list[any]:\n", + " return self._tools\n", + "\n", + " def dump_tools(self) -> str:\n", + " return json.dumps(self._tools, indent=True)\n", + "\n", + " \n", + "tool_manager = ToolManager()\n", + "\n", + "tool_manager.register_tool(get_current_datetime, GetCurrentDateTimeInput)\n", + "tool_manager.register_tool(get_temperature, GetTemperatureInput)\n", + "tool_manager.register_tool(plot_function, PlotFunctionInput)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "9b2e0634-de5d-45f6-a8d4-569e04d14a00", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "DEBUG:mathxpert:[\n", + " {\n", + " \"type\": \"function\",\n", + " \"function\": {\n", + " \"name\": \"get_current_datetime\",\n", + " \"description\": \"Returns the current date and time in the specified timezone.\",\n", + " \"parameters\": {\n", + " \"properties\": {\n", + " \"timezone\": {\n", + " \"default\": \"UTC\",\n", + " \"description\": \"Timezone name, e.g., 'UTC' or 'Africa/Accra'\",\n", + " \"title\": \"Timezone\",\n", + " \"type\": \"string\"\n", + " }\n", + " },\n", + " \"title\": \"GetCurrentDateTimeInput\",\n", + " \"type\": \"object\"\n", + " }\n", + " }\n", + " },\n", + " {\n", + " \"type\": \"function\",\n", + " \"function\": {\n", + " \"name\": \"get_temperature\",\n", + " \"description\": \"Returns the current temperature in degree celsius\",\n", + " \"parameters\": {\n", + " \"properties\": {},\n", + " \"title\": \"GetTemperatureInput\",\n", + " \"type\": \"object\"\n", + " }\n", + " }\n", + " },\n", + " {\n", + " \"type\": \"function\",\n", + " \"function\": {\n", + " \"name\": \"plot_function\",\n", + " \"description\": \"Plots a mathematical function and returns image data.\",\n", + " \"parameters\": {\n", + " \"properties\": {\n", + " \"expression\": {\n", + " \"description\": \"Mathematical expression to plot, e.g., 'sin(x)'\",\n", + " \"title\": \"Expression\",\n", + " \"type\": \"string\"\n", + " },\n", + " \"x_min\": {\n", + " \"default\": -10,\n", + " \"description\": \"Minimum x value\",\n", + " \"title\": \"X Min\",\n", + " \"type\": \"number\"\n", + " },\n", + " \"x_max\": {\n", + " \"default\": 10,\n", + " \"description\": \"Maximum x value\",\n", + " \"title\": \"X Max\",\n", + " \"type\": \"number\"\n", + " }\n", + " },\n", + " \"required\": [\n", + " \"expression\"\n", + " ],\n", + " \"title\": \"PlotFunctionInput\",\n", + " \"type\": \"object\"\n", + " }\n", + " }\n", + " }\n", + "]\n" + ] + } + ], + "source": [ + "logger.debug(tool_manager.dump_tools())" + ] + }, + { + "cell_type": "markdown", + "id": "bde4cd2a-b681-4b78-917c-d970c264b151", + "metadata": {}, + "source": [ + "## Interaction with LLM" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "8f7c8ea8-4082-4ad0-8751-3301adcf6538", + "metadata": {}, + "outputs": [], + "source": [ + "# handle = display(None, display_id=True)\n", + "\n", + "def ask(client: OpenAI | None, model: str, question: str, max_tool_turns=5):\n", + " if client is None:\n", + " logger.warning('You should have provided the API Keys you know. Fix 🔧 this and try again ♻️.')\n", + " return\n", + "\n", + " try:\n", + " logger.debug(f'# Tools: {len(tool_manager.tools)}')\n", + "\n", + " messages = get_messages(question=question)\n", + "\n", + " for turn in range(max_tool_turns):\n", + " logger.debug(f'Turn: {turn}')\n", + " response = client.chat.completions.create(\n", + " model=model,\n", + " messages=messages,\n", + " tools=tool_manager.tools,\n", + " stream=True,\n", + " )\n", + " \n", + " current_message = {}\n", + " tool_calls_accumulator = {}\n", + " \n", + " output = ''\n", + " call_id = None\n", + " \n", + " for chunk in response:\n", + " delta = chunk.choices[0].delta\n", + "\n", + " logger.debug(f' ✨ {chunk.choices[0]}')\n", + " if content := delta.content:\n", + " output += content\n", + " yield output\n", + "\n", + " if tool_calls := delta.tool_calls:\n", + " for tool_chunk in tool_calls:\n", + " print('x' * 50)\n", + " print(tool_chunk)\n", + "\n", + " if tool_chunk.id and call_id != tool_chunk.id:\n", + " call_id = tool_chunk.id\n", + "\n", + " print(f'Call ID: {call_id}')\n", + " # Streams of arguments don't come with the call id\n", + " # if not call_id:\n", + " # continue\n", + "\n", + " if call_id not in tool_calls_accumulator:\n", + " # tool_calls_accumulator[call_id] = {\n", + " # 'id': call_id,\n", + " # 'function': {'name': '', 'arguments': ''}\n", + " # }\n", + " tool_calls_accumulator[call_id] = SimpleNamespace(\n", + " id=call_id,\n", + " function=SimpleNamespace(name='', arguments='')\n", + " )\n", + "\n", + " if tool_chunk.function.name:\n", + " tool_calls_accumulator[call_id].function.name += tool_chunk.function.name\n", + " \n", + " if tool_chunk.function.arguments:\n", + " tool_calls_accumulator[call_id].function.arguments += tool_chunk.function.arguments\n", + "\n", + " if finish_reason := chunk.choices[0].finish_reason:\n", + " logger.debug('🧠 LLM interaction ended. Reason: {finish_reason}')\n", + "\n", + " final_tool_calls = list(tool_calls_accumulator.values())\n", + " if final_tool_calls:\n", + " logger.debug(f'Final tools to call {final_tool_calls}')\n", + "\n", + " tool_call_message = {\n", + " 'role': 'assistant',\n", + " 'content': None,\n", + " 'tool_calls': json.loads(json.dumps(final_tool_calls, default=lambda o: o.__dict__))\n", + " }\n", + "\n", + " messages.append(tool_call_message)\n", + " tool_messages = tool_manager.run(final_tool_calls)\n", + "\n", + " if tool_messages:\n", + " for tool_msg in tool_messages:\n", + " try:\n", + " data = json.loads(tool_msg['content'])\n", + " if 'plot_image' in data:\n", + " logger.debug('We have a plot')\n", + " yield f''\n", + " return\n", + " except:\n", + " pass\n", + " messages.extend(tool_messages)\n", + " else:\n", + " return\n", + " \n", + " except Exception as e:\n", + " logger.error(f'🔥 An error occurred during the interaction with the LLM: {e}', exc_info=True)\n", + " return str(e)" + ] + }, + { + "cell_type": "markdown", + "id": "eda786d3-5add-4bd1-804d-13eff60c3d1a", + "metadata": {}, + "source": [ + "### Verify streaming behaviour" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "09bc9a11-adb4-4a9c-9c77-73b2b5a665cf", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "DEBUG:mathxpert:# Tools: 3\n", + "DEBUG:mathxpert:Turn: 0\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role='assistant', tool_calls=None), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content='The'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' user'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' wants'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' a'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' plot'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' of'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' y'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' ='), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' x'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content='^'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content='2'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content='.'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' We'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' need'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' to'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' call'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' plot'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content='_function'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' via'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' tools'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content='.'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' So'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' use'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' the'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' function'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' with'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' expression'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' \"'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content='x'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content='**'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content='2'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content='\".'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' Probably'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' set'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' range'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' default'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content='.'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' Then'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' return'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' an'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' image'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content='?'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' We'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' just'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' return'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' the'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' tool'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' output'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content='.\\n\\n'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content='User'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=\"'s\"), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' message'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' is'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' \"'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content='Plot'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' a'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' graph'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' of'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' y'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' ='), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' x'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content='**'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content='2'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content='\".'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' So'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' we'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' provide'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' image'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content='.'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' Probably'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' just'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' respond'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' with'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' the'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' call'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content='.'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=[ChoiceDeltaToolCall(index=0, id='call_gUaf9cCr8Mn2s5zdix8L3ij2', function=ChoiceDeltaToolCallFunction(arguments=None, name='plot_function'), type='function')]), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=[ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='{\"', name=None), type='function')]), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=[ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='expression', name=None), type='function')]), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=[ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='\":\"', name=None), type='function')]), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=[ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='x', name=None), type='function')]), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=[ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='**', name=None), type='function')]), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=[ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='2', name=None), type='function')]), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=[ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='\"}', name=None), type='function')]), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None), finish_reason='tool_calls', index=0, logprobs=None)\n", + "DEBUG:mathxpert:🧠 LLM interaction ended. Reason: {finish_reason}\n", + "DEBUG:mathxpert:Final tools to call [namespace(id='call_gUaf9cCr8Mn2s5zdix8L3ij2', function=namespace(name='plot_function', arguments='{\"expression\":\"x**2\"}'))]\n", + "DEBUG:mathxpert:[namespace(id='call_gUaf9cCr8Mn2s5zdix8L3ij2', function=namespace(name='plot_function', arguments='{\"expression\":\"x**2\"}'))]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n", + "ChoiceDeltaToolCall(index=0, id='call_gUaf9cCr8Mn2s5zdix8L3ij2', function=ChoiceDeltaToolCallFunction(arguments=None, name='plot_function'), type='function')\n", + "Call ID: call_gUaf9cCr8Mn2s5zdix8L3ij2\n", + "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n", + "ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='{\"', name=None), type='function')\n", + "Call ID: call_gUaf9cCr8Mn2s5zdix8L3ij2\n", + "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n", + "ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='expression', name=None), type='function')\n", + "Call ID: call_gUaf9cCr8Mn2s5zdix8L3ij2\n", + "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n", + "ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='\":\"', name=None), type='function')\n", + "Call ID: call_gUaf9cCr8Mn2s5zdix8L3ij2\n", + "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n", + "ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='x', name=None), type='function')\n", + "Call ID: call_gUaf9cCr8Mn2s5zdix8L3ij2\n", + "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n", + "ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='**', name=None), type='function')\n", + "Call ID: call_gUaf9cCr8Mn2s5zdix8L3ij2\n", + "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n", + "ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='2', name=None), type='function')\n", + "Call ID: call_gUaf9cCr8Mn2s5zdix8L3ij2\n", + "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n", + "ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='\"}', name=None), type='function')\n", + "Call ID: call_gUaf9cCr8Mn2s5zdix8L3ij2\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "DEBUG:mathxpert:Tool run result: {'plot_image': 'data:image/png;base64,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', 'expression': 'x**2', 'x_range': [-10, 10]}\n", + "DEBUG:mathxpert:We have a plot\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "# print(selected_provider, selected_model)\n", + "# print(client)\n", + "# for o in ask(client, selected_model, 'What is the time?'):\n", + "# for o in ask(client, selected_model, 'What is the temperature?'):\n", + "# for o in ask(client, selected_model, 'What is the time and the temperature?'):\n", + "# for o in ask(client, selected_model, 'Plot a for the expression sin(x)'):\n", + "for o in ask(client, selected_model, 'Plot a graph of y = x**2'):\n", + " print(o)" + ] + }, + { + "cell_type": "markdown", + "id": "27230463", + "metadata": {}, + "source": [ + "## Build Gradio UI" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "50fc3577", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "DEBUG:mathxpert:Pick Ollama from ['Ollama', 'OpenRouter']\n", + "DEBUG:mathxpert:Pick gpt-oss:20b from ['glm-4.6', 'kimi-k2:1t', 'qwen3-coder:480b', 'deepseek-v3.1:671b', 'gpt-oss:120b', 'gpt-oss:20b', 'qwen3-vl:235b']\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "* Running on local URL: http://127.0.0.1:7860\n", + "* To create a public link, set `share=True` in `launch()`.\n" + ] + }, + { + "data": { + "text/html": [ + "
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "DEBUG:mathxpert:# Tools: 3\n", + "DEBUG:mathxpert:Turn: 0\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role='assistant', tool_calls=None), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content='User'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' wants'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' to'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' plot'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' function'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' x'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content='**'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content='2'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' -'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' '), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content='3'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content='x'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content='.'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' We'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' can'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' use'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' plot'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content='_function'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content='.'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' Provide'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' function'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' expression'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' \"'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content='x'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content='**'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content='2'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' -'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' '), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content='3'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content='*x'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content='\".'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' Provide'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' x'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content='_min'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' and'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' x'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content='_max'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' maybe'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' default'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' ok'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content='.'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' Provide'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' result'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content='.'), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=[ChoiceDeltaToolCall(index=0, id='call_EAUjPtptsIVT7yUFY7KMYVZ9', function=ChoiceDeltaToolCallFunction(arguments=None, name='plot_function'), type='function')]), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=[ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='{\"', name=None), type='function')]), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=[ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='expression', name=None), type='function')]), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=[ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='\":\"', name=None), type='function')]), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=[ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='x', name=None), type='function')]), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=[ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='**', name=None), type='function')]), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=[ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='2', name=None), type='function')]), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=[ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments=' -', name=None), type='function')]), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=[ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments=' ', name=None), type='function')]), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=[ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='3', name=None), type='function')]), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=[ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='*x', name=None), type='function')]), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=[ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='\",\"', name=None), type='function')]), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=[ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='x', name=None), type='function')]), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=[ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='_min', name=None), type='function')]), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=[ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='\":', name=None), type='function')]), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=[ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='-', name=None), type='function')]), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=[ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='10', name=None), type='function')]), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=[ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments=',\"', name=None), type='function')]), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=[ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='x', name=None), type='function')]), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=[ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='_max', name=None), type='function')]), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=[ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='\":', name=None), type='function')]), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=[ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='10', name=None), type='function')]), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=[ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='}', name=None), type='function')]), finish_reason=None, index=0, logprobs=None)\n", + "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None), finish_reason='tool_calls', index=0, logprobs=None)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n", + "ChoiceDeltaToolCall(index=0, id='call_EAUjPtptsIVT7yUFY7KMYVZ9', function=ChoiceDeltaToolCallFunction(arguments=None, name='plot_function'), type='function')\n", + "Call ID: call_EAUjPtptsIVT7yUFY7KMYVZ9\n", + "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n", + "ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='{\"', name=None), type='function')\n", + "Call ID: call_EAUjPtptsIVT7yUFY7KMYVZ9\n", + "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n", + "ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='expression', name=None), type='function')\n", + "Call ID: call_EAUjPtptsIVT7yUFY7KMYVZ9\n", + "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n", + "ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='\":\"', name=None), type='function')\n", + "Call ID: call_EAUjPtptsIVT7yUFY7KMYVZ9\n", + "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n", + "ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='x', name=None), type='function')\n", + "Call ID: call_EAUjPtptsIVT7yUFY7KMYVZ9\n", + "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n", + "ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='**', name=None), type='function')\n", + "Call ID: call_EAUjPtptsIVT7yUFY7KMYVZ9\n", + "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n", + "ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='2', name=None), type='function')\n", + "Call ID: call_EAUjPtptsIVT7yUFY7KMYVZ9\n", + "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n", + "ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments=' -', name=None), type='function')\n", + "Call ID: call_EAUjPtptsIVT7yUFY7KMYVZ9\n", + "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n", + "ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments=' ', name=None), type='function')\n", + "Call ID: call_EAUjPtptsIVT7yUFY7KMYVZ9\n", + "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n", + "ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='3', name=None), type='function')\n", + "Call ID: call_EAUjPtptsIVT7yUFY7KMYVZ9\n", + "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n", + "ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='*x', name=None), type='function')\n", + "Call ID: call_EAUjPtptsIVT7yUFY7KMYVZ9\n", + "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n", + "ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='\",\"', name=None), type='function')\n", + "Call ID: call_EAUjPtptsIVT7yUFY7KMYVZ9\n", + "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n", + "ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='x', name=None), type='function')\n", + "Call ID: call_EAUjPtptsIVT7yUFY7KMYVZ9\n", + "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n", + "ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='_min', name=None), type='function')\n", + "Call ID: call_EAUjPtptsIVT7yUFY7KMYVZ9\n", + "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n", + "ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='\":', name=None), type='function')\n", + "Call ID: call_EAUjPtptsIVT7yUFY7KMYVZ9\n", + "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n", + "ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='-', name=None), type='function')\n", + "Call ID: call_EAUjPtptsIVT7yUFY7KMYVZ9\n", + "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n", + "ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='10', name=None), type='function')\n", + "Call ID: call_EAUjPtptsIVT7yUFY7KMYVZ9\n", + "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n", + "ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments=',\"', name=None), type='function')\n", + "Call ID: call_EAUjPtptsIVT7yUFY7KMYVZ9\n", + "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n", + "ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='x', name=None), type='function')\n", + "Call ID: call_EAUjPtptsIVT7yUFY7KMYVZ9\n", + "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n", + "ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='_max', name=None), type='function')\n", + "Call ID: call_EAUjPtptsIVT7yUFY7KMYVZ9\n", + "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n", + "ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='\":', name=None), type='function')\n", + "Call ID: call_EAUjPtptsIVT7yUFY7KMYVZ9\n", + "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n", + "ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='10', name=None), type='function')\n", + "Call ID: call_EAUjPtptsIVT7yUFY7KMYVZ9\n", + "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n", + "ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='}', name=None), type='function')\n", + "Call ID: call_EAUjPtptsIVT7yUFY7KMYVZ9\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "DEBUG:mathxpert:🧠 LLM interaction ended. Reason: {finish_reason}\n", + "DEBUG:mathxpert:Final tools to call [namespace(id='call_EAUjPtptsIVT7yUFY7KMYVZ9', function=namespace(name='plot_function', arguments='{\"expression\":\"x**2 - 3*x\",\"x_min\":-10,\"x_max\":10}'))]\n", + "DEBUG:mathxpert:[namespace(id='call_EAUjPtptsIVT7yUFY7KMYVZ9', function=namespace(name='plot_function', arguments='{\"expression\":\"x**2 - 3*x\",\"x_min\":-10,\"x_max\":10}'))]\n", + "DEBUG:mathxpert:Tool run result: {'plot_image': 'data:image/png;base64,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', 'expression': 'x**2 - 3*x', 'x_range': [-10.0, 10.0]}\n", + "DEBUG:mathxpert:We have a plot\n" + ] + } + ], + "source": [ + "def chat(message: str, history: list[dict], selected_provider: str, model_selector: str):\n", + " # NOTE: I'm not interesting in maintaining a conversation\n", + " response = ask(client, selected_model, message)\n", + "\n", + " for chunk in response:\n", + " yield chunk\n", + "\n", + "def on_provider_change(change):\n", + " global selected_provider, client, models\n", + " logger.info(f'Provider changed to {change}')\n", + " selected_provider = change\n", + " client = clients.get(selected_provider)\n", + " load_models_if_needed(client, selected_provider)\n", + "\n", + " return gr.Dropdown(\n", + " choices=models.get(selected_provider, []),\n", + " value=selection_state[selected_provider],\n", + " interactive=True,\n", + " )\n", + "\n", + "\n", + "def on_model_change(change):\n", + " global selected_provider, selected_model, selection_state\n", + "\n", + " selected_model = change\n", + " selection_state[selected_provider] = selected_model\n", + " logger.info(f'👉 Selected model: {selected_model}')\n", + "\n", + "\n", + "with gr.Blocks(title='MathXpert', fill_width=True, \n", + " \n", + " ) as ui:\n", + " def get_value_if_exist(v, ls) -> str:\n", + " print(ls)\n", + " selected = v if v in ls else None\n", + " if selected:\n", + " return selected\n", + "\n", + " return ls[0] if ls else None\n", + "\n", + " with gr.Row():\n", + " provider_selector = gr.Dropdown(\n", + " choices=available_providers, \n", + " value=get_desired_value_or_first_item(selected_provider, available_providers),\n", + " label='Provider',\n", + " )\n", + " model_selector = gr.Dropdown(\n", + " choices=models[selected_provider],\n", + " value=get_desired_value_or_first_item(selection_state[selected_provider], models[selected_provider]),\n", + " label='Model',\n", + " )\n", + " \n", + " provider_selector.change(fn=on_provider_change, inputs=provider_selector, outputs=model_selector)\n", + " model_selector.change(fn=on_model_change, inputs=model_selector)\n", + "\n", + " examples = [\n", + " ['Where can substitutions be applied in real life?', None, None],\n", + " ['Give 1 differential equation question and solve it', None, None],\n", + " ['Plot x**2 - 3x', None, None],\n", + " ['What is the time now?', None, None],\n", + " ['What is the temperature?', None, None],\n", + " ['Tell me the time and the temperature now', None, None],\n", + " ]\n", + "\n", + " \n", + " gr.ChatInterface(\n", + " fn=chat, \n", + " type='messages', \n", + " chatbot=gr.Chatbot(type='messages', height='75vh', resizable=True),\n", + " additional_inputs=[provider_selector, model_selector],\n", + " examples=examples,\n", + " )\n", + "\n", + "ui.launch()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9c3289fe-efda-46e8-824f-01c1e68f23f5", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a4409824-4f7e-4ec5-b8aa-e42a0b73cc54", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 9543fed3d4a333f703250b27c4b7d6c48a032c14 Mon Sep 17 00:00:00 2001 From: Ransford Okpoti Date: Wed, 22 Oct 2025 13:00:28 +0000 Subject: [PATCH 2/3] =?UTF-8?q?fix:=20left=20cells=20outputs=20after=20fin?= =?UTF-8?q?al=20check=20run=20=F0=9F=A4=A6?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...ranskills-week2-mathxpert-with-tools.ipynb | 480 +----------------- 1 file changed, 17 insertions(+), 463 deletions(-) diff --git a/week2/community-contributions/ranskills-week2-mathxpert-with-tools.ipynb b/week2/community-contributions/ranskills-week2-mathxpert-with-tools.ipynb index b058bf3..a423a46 100644 --- a/week2/community-contributions/ranskills-week2-mathxpert-with-tools.ipynb +++ b/week2/community-contributions/ranskills-week2-mathxpert-with-tools.ipynb @@ -18,21 +18,10 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "id": "c1070317-3ed9-4659-abe3-828943230e03", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "True" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "import os\n", "import json\n", @@ -53,7 +42,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "id": "99901b80", "metadata": {}, "outputs": [], @@ -81,19 +70,10 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "id": "4a456906-915a-4bfd-bb9d-57e505c5093f", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:mathxpert:✅ OLLAMA_API_KEY provided\n", - "INFO:mathxpert:✅ OPENROUTER_API_KEY provided\n" - ] - } - ], + "outputs": [], "source": [ "class Provider(StrEnum):\n", " OLLAMA = 'Ollama'\n", @@ -145,20 +125,10 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "id": "aae1579b-7a02-459d-81c6-0f775d2a1410", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:mathxpert:Pick Ollama from ['Ollama', 'OpenRouter']\n", - "DEBUG:mathxpert:Pick gpt-oss:20b from ['glm-4.6', 'kimi-k2:1t', 'qwen3-coder:480b', 'deepseek-v3.1:671b', 'gpt-oss:120b', 'gpt-oss:20b', 'qwen3-vl:235b']\n", - "INFO:mathxpert:ℹ️ Provider: Ollama Model: gpt-oss:20b, Client: \n" - ] - } - ], + "outputs": [], "source": [ "selected_provider, selected_model, client = '', '', None\n", "\n", @@ -204,7 +174,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "id": "a8d7923c-5f28-4c30-8556-342d7c8497c1", "metadata": {}, "outputs": [], @@ -247,7 +217,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "id": "3f302f47-9a67-4410-ba16-56fa5a731c66", "metadata": {}, "outputs": [], @@ -342,7 +312,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "id": "4f18bc9f-f8d1-4208-a3d7-e4e911034572", "metadata": {}, "outputs": [], @@ -424,83 +394,10 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "id": "9b2e0634-de5d-45f6-a8d4-569e04d14a00", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:mathxpert:[\n", - " {\n", - " \"type\": \"function\",\n", - " \"function\": {\n", - " \"name\": \"get_current_datetime\",\n", - " \"description\": \"Returns the current date and time in the specified timezone.\",\n", - " \"parameters\": {\n", - " \"properties\": {\n", - " \"timezone\": {\n", - " \"default\": \"UTC\",\n", - " \"description\": \"Timezone name, e.g., 'UTC' or 'Africa/Accra'\",\n", - " \"title\": \"Timezone\",\n", - " \"type\": \"string\"\n", - " }\n", - " },\n", - " \"title\": \"GetCurrentDateTimeInput\",\n", - " \"type\": \"object\"\n", - " }\n", - " }\n", - " },\n", - " {\n", - " \"type\": \"function\",\n", - " \"function\": {\n", - " \"name\": \"get_temperature\",\n", - " \"description\": \"Returns the current temperature in degree celsius\",\n", - " \"parameters\": {\n", - " \"properties\": {},\n", - " \"title\": \"GetTemperatureInput\",\n", - " \"type\": \"object\"\n", - " }\n", - " }\n", - " },\n", - " {\n", - " \"type\": \"function\",\n", - " \"function\": {\n", - " \"name\": \"plot_function\",\n", - " \"description\": \"Plots a mathematical function and returns image data.\",\n", - " \"parameters\": {\n", - " \"properties\": {\n", - " \"expression\": {\n", - " \"description\": \"Mathematical expression to plot, e.g., 'sin(x)'\",\n", - " \"title\": \"Expression\",\n", - " \"type\": \"string\"\n", - " },\n", - " \"x_min\": {\n", - " \"default\": -10,\n", - " \"description\": \"Minimum x value\",\n", - " \"title\": \"X Min\",\n", - " \"type\": \"number\"\n", - " },\n", - " \"x_max\": {\n", - " \"default\": 10,\n", - " \"description\": \"Maximum x value\",\n", - " \"title\": \"X Max\",\n", - " \"type\": \"number\"\n", - " }\n", - " },\n", - " \"required\": [\n", - " \"expression\"\n", - " ],\n", - " \"title\": \"PlotFunctionInput\",\n", - " \"type\": \"object\"\n", - " }\n", - " }\n", - " }\n", - "]\n" - ] - } - ], + "outputs": [], "source": [ "logger.debug(tool_manager.dump_tools())" ] @@ -515,7 +412,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "id": "8f7c8ea8-4082-4ad0-8751-3301adcf6538", "metadata": {}, "outputs": [], @@ -629,153 +526,10 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "id": "09bc9a11-adb4-4a9c-9c77-73b2b5a665cf", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:mathxpert:# Tools: 3\n", - "DEBUG:mathxpert:Turn: 0\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role='assistant', tool_calls=None), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content='The'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' user'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' wants'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' a'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' plot'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' of'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' y'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' ='), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' x'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content='^'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content='2'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content='.'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' We'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' need'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' to'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' call'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' plot'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content='_function'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' via'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' tools'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content='.'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' So'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' use'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' the'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' function'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' with'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' expression'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' \"'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content='x'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content='**'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content='2'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content='\".'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' Probably'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' set'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' range'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' default'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content='.'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' Then'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' return'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' an'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' image'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content='?'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' We'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' just'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' return'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' the'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' tool'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' output'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content='.\\n\\n'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content='User'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=\"'s\"), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' message'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' is'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' \"'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content='Plot'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' a'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' graph'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' of'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' y'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' ='), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' x'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content='**'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content='2'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content='\".'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' So'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' we'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' provide'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' image'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content='.'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' Probably'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' just'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' respond'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' with'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' the'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' call'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content='.'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=[ChoiceDeltaToolCall(index=0, id='call_gUaf9cCr8Mn2s5zdix8L3ij2', function=ChoiceDeltaToolCallFunction(arguments=None, name='plot_function'), type='function')]), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=[ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='{\"', name=None), type='function')]), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=[ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='expression', name=None), type='function')]), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=[ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='\":\"', name=None), type='function')]), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=[ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='x', name=None), type='function')]), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=[ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='**', name=None), type='function')]), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=[ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='2', name=None), type='function')]), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=[ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='\"}', name=None), type='function')]), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None), finish_reason='tool_calls', index=0, logprobs=None)\n", - "DEBUG:mathxpert:🧠 LLM interaction ended. Reason: {finish_reason}\n", - "DEBUG:mathxpert:Final tools to call [namespace(id='call_gUaf9cCr8Mn2s5zdix8L3ij2', function=namespace(name='plot_function', arguments='{\"expression\":\"x**2\"}'))]\n", - "DEBUG:mathxpert:[namespace(id='call_gUaf9cCr8Mn2s5zdix8L3ij2', function=namespace(name='plot_function', arguments='{\"expression\":\"x**2\"}'))]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n", - "ChoiceDeltaToolCall(index=0, id='call_gUaf9cCr8Mn2s5zdix8L3ij2', function=ChoiceDeltaToolCallFunction(arguments=None, name='plot_function'), type='function')\n", - "Call ID: call_gUaf9cCr8Mn2s5zdix8L3ij2\n", - "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n", - "ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='{\"', name=None), type='function')\n", - "Call ID: call_gUaf9cCr8Mn2s5zdix8L3ij2\n", - "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n", - "ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='expression', name=None), type='function')\n", - "Call ID: call_gUaf9cCr8Mn2s5zdix8L3ij2\n", - "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n", - "ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='\":\"', name=None), type='function')\n", - "Call ID: call_gUaf9cCr8Mn2s5zdix8L3ij2\n", - "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n", - "ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='x', name=None), type='function')\n", - "Call ID: call_gUaf9cCr8Mn2s5zdix8L3ij2\n", - "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n", - "ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='**', name=None), type='function')\n", - "Call ID: call_gUaf9cCr8Mn2s5zdix8L3ij2\n", - "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n", - "ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='2', name=None), type='function')\n", - "Call ID: call_gUaf9cCr8Mn2s5zdix8L3ij2\n", - "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n", - "ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='\"}', name=None), type='function')\n", - "Call ID: call_gUaf9cCr8Mn2s5zdix8L3ij2\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:mathxpert:Tool run result: {'plot_image': 'data:image/png;base64,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', 'expression': 'x**2', 'x_range': [-10, 10]}\n", - "DEBUG:mathxpert:We have a plot\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n" - ] - } - ], + "outputs": [], "source": [ "# print(selected_provider, selected_model)\n", "# print(client)\n", @@ -797,210 +551,10 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "id": "50fc3577", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:mathxpert:Pick Ollama from ['Ollama', 'OpenRouter']\n", - "DEBUG:mathxpert:Pick gpt-oss:20b from ['glm-4.6', 'kimi-k2:1t', 'qwen3-coder:480b', 'deepseek-v3.1:671b', 'gpt-oss:120b', 'gpt-oss:20b', 'qwen3-vl:235b']\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "* Running on local URL: http://127.0.0.1:7860\n", - "* To create a public link, set `share=True` in `launch()`.\n" - ] - }, - { - "data": { - "text/html": [ - "
" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:mathxpert:# Tools: 3\n", - "DEBUG:mathxpert:Turn: 0\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role='assistant', tool_calls=None), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content='User'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' wants'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' to'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' plot'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' function'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' x'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content='**'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content='2'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' -'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' '), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content='3'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content='x'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content='.'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' We'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' can'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' use'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' plot'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content='_function'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content='.'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' Provide'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' function'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' expression'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' \"'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content='x'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content='**'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content='2'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' -'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' '), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content='3'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content='*x'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content='\".'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' Provide'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' x'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content='_min'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' and'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' x'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content='_max'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' maybe'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' default'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' ok'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content='.'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' Provide'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=' result'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content='.'), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=[ChoiceDeltaToolCall(index=0, id='call_EAUjPtptsIVT7yUFY7KMYVZ9', function=ChoiceDeltaToolCallFunction(arguments=None, name='plot_function'), type='function')]), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=[ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='{\"', name=None), type='function')]), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=[ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='expression', name=None), type='function')]), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=[ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='\":\"', name=None), type='function')]), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=[ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='x', name=None), type='function')]), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=[ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='**', name=None), type='function')]), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=[ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='2', name=None), type='function')]), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=[ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments=' -', name=None), type='function')]), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=[ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments=' ', name=None), type='function')]), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=[ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='3', name=None), type='function')]), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=[ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='*x', name=None), type='function')]), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=[ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='\",\"', name=None), type='function')]), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=[ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='x', name=None), type='function')]), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=[ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='_min', name=None), type='function')]), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=[ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='\":', name=None), type='function')]), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=[ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='-', name=None), type='function')]), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=[ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='10', name=None), type='function')]), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=[ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments=',\"', name=None), type='function')]), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=[ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='x', name=None), type='function')]), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=[ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='_max', name=None), type='function')]), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=[ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='\":', name=None), type='function')]), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=[ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='10', name=None), type='function')]), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=[ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='}', name=None), type='function')]), finish_reason=None, index=0, logprobs=None)\n", - "DEBUG:mathxpert: ✨ Choice(delta=ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None), finish_reason='tool_calls', index=0, logprobs=None)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n", - "ChoiceDeltaToolCall(index=0, id='call_EAUjPtptsIVT7yUFY7KMYVZ9', function=ChoiceDeltaToolCallFunction(arguments=None, name='plot_function'), type='function')\n", - "Call ID: call_EAUjPtptsIVT7yUFY7KMYVZ9\n", - "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n", - "ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='{\"', name=None), type='function')\n", - "Call ID: call_EAUjPtptsIVT7yUFY7KMYVZ9\n", - "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n", - "ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='expression', name=None), type='function')\n", - "Call ID: call_EAUjPtptsIVT7yUFY7KMYVZ9\n", - "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n", - "ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='\":\"', name=None), type='function')\n", - "Call ID: call_EAUjPtptsIVT7yUFY7KMYVZ9\n", - "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n", - "ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='x', name=None), type='function')\n", - "Call ID: call_EAUjPtptsIVT7yUFY7KMYVZ9\n", - "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n", - "ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='**', name=None), type='function')\n", - "Call ID: call_EAUjPtptsIVT7yUFY7KMYVZ9\n", - "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n", - "ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='2', name=None), type='function')\n", - "Call ID: call_EAUjPtptsIVT7yUFY7KMYVZ9\n", - "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n", - "ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments=' -', name=None), type='function')\n", - "Call ID: call_EAUjPtptsIVT7yUFY7KMYVZ9\n", - "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n", - "ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments=' ', name=None), type='function')\n", - "Call ID: call_EAUjPtptsIVT7yUFY7KMYVZ9\n", - "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n", - "ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='3', name=None), type='function')\n", - "Call ID: call_EAUjPtptsIVT7yUFY7KMYVZ9\n", - "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n", - "ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='*x', name=None), type='function')\n", - "Call ID: call_EAUjPtptsIVT7yUFY7KMYVZ9\n", - "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n", - "ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='\",\"', name=None), type='function')\n", - "Call ID: call_EAUjPtptsIVT7yUFY7KMYVZ9\n", - "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n", - "ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='x', name=None), type='function')\n", - "Call ID: call_EAUjPtptsIVT7yUFY7KMYVZ9\n", - "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n", - "ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='_min', name=None), type='function')\n", - "Call ID: call_EAUjPtptsIVT7yUFY7KMYVZ9\n", - "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n", - "ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='\":', name=None), type='function')\n", - "Call ID: call_EAUjPtptsIVT7yUFY7KMYVZ9\n", - "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n", - "ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='-', name=None), type='function')\n", - "Call ID: call_EAUjPtptsIVT7yUFY7KMYVZ9\n", - "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n", - "ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='10', name=None), type='function')\n", - "Call ID: call_EAUjPtptsIVT7yUFY7KMYVZ9\n", - "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n", - "ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments=',\"', name=None), type='function')\n", - "Call ID: call_EAUjPtptsIVT7yUFY7KMYVZ9\n", - "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n", - "ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='x', name=None), type='function')\n", - "Call ID: call_EAUjPtptsIVT7yUFY7KMYVZ9\n", - "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n", - "ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='_max', name=None), type='function')\n", - "Call ID: call_EAUjPtptsIVT7yUFY7KMYVZ9\n", - "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n", - "ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='\":', name=None), type='function')\n", - "Call ID: call_EAUjPtptsIVT7yUFY7KMYVZ9\n", - "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n", - "ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='10', name=None), type='function')\n", - "Call ID: call_EAUjPtptsIVT7yUFY7KMYVZ9\n", - "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n", - "ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='}', name=None), type='function')\n", - "Call ID: call_EAUjPtptsIVT7yUFY7KMYVZ9\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:mathxpert:🧠 LLM interaction ended. Reason: {finish_reason}\n", - "DEBUG:mathxpert:Final tools to call [namespace(id='call_EAUjPtptsIVT7yUFY7KMYVZ9', function=namespace(name='plot_function', arguments='{\"expression\":\"x**2 - 3*x\",\"x_min\":-10,\"x_max\":10}'))]\n", - "DEBUG:mathxpert:[namespace(id='call_EAUjPtptsIVT7yUFY7KMYVZ9', function=namespace(name='plot_function', arguments='{\"expression\":\"x**2 - 3*x\",\"x_min\":-10,\"x_max\":10}'))]\n", - "DEBUG:mathxpert:Tool run result: {'plot_image': 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAA1YAAAIrCAYAAADslwjAAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjMsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvZiW1igAAAAlwSFlzAAAPYQAAD2EBqD+naQAAcdlJREFUeJzt3XmcjeX/x/H3GcOMbWbQmDEltNkiQtPY4hshFdKGShGSNVoo2QqRJEuhLO2pX5E2kjVZskZCiBTNkGXGYBZz7t8fVzPHZDDbmfssr+fjMY+u6z73nHnP1e3M+Zz7vq/LYVmWJQAAAABArgXYHQAAAAAAvB2FFQAAAADkEYUVAAAAAOQRhRUAAAAA5BGFFQAAAADkEYUVAAAAAOQRhRUAAAAA5BGFFQAAAADkEYUVAAAAAOQRhRUAAPlkzJgxqlu3rkqWLKmIiAjdd9992r9/v92xAAAFgMIKAIB8smLFCvXp00fr1q3TwoULdezYMbVq1Upnz561OxoAwM0orAAAubJ//345HA498sgjdkfJltTUVA0fPlzXXnutgoKC5HA4NH/+/Hz9GQsXLlTnzp1VrVo11a5dW2+99ZZ27typX3/9NV9/DgDA81BYAQAypBdL534VKVJE5cuXV8eOHbV169Z8/5nLly+Xw+HQ8OHD8/25z/Xqq69qxIgRioqK0lNPPaVhw4apSpUqbv2Z8fHxkqTSpUu79eecKykpSQMGDFDjxo0VFRWl4OBgRUZGqkGDBpo9e7ZSU1MLLAsA+JNAuwMAADzP1VdfrQcffFCSlJiYqLVr1+qjjz7S559/riVLlqhBgwY2J8y5r776SiVKlNDixYtVpEgRt/+8tLQ0PfXUU7r99tt1xRVXuP3npUtMTNSbb76pm266Sa1bt1Z4eLiOHz+ub7/9Vl26dNHHH3+sb7/9VgEBfLYKAPmJwgoAcJ5rrrnmvDNIQ4YM0ahRo/T8889r+fLltuTKi0OHDqlMmTIFUlRZlqXHH39cBw4c0I8//uj2n3eu0qVLKz4+/rzf8+zZs2revLm+++47ffvtt2rdunWB5gIAX8fHVQCAbOnTp48kaf369dnaf/bs2YqOjlaJEiVUokQJRUdHa86cOZn2GT58uJo2bSpJGjFiRKZLELMzm152f4bD4dC+ffv0xx9/ZDx/xYoVL/n8MTExcjgcWrNmTabtCQkJqlWrloKCgrR48eJMj1mWpSeeeELff/+9lixZovDw8Ev+nPwUEBCQZfEYGBiodu3aSZL27NmT6bHc/J4AgMw4YwUAyBGHw3HJffr27avJkyfr8ssvV9euXSVJn332mR599FFt3rxZr7/+uiSpSZMm2r9/v9555x3dcsstatKkScZzhIWF5dvPkKSJEydKkvr375+t55eksWPH6pZbbtGQIUO0ZMkSSVJKSoratWunrVu36sMPP1Tz5s0z9rcsS7169dLXX3+tFStWqHz58pf8GQXF6XRq4cKFkqTrr78+02M5/T0BAFmwAAD41759+yxJVosWLc57bOjQoZYkq2nTppn27dy5c6b9VqxYYUmyqlatap04cSJj+7Fjx6zrrrvOkmStXLkyY/uyZcssSdawYcOynTOnP8OyLKtChQpWhQoVsv0z0rVu3dqSZC1btsxyOp1Whw4dLEnWxIkTz9u3Z8+eVlhYmPXDDz9Yf//9d8ZXcnJyjn9uXiUnJ1vDhg2zhg4davXq1cuqUqWKJcl69NFHs9w/J78nAOB8FFYAgAzpxdLVV19tDRs2zBo2bJj11FNPWY0aNbIkWcHBwdbq1asz7fvfwqpLly6WJGvu3LnnPf8HH3xgSbK6dOmSsS03hVVOf4Zl5b6w2rp1qxUQEGA1bNjQGjBggCXJGjx4cJb7Ssrya9myZTn+uXl18uTJTBkcDof11FNPWampqVnun5PfEwBwPi4FBACcZ+/evRoxYoQkqXDhwoqIiFDHjh01aNAg1ahR46Lfu3nzZknKdFlfuvT7qbZs2ZKnfAXxM9LVqFFDDz74oN59912tWrVKXbp00ejRo7Pc17KsXP2MgQMHKjk5Odv79+vXT9dee+1F9ylRooQsy5LT6dShQ4f05Zdf6rnnntOaNWv0zTffKCQkJNP+Ofk9AQDno7ACAJynRYsWGffj5FRCQoICAgKynLQhIiJCDodDCQkJecpXED/jXOk/p2TJkpo6dWq+PW+66dOn69SpU9ne/5577rlkYZUuICBAV1xxhXr27KnLLrtM9913n0aNGqWxY8eet6+7f08A8GXMCggAyFchISFyOp06cuTIeY8dPnxYlmWdd7bEE39GuilTpujVV19VRESETp48qXfeeSdfnvdciYmJsszl+dn6yupMXXbcdtttkpTldPkF8XsCgC+jsAIA5KvatWtLyvrNe/q2WrVqZWwrVKiQJLOgrrt+Rm598skn6tevn5o2barNmzcrNDRUI0aM0OnTp/P83HY4dOiQJHN557l87fcEADtQWAEA8lXnzp0lmXWpzr0cLz4+PuO+rfR9JLOgrST9+eefbvsZubFkyRI99NBDqlGjhubPn69y5crpySef1N9//50xlbsn+vXXX7MsiE6fPq0BAwZIkm6//faM7d76ewKAp3FYub3TFgDgc/bv369KlSpl6x6r9H07d+583qK86WtMlS9fXu3bt5dlWfrss8/0119/qW/fvpnesKelpenKK6/U0aNH1blzZ11xxRVyOBzq06ePQkNDL/jzc/IzJGUsCJydhYc3bdqkJk2aqEyZMlq9erXKlSsnydzbValSJaWlpen333/PKAo9yfDhwzVhwgQ1bNhQFStWVEhIiA4ePKhvv/1WR48eVaNGjbRo0SIVLVrUq39PAPA4BTwLIQDAg11sHasL7fvf6dbTzZo1y6pXr55VrFgxq1ixYla9evWsWbNmZbnv2rVrrVtuucUqWbJkxvTg+/btu2SGnPyM7E63vmfPHisiIsIqU6aMtXPnzvMeHzt2rCXJeuqppy75XHZYv3691a1bN6t69epWWFiYFRgYaJUpU8Zq2rSpNX369Izp1r399wQAT8MZKwAAAADII+6xAgAAAIA8orACAAAAgDyisAIAAACAPKKwAgAAAIA8orACAAAAgDyisAIAAACAPKKwAgAAAIA8CrQ7gCdyOp06dOiQSpYsKYfDYXccAAAAADaxLEsnT55UVFSUAgIufF6KwioLhw4dUvny5e2OAQAAAMBD/Pnnn7riiisu+DiFVRZKliwpyQxeSEiIrVmcTqeOHDmi8PDwi1bIyB3G170YX/difN2L8XUvxte9GF/3Ynzdy9PGNyEhQeXLl8+oES6EwioL6Zf/hYSEeERhlZSUpJCQEI84sHwN4+tejK97Mb7uxfi6F+PrXoyvezG+7uWp43upW4Q8JykAAAAAeCkKKwAAAADIIworAAAAAMgjCisAAAAAyCMKKwAAAADIIworAAAAAMgjCisAAAAAyCMKKwAAAADIIworAAAAAMgjCisAAAAAyCMKKwAAAADIIworAAAAAMgjCisAAAAAyCMKKwAAAADIIworAAAAAMgjCisvkJxsdwIAAAAAF0Nh5cF27JAeesih1q3LyOm0Ow0AAACAC6Gw8mCPPSZ9+KFD27cX1vz5dqcBAAAAcCEUVh7s+edd7dGjHbIs+7IAAAAAuDAKKw/WqpVUp46ppjZvdujrr20OBAAAACBLFFYezOGQnnvOdZrqxRfFWSsAAADAA1FYebi77pKqVk2VJP30k7R4sc2BAAAAAJyHwsrDBQRI/fufyuhz1goAAADwPBRWXqB16yRVqWKqqVWrpBUrbA4EAAAAIBMKKy9QqND591oBAAAA8BwUVl7i/vula64x7aVLpdWr7c0DAAAAwIXCyksEBkrPPefqc9YKAAAA8BwUVl7kwQelihVNe+FCaf16W+MAAAAA+BeFlRcpXFgaNMjV56wVAAAA4BkorLzMI49IV1xh2l9+KW3ZYmcaAAAAABKFldcJCpKeecbVf+kl+7IAAAAAMCisvNBjj0kREab92WfS9u325gEAAAD8HYWVFypaVHr6aVd/1Cj7sgAAAACgsPJajz8uXXaZac+dK/32m715AAAAAH9GYeWliheXBg40badTGj3a3jwAAACAP6Ow8mK9ekmlSpn2++9Lv/9ubx4AAADAX1FYebGSJaX+/U07LU16+WVb4wAAAAB+i8LKy/XtK4WEmPacOdKBA7bGAQAAAPwShZWXCwuT+vQx7dRUaexYW+MAAAAAfonCygf0728ms5Ckt9+W/vrL1jgAAACA36Gw8gGXXSb17m3aKSncawUAAAAUNAorH/HUU66zVm+9Jf35p715AAAAAH9CYeUjLrvMda8VZ60AAACAgkVh5UMGDpRKlDDtt9/mrBUAAABQUCisfMh/z1qNGWNvHgAAAMBfeFRhtXLlSt15552KioqSw+HQ/PnzMx5LTU3Vs88+qxo1aqh48eKKiorSww8/rEOHDmV6jmPHjqlTp04KCQlRWFiYunbtqsTExAL+Tezz37NWrGsFAAAAuJ9HFVanTp3SDTfcoKlTp5732OnTp7Vp0ya98MIL2rRpkz7//HPt2rVLd911V6b9OnXqpO3bt2vx4sX66quvtHLlSnXv3r2gfgXblSljFg2WzLpWnLUCAAAA3C/Q7gDnatWqlVq1apXlY6GhoVq8eHGmbVOmTNFNN92kAwcO6Morr9SOHTu0cOFCrV+/XnXr1pUkTZ48WbfffrvGjx+vqKgot/8OnmDAAGnyZOnkSWnmTGnQIKlCBbtTAQAAAL7LowqrnIqPj5fD4VBYWJgkac2aNQoLC8soqiSpWbNmCggI0Lp169SuXbssnyc5OVnJyckZ/YSEBEmS0+mU0+l03y+QDU6nU5Zl5ShHqVJSnz4OjR7tUGqqNHq0pTfftNyY0nvlZnyRfYyvezG+7sX4uhfj616Mr3sxvu7laeOb3RxeW1glJSXp2WefVYcOHRQSEiJJio2NVdmyZTPtFxgYqNKlSys2NvaCzzVmzBiNGDHivO1HjhxRUlJS/gbPIafTqfj4eFmWpYCA7F+5+eCDDk2aFK7ExADNni099tg/Kl/eMw5OT5Lb8UX2ML7uxfi6F+PrXoyvezG+7sX4upenje/JkyeztZ9XFlapqam67777ZFmW3nzzzTw/3+DBgzVgwICMfkJCgsqXL6/w8PCMos0uTqdTDodD4eHhOTqwypaV+vVzaNQoKTXVobfeCte0aZy1+q/cji+yh/F1L8bXvRhf92J83YvxdS/G1708bXyDg4OztZ/XFVbpRdUff/yhpUuXZip8IiMjdfjw4Uz7nz17VseOHVNkZOQFnzMoKEhBQUHnbQ8ICPCI/5kOhyNXWdLvtUpIkGbPdui55xyqWNE9Gb1ZbscX2cP4uhfj616Mr3sxvu7F+LoX4+tenjS+2c1gf9IcSC+qdu/ere+//15lypTJ9HhMTIxOnDihjRs3ZmxbunSpnE6noqOjCzqu7UqXlvr1M+2zZ6XRo+3NAwAAAPgqjyqsEhMTtWXLFm3ZskWStG/fPm3ZskUHDhxQamqq7rnnHm3YsEEffPCB0tLSFBsbq9jYWKWkpEiSqlatqpYtW6pbt2766aef9OOPP6p379564IEH/GZGwP968kkp/aTe7NnSvn325gEAAAB8kUcVVhs2bFDt2rVVu3ZtSdKAAQNUu3ZtDR06VAcPHtSCBQv0119/qVatWipXrlzG1+rVqzOe44MPPlCVKlV066236vbbb1fDhg01Y8YMu34l25UqJfXvb9qctQIAAADcw6PusWrSpIks68ITLFzssXSlS5fWhx9+mJ+xvF7//tLrr0vx8dKcOdJzz0mVKtmdCgAAAPAdHnXGCu7x37NWo0bZGgcAAADwORRWfqJ/fyk01LTnzJF+/93ONAAAAIBvobDyE2FhZiILSUpLk156ydY4AAAAgE+hsPIj/fq5zlq9+660d6+9eQAAAABfQWHlR8LCzKLBkjlrNXKkrXEAAAAAn0Fh5Wf69TOTWUjS++9LO3bYmwcAAADwBRRWfiY0VHrmGdN2OqXhw22NAwAAAPgECis/1KePVLasaX/yifTzz/bmAQAAALwdhZUfKl5cGjzY1R861L4sAAAAgC+gsPJTjz8uXX65aS9YIP30k715AAAAAG9GYeWngoOlIUNc/RdesC8LAAAA4O0orPxYly5SpUqm/d130sqV9uYBAAAAvBWFlR8rUkQaNszVHzJEsiz78gAAAADeisLKz3XqJFWubNo//CB9/729eQAAAABvRGHl5wIDpREjXH3OWgEAAAA5R2EF3XuvVKOGaf/0k/TVV/bmAQAAALwNhRUUECC9+KKr/8ILktNpXx4AAADA21BYQZJ0111S3bqm/fPP0mef2ZsHAAAA8CYUVpAkORzSSy+5+kOHSmlp9uUBAAAAvAmFFTLcdpvUqJFp79wpffCBvXkAAAAAb0FhhQz/PWs1fLiUmmpbHAAAAMBrUFghk8aNpebNTXvfPmn2bHvzAAAAAN6AwgrnOXeGwBdflJKS7MsCAAAAeAMKK5wnOlq6807T/usvacYMe/MAAAAAno7CClkaOdLVHj1aOnXKviwAAACAp6OwQpZq1ZLuvde04+Kk11+3NQ4AAADg0SiscEEvvigVKmTa48ZJx47ZmwcAAADwVBRWuKDKlaVHHzXt+Hhp7Fh78wAAAACeisIKFzVsmBQUZNqTJkkHD9qbBwAAAPBEFFa4qCuukHr3Nu2kpMyTWgAAAAAwKKxwSYMGSSVLmvbMmdLu3fbmAQAAADwNhRUu6bLLpKefNu20NOmFF+zNAwAAAHgaCitkS//+Uni4ac+dK23ebGscAAAAwKNQWCFbSpaUhgxx9Z97zr4sAAAAgKehsEK29eghVahg2gsXSitW2JsHAAAA8BQUVsi2oCBpxAhXf/BgybLsywMAAAB4Cgor5MiDD0rVqpn2mjXSl1/amwcAAADwBBRWyJFChaRRo1z9554zMwUCAAAA/ozCCjnWpo0UHW3a27dLH35obx4AAADAbhRWyDGHQ3r5ZVd/6FApJcW+PAAAAIDdKKyQK02aSLfdZtr790szZtiZBgAAALAXhRVybfRoV3vkSOnkSfuyAAAAAHaisEKu1akj3XefaR85Io0fb28eAAAAwC4UVsiTUaOkwEDTfvVVKTbW3jwAAACAHSiskCfXXCP16GHap06ZSwIBAAAAf0NhhTwbOlQqUcK0Z8yQfvvN3jwAAABAQaOwQp6VLSs9/bRpp6WZRYMBAAAAf0JhhXwxYIAUEWHan30mrV1rbx4AAACgIFFYIV+UKCENH+7qP/OMZFm2xQEAAAAKFIUV8k3XrtJ115n2Dz9IX31lbx4AAACgoFBYId8ULiyNGePqDxpk7rkCAAAAfB2FFfJVu3bSzTeb9q+/Su+8Y28eAAAAoCBQWCFfORzSuHGu/tCh0unT9uUBAAAACoJHFVYrV67UnXfeqaioKDkcDs2fPz/T45ZlaejQoSpXrpyKFi2qZs2aaffu3Zn2OXbsmDp16qSQkBCFhYWpa9euSkxMLMDfAo0aSXfeadoHD0qTJtmbBwAAAHA3jyqsTp06pRtuuEFTp07N8vFx48Zp0qRJmjZtmtatW6fixYurRYsWSkpKytinU6dO2r59uxYvXqyvvvpKK1euVPfu3QvqV8C/Xn5ZCghwtY8etTcPAAAA4E4eVVi1atVKL730ktq1a3feY5ZlaeLEiRoyZIjatGmjmjVr6t1339WhQ4cyzmzt2LFDCxcu1Ntvv63o6Gg1bNhQkydP1scff6xDhw4V8G/j36pVkx591LTj46VRo+zNAwAAALhToN0Bsmvfvn2KjY1Vs2bNMraFhoYqOjpaa9as0QMPPKA1a9YoLCxMdevWzdinWbNmCggI0Lp167Is2CQpOTlZycnJGf2EhARJktPplNPpdNNvlD1Op1OWZdmeIzeGDZM+/NChM2ccmjrVUu/elipWtDtVZt48vt6A8XUvxte9GF/3Ynzdi/F1L8bXvTxtfLObw2sKq9jYWElSREREpu0REREZj8XGxqps2bKZHg8MDFTp0qUz9snKmDFjNGLEiPO2HzlyJNNlhnZwOp2Kj4+XZVkKCPCoE4yXVLiw9NhjJTR5cgmlpDj01FNJeuONeLtjZeLN4+sNGF/3Ynzdi/F1L8bXvRhf92J83cvTxvfkyZPZ2s9rCit3Gjx4sAYMGJDRT0hIUPny5RUeHq6QkBAbk5kDy+FwKDw83CMOrJwaMUL68ENLR486NG9eUQ0aFKRzTijaztvH19Mxvu7F+LoX4+tejK97Mb7uxfi6l6eNb3BwcLb285rCKjIyUpIUFxencuXKZWyPi4tTrVq1MvY5fPhwpu87e/asjh07lvH9WQkKClJQUNB52wMCAjzif6bD4fCYLDlVqpS5JLBvX9N/+ukALV9upmX3FN48vt6A8XUvxte9GF/3Ynzdi/F1L8bXvTxpfLObwf6k2VSpUiVFRkZqyZIlGdsSEhK0bt06xcTESJJiYmJ04sQJbdy4MWOfpUuXyul0Kjo6usAzw+jRQ7r2WtNeuVJasMDePAAAAEB+86jCKjExUVu2bNGWLVskmQkrtmzZogMHDsjhcKh///566aWXtGDBAm3btk0PP/ywoqKi1LZtW0lS1apV1bJlS3Xr1k0//fSTfvzxR/Xu3VsPPPCAoqKi7PvF/FyRIpkXDX7mGSk11b48AAAAQH7zqMJqw4YNql27tmrXri1JGjBggGrXrq2hQ4dKkp555hn16dNH3bt3V7169ZSYmKiFCxdmuu7xgw8+UJUqVXTrrbfq9ttvV8OGDTVjxgxbfh+4tGljFg6WpN9+k6ZPtzcPAAAAkJ8clmVZdofwNAkJCQoNDVV8fLxHTF5x+PBhlS1b1iOuMc2L9eulm24y7TJlpL17pdBQezP50vh6IsbXvRhf92J83YvxdS/G170YX/fytPHNbm1gf1L4jXr1pI4dTfvoUWnMGHvzAAAAAPmFwgoFavRoKX0CxokTpf377UwDAAAA5A8KKxSoChWk/v1NOzlZev55W+MAAAAA+YLCCgVu8GBzj5Ukffih9NNP9uYBAAAA8orCCgUuNFQaPtzVf+opiSlUAAAA4M0orGCLHj2k664z7R9+kL74wt48AAAAQF5QWMEWhQufv2hwSop9eQAAAIC8oLCCbe66S7rlFtPevZtFgwEAAOC9KKxgG4dDGj/e1R8xQjpxwrY4AAAAQK5RWMFWdetKnTqZ9tGj0ksv2ZsHAAAAyA0KK9hu9GgpONi0J02S9uyxNw8AAACQUxRWsN2VV5op1yUpNVV6+ml78wAAAAA5RWEFj/Dss1K5cqY9f760dKmtcQAAAIAcobCCRyhRQhozxtV/8kkpLc2+PAAAAEBOUFjBYzz0kFSnjmlv3SrNmmVvHgAAACC7KKzgMQICpIkTXf3nn5fi422LAwAAAGQbhRU8SsOG0n33mfaRI9KoUfbmAQAAALKDwgoeZ+xYKSjItCdOZPp1AAAAeD4KK3icihWlgQNNOzVVeuYZW+MAAAAAl0RhBY80aJAUGWna8+ZJy5bZmwcAAAC4GAoreKSSJaXRo119pl8HAACAJ6Owgsfq3FmqXdu0f/5Zmj3b3jwAAADAhVBYwWNlNf16QoJtcQAAAIALorCCR2vcWLrnHtM+fDjz5YEAAACAp6CwgscbN04qUsS0X3tN2rvX3jwAAADAf1FYweNVqiQNGGDaKSmuqdgBAAAAT0FhBa/w3HNSuXKm/cUX0qJF9uYBAAAAzkVhBa9QsqQ0dqyr36+fOXsFAAAAeAIKK3iNTp2kmBjT3rVLmjLF3jwAAABAOgoreI2AAGnSJMnhMP3hw6XYWFsjAQAAAJIorOBl6taVunY17ZMnzb1XAAAAgN0orOB1Ro2SQkNNe/Zs6aef7M0DAAAAUFjB65QtK40Y4er36SM5nfblAQAAACis4JWeeEKqVs20f/pJevdde/MAAADAv1FYwSsVLiy9/rqrP2iQlJBgXx4AAAD4NworeK1mzaS77zbtuDjpxRftzQMAAAD/RWEFr/bqq1JwsGlPnCjt3GlrHAAAAPgpCit4tYoVpWeeMe2zZ6X+/SXLsjMRAAAA/BGFFbzes89K5cub9qJF0ldf2ZsHAAAA/ofCCl6vWDFzSWC6/v2lpCTb4gAAAMAPUVjBJ9xzj9SkiWn//rs0frytcQAAAOBnKKzgExwOadIkqVAh0x81Stq/39ZIAAAA8CMUVvAZNWpIffuadlKSuSQQAAAAKAgUVvApw4dLkZGm/cUX0tdf2xoHAAAAfoLCCj4lJCTzRBZ9+zKRBQAAANyPwgo+p0MH6ZZbTPv336Vx4+zNAwAAAN9HYQWf43BIU6e6JrIYM8YUWAAAAIC7UFjBJ1Wv7pq8goksAAAA4G4UVvBZw4ZJUVGm/eWX5gsAAABwBwor+KySJTNPZNGvn3TmjH15AAAA4LsorODT7r9fatrUtPftk8aOtTcPAAAAfBOFFXyawyFNmSIFBpr+yy9Le/famwkAAAC+h8IKPq9aNenJJ007OdmsbWVZ9mYCAACAb/GqwiotLU0vvPCCKlWqpKJFi+rqq6/Wiy++KOucd8mWZWno0KEqV66cihYtqmbNmmn37t02poYnGDpUuvxy0/7mGyayAAAAQP7yqsJq7NixevPNNzVlyhTt2LFDY8eO1bhx4zR58uSMfcaNG6dJkyZp2rRpWrdunYoXL64WLVooKSnJxuSwW4kS0muvufp9+0qnT9uXBwAAAL7Fqwqr1atXq02bNmrdurUqVqyoe+65R7fddpt++uknSeZs1cSJEzVkyBC1adNGNWvW1LvvvqtDhw5p/vz59oaH7e65R2rWzLT/+EN68UV78wAAAMB3BNodICfq16+vGTNm6LffftN1112nn3/+WatWrdKECRMkSfv27VNsbKyapb97lhQaGqro6GitWbNGDzzwQJbPm5ycrOTk5Ix+QkKCJMnpdMrpdLrxN7o0p9Mpy7Jsz+ErJk2SatVyKCXFofHjLd1/v1MREYyvu3D8uhfj616Mr3sxvu7F+LoX4+tenja+2c3hVYXVoEGDlJCQoCpVqqhQoUJKS0vTqFGj1KlTJ0lSbGysJCkiIiLT90VERGQ8lpUxY8ZoxIgR520/cuSI7ZcQOp1OxcfHy7IsBQR41QlGj1SqlNSnTwm9+moJnT3rUI8eaZo16wTj6yYcv+7F+LoX4+tejK97Mb7uxfi6l6eN78mTJ7O1n1cVVp988ok++OADffjhh6pevbq2bNmi/v37KyoqSp07d8718w4ePFgDBgzI6CckJKh8+fIKDw9XSEhIfkTPNafTKYfDofDwcI84sHzByJHSF19Y2rPHoZ9+CtKiReXUt28JxtcNOH7di/F1L8bXvRhf92J83YvxdS9PG9/g4OBs7edVhdXTTz+tQYMGZVzSV6NGDf3xxx8aM2aMOnfurMjISElSXFycypUrl/F9cXFxqlWr1gWfNygoSEFBQedtDwgI8Ij/mQ6Hw2Oy+IJixaQ33pBuu830X3opRJ06SRERjK87cPy6F+PrXoyvezG+7sX4uhfj616eNL7ZzWB/0hw4ffr0eb9YoUKFMq57rFSpkiIjI7VkyZKMxxMSErRu3TrFxMQUaFZ4tubNpQ4dTPv48QA9+6zD3kAAAADwal5VWN15550aNWqUvv76a+3fv1/z5s3ThAkT1K5dO0mmsu3fv79eeuklLViwQNu2bdPDDz+sqKgotW3b1t7w8DgTJkihoWYNtHfecWjFCpsDAQAAwGt51aWAkydP1gsvvKAnnnhChw8fVlRUlHr06KGhQ4dm7PPMM8/o1KlT6t69u06cOKGGDRtq4cKF2b42Ev4jMlIaNcpS797mbFXPntKWLVKRIvbmAgAAgPdxWJZl2R3C0yQkJCg0NFTx8fEeMXnF4cOHVbZsWY+4xtTXpKY6FR19Vps3m2pq1CjpuedsDuVDOH7di/F1L8bXvRhf92J83YvxdS9PG9/s1gb2JwVsVKiQNHZsggICzOcLL74o/f67zaEAAADgdSis4Pdq1Dirvn1NOylJ6tVL4jwuAAAAcoLCCpA0fLilyy837YULpf/7P3vzAAAAwLtQWAGSSpaUJk1y9fv1kxIS7MsDAAAA70JhBfyrXTvpjjtM+++/pSFD7M0DAAAA70FhBfzL4ZAmT5aKFjX9KVOkdevszQQAAADvQGEFnKNiRWnECNO2LKlbNyk11dZIAAAA8AIUVsB/PPmkVKuWaW/bJr3yiq1xAAAA4AUorID/CAyU3n5bSl+PbuRIafduezMBAADAs1FYAVmoU0fq39+0k5OlHj1Y2woAAAAXRmEFXMDIkeaeK0latkyaPdvWOAAAAPBgFFbABRQvLk2b5uo/9ZQUF2dfHgAAAHguCivgIlq0kDp1Mu3jx83CwQAAAMB/UVgBl/Daa1KZMqY9d6709df25gEAAIDnobACLiE8XJowwdV/4gkpMdG+PAAAAPA8FFZANjz0kNSsmWkfOCANGWJvHgAAAHgWCisgGxwOM5FF0aKmP2mS9NNP9mYCAACA56CwArLp6qul4cNN27Kkxx6TUlNtjQQAAAAPQWEF5MCAAVKtWqa9bZv0yiu2xgEAAICHoLACciAwUHr7bSng3385I0dKO3bYmwkAAAD2o7ACcqhOHWngQNNOTpa6dpXS0uzNBAAAAHtRWAG5MGKEdO21pr1mjTRlir15AAAAYC8KKyAXihaVZs509QcPlvbutS8PAACAr9i/X5o/P1iWZXeSnKGwAnKpUSOpd2/TPnNG6tZNXvcCAAAA4EksS+re3aGePcPUvr1DR47YnSj7KKyAPBgzRqpQwbSXLZPeesvePAAAAN5s5kxpyRKHJGnTJikoyOZAOUBhBeRBiRKZi6mnnpL+/NO+PAAAAN7qr79cE4RJ0rRplkJC7MuTUxRWQB41b25mBpSkkyelHj24JBAAACAnLMu8h0pIMP377z+tli3tzZRTFFZAPhg/XoqKMu1vv5Xee8/ePAAAAN7kvfekb74x7XLlLA0fftLeQLlAYQXkg7Awado0V79/fyk21q40AAAA3uPvv6V+/Vz9N96wFBbmfZf/UFgB+eTOO6WOHU37+HHpiSe4JBAAAOBiLMu8ZzpxwvQ7dpTuusvWSLlGYQXko9dfl8LDTXvePOn//s/ePAAAAJ7sk0+k+fNNu2xZ817KW1FYAfnossukqVNd/V69pH/+sS8PAACApzp82LUmqGTeQ112mX158orCCshn99wjtWtn2keOSH362JsHAADA06RfApj+AXT79uY9lDfLU2H1zz//aOfOndq1a5eOHj2aX5kAr+ZwSG+8IZUubfoff8wlgQAAAOf6+GPps89Mu0yZzFf8eKscFVanTp3SnDlz1K5dO0VERCgiIkLVq1dXtWrVVLZsWUVERKht27aaM2eOTp065a7MgMeLjJSmTHH1e/Y0p7sBAAD83d9/m9sl0r35phQRYV+e/BKYnZ2OHj2qMWPGaPr06UpKSlLNmjXVpk0bXXXVVSpVqpQsy9Lx48e1b98+bdy4Ud26dVOfPn3Uo0cPDRo0SJd588WSQC498IA5U/X55+Y09+OPm09mHA67kwEAANgjfSHg48dN/777pHvvtTdTfslWYVWxYkVdc801euWVV9S+fXuFp097dgFHjhzRZ599phkzZmjGjBlKSF9CGfAjDof5BGblSlNYzZsnffSRa0p2AAAAf/Puu9KXX5p22bK+cQlgumxdCvh///d/2rx5sx5//PFLFlWSFB4erscff1ybNm3Sp59+mueQgLcqWzbzwsG9e0uHDtmXBwAAwC5//ZV5IeAZM7x7FsD/ylZh1aJFi1z/gLx8L+AL2reXOnQw7ePHpe7dWTgYAAD4F8uSHntMio83/QcflNq0sTdTfsvVrICxsbGX3Oenn37KzVMDPmnyZDOhhSR9/bU0Z46tcQAAAArU229LixaZdlSUNGmSvXncIVeFVfXq1fXRRx9l+VhqaqqeffZZNWjQIE/BAF9Spow53Z2uf3/pzz9tiwMAAFBg9u+XBgxw9d96SypVyrY4bpOrwqpu3bp68MEHdc899+if9FW9JG3cuFG1a9fWq6++qr59++ZbSMAX3Hmn1LmzaSckmNPhXBIIAAB8mdMpde0qJSaafpcu0u2325vJXXJVWC1atEhvvPGGvvvuO1WvXl1z587VkCFDdPPNNys5OVnLly/Xq6++mt9ZAa83caJ0+eWm/d13mc9iAQAA+Jo335SWLjXt8uWlCRPszeNOuSqsJKlHjx7aunWrLr/8cnXs2FFjxozRY489pp9//lkNGzbMz4yAzwgLk2bOdPUHDpT27bMtDgAAgNvs2SM984yrP2uWFBpqXx53y3VhZVmWPvroI/3666+KiIiQw+HQ6tWrtXv37vzMB/icFi2kbt1M+9Qpc0rc6bQ3EwAAQH5KSzPvcU6fNv3HH5eaNbM3k7vlqrDatWuXYmJi9Pzzz+vRRx/V7t27tWzZMp06dUrR0dF66aWX5OSdInBBr74qVahg2suX++bMOAAAwH9NmCD98INpV6okvfKKvXkKQq4Kq1q1aunQoUNatGiR3nzzTRUvXlyNGjXS1q1b9dhjj2nYsGG6+eab8zsr4DNKlpRmz3b1Bw2Stm+3Lw8AAEB++fln6fnnTdvhMMvMlChha6QCkavC6v7779e2bdvUvHnzTNuLFSumKVOmaPHixTpy5Ei+BAR8VdOm0pNPmnZyslkoLyXF3kwAAAB5kZQkPfSQlJpq+k8/LTVubG+mgpKrwmrOnDkKvcidZ//73/+0bdu2XIcC/MXo0VK1aqa9ZYs0fLidaQAAAPLmhRek9DKgZk1p5Eh78xSkXE9ecSkl/OF8H5BHwcHSBx9IhQub/tix0qpV9mYCAADIjeXLzX3kklSkiPT++1JQkK2RClS2CqsWLVpo5cqVOX7yZcuWqUWLFjn+PsCf1KolvfiiaTud5vR5QoKtkQAAAHIkPl56+GHJskx/9GipRg17MxW0bBVWV199tZo3b66qVatq+PDh+uGHH5SYvnzyOU6ePKnly5dryJAhqly5slq1aqVrrrkm30MDvuapp6T05d/273fdewUAAOAN+vSR/vzTtJs08c/3MtkqrN544w3t3LlTLVq00BtvvKFbbrlFYWFhKlu2rCpXrqzrrrtO4eHhKlWqlG699VZNnz5drVq10o4dOzR16tR8DXzw4EE9+OCDKlOmjIoWLaoaNWpow4YNGY9blqWhQ4eqXLlyKlq0qJo1a8baWvB4hQpJ777rmjFn1ixp/nxbIwEAAGTLp59K771n2iEhZhbAALfdcOS5ArOz09atW1WhQgVNnDhR48eP16pVq7R69Wrt3LlTR48elSSVKVNGVapUUUxMjBo2bKjC6TeN5KPjx4+rQYMGatq0qb799luFh4dr9+7dKlWqVMY+48aN06RJk/TOO++oUqVKeuGFF9SiRQv9+uuvCg4OzvdMQH6pVMmsZ9Wli+l36ybFxEgREfbmAgAAuJBDh8ziv+mmTHGt1elvslVY1a5dW++99546duyowMBAjRw5Us8//7yee+45d+fLZOzYsSpfvrxmn7MAUKVKlTLalmVp4sSJGjJkiNq0aSNJevfddxUREaH58+frgQceKNC8QE498oi0YIE5W/XPP1LXrtKXX5o1IAAAADyJZZkPhI8dM/177jHLx/irbBVWRYsW1enTpzP6y5cv12OPPea2UBeyYMECtWjRQvfee69WrFihyy+/XE888YS6desmSdq3b59iY2PVrFmzjO8JDQ1VdHS01qxZc8HCKjk5WcnJyRn9hH9nDnA6nXI6nW78jS7N6XTKsizbc/gqTxzfadOkNWsciotz6OuvpenTnere3e5UueOJ4+tLGF/3Ynzdi/F1L8bXvRhf4803pUWLzDV/5cpZeuMNS5blmsAitzxtfLObI1uF1Q033KAJEyaoUKFCGetXrV+//pKX1t19993ZCpFdv//+u958800NGDBAzz33nNavX6++ffuqSJEi6ty5s2JjYyVJEf+5dioiIiLjsayMGTNGI0aMOG/7kSNHlJSUlK+/Q045nU7Fx8fLsiwF+OPFqm7mqeM7fnyQHnrIXOI6YIB0ww1HValSms2pcs5Tx9dXML7uxfi6F+PrXoyvezG+0p49hfTUU5dl9MePP660tBQdPpz35/a08T158mS29nNY1qVryg0bNuiee+7RgQMHzDc5HLrUtzkcDqWl5e8bwSJFiqhu3bpavXp1xra+fftq/fr1WrNmjVavXq0GDRro0KFDKleuXMY+9913nxwOh+bOnZvl82Z1xqp8+fI6fvy4QkJC8vV3yCmn06kjR44oPDzcIw4sX+PJ49uzp0MzZphrAG++2dKKFZYCs/VRiOfw5PH1BYyvezG+7sX4uhfj617+Pr4pKVKjRg5t2GDep/TsaWnKlDyepjqHp41vQkKCSpUqpfj4+IvWBtl6m1a3bl3t2bNHe/fuVVxcnJo0aaLnn38+0yV3BaFcuXKqVq1apm1Vq1bVZ599JkmKjIyUJMXFxWUqrOLi4lSrVq0LPm9QUJCCsli9LCAgwCP+ZzocDo/J4os8dXxffVVaulTas0dau9ahUaMcyuLEqsfz1PH1FYyvezG+7sX4uhfj617+PL4jRkjpk3Jfd530yisOBQTk7w3hnjS+2c2Q7c+/AwMDVblyZVWuXFmdO3fWHXfcoejo6FwHzI0GDRpo165dmbb99ttvqvDv1COVKlVSZGSklixZklFIJSQkaN26derZs2eBZgXyqkQJs2J5gwZSWpr00ktSs2ZSo0Z2JwMAAP5q6VJp7FjTLlxY+vBDqXhxezN5ilyVgLNnzy7wokqSnnzySa1du1ajR4/Wnj179OGHH2rGjBnq1auXJFPZ9u/fXy+99JIWLFigbdu26eGHH1ZUVJTatm1b4HmBvIqOlkaONG2nU+rUSTp+3N5MAADAPx09Kj30kGtyilGjpDp17M3kSew/t5YD9erV07x58/TRRx/p+uuv14svvqiJEyeqU6dOGfs888wz6tOnj7p376569eopMTFRCxcuZA0reK1nn5VuucW0//zTrBWR19l2AAAAcsKypMceM+tWSdKtt0oDB9qbydN42a3w0h133KE77rjjgo87HA6NHDlSI9M/5ge8XKFCZjXzG24wZ6s++URq2VJ69FG7kwEAAH/x1ltmnU1JKlNGevddyQNuf/IoDAfgBcqXNy9o6fr0kX77zb48AADAf+zYIfXv7+rPnClFRdkWx2NRWAFeon176d+1sHXqlNSxo5nuFAAAwF2Sk6UOHaQzZ0y/Z0+pTRt7M3kqCivAi7z2mlS5smlv3Ci98IK9eQAAgG8bPFj6+WfTrlZNGj/e3jyejMIK8CLFi0sffWSmN5WkceOk77+3NxMAAPBNCxeaD3UlKSjIvAcpVszeTJ6MwgrwMrVrSy+/7Oo//LD0zz/25QEAAL7n8GHpkUdc/XHjpJo1bYvjFSisAC/Uv790222m/fffUteuTMEOAADyh2WZ2Yfj4ky/VSszcRYujsIK8EIBAdI770jh4aa/YIH05pv2ZgIAAL5h8mTpm29MOyJCmjNHcjhsjeQVKKwALxUZKc2e7eoPGCBt3WpfHgAA4P02bpSeftrVnzNHKlvWtjhehcIK8GKtW7tOzScnS/fdJyUm2psJAAB4p4QE6f77Xcu5DBggtWxpbyZvQmEFeLlXXpFuvNG0d+2SevWyNw8AAPA+liV17y7t3Wv6N90kjRljbyZvQ2EFeLmgIGnuXKlkSdN/911z2h4AACC73n7bvJ+QpNBQ6eOPpSJF7M3kbSisAB9wzTXSjBmufq9e0q+/2pcHAAB4j23bpL59Xf2ZM6VKlezL460orAAf8cADUrdupn36tLlG+vRpezMBAADPduqUuUc7Kcn0n3hCat/e3kzeisIK8CGvvy5df71p//KLWe8KAADgQnr3lnbuNO0bbpBefdXePN6MwgrwIUWLSp98IhUrZvpvvSV99JG9mQAAgGc6977s4sXNe4jgYFsjeTUKK8DHVK0qvfGGq9+9u7R7t315AACA59m501z2l276dOm66+zL4wsorAAf1Lmz9PDDpp2YmPnaaQAA4N/OnDH3Yp86ZfpdukidOtmbyRdQWAE+aupUqUoV096yJfMq6gAAwH8NGCBt3Wra1apJkybZm8dXUFgBPqpECbMeRfq10lOmSJ99Zm8mAABgr08+kaZNM+30e7OLF7c3k6+gsAJ8WM2aZqbAdF26cL8VAAD+audOqWtXV3/yZKl6dfvy+BoKK8DHdetm1riSpIQE6Z57WN8KAAB/c+qUeQ+QmGj6Dz5oPnBF/qGwAnycw2GmXU+/32rrVrNmBQAA8A+WJT3+uLR9u+lXr24uB3Q47M3layisAD9QooS5vyp9favZs6WZM+3NBAAACsb06dL775t2+nsC7qvKfxRWgJ+oVs2cuUrXq5e0ebN9eQAAgPtt2CD16+fqz5olVa5sXx5fRmEF+JGOHV2LASYnm2utT5ywNRIAAHCTY8fM3/qUFNPv10+69157M/kyCivAz0yYIN10k2n//rtZTNjptDcTAADIX06n9PDD0h9/mH5MjDRunL2ZfB2FFeBngoLMmhWlS5v+ggXS+PH2ZgIAAPnr5Zelr7827csuM2tbFilibyZfR2EF+KEKFaQPPnDNBjR4sLRihb2ZAABA/li6VHrhBdN2OKQPP5TKl7c3kz+gsAL8VMuW0pAhpu10SvffL/39t72ZAABA3hw8KHXo4LrMf/hwqXlzWyP5DQorwI8NG+Z6sY2LMwsJnz1rbyYAAJA7qanmb/nhw6bfooXrQ1S4H4UV4McKFTKXBF5xhemvXCkNGmRvJgAAkDtPPy2tWmXa5cubtasCeLdfYBhqwM+Fh5vJLAIDTf/VV6WPP7Y3EwAAyJn335def920CxeWPv3UTFqBgkNhBUAxMa4XY0nq2lXautW+PAAAIPs2b5a6dXP1p06VoqPty+OvKKwASJJ69pQeecS0T5+W2rUzCwsCAADP9c8/5m92UpLpd+uWuchCwaGwAiDJTMf65ptS3bqm//vvUseOUlqavbkAAEDWzp41k1WkLwIcHS1NnmxvJn9GYQUgQ3Cw9Pnn5r4rSVq0yLUOBgAA8CyDB0tLlph2RIT02WdSUJC9mfwZhRWATMqXN5NZFCpk+mPGSP/3f/ZmAgAAmc2dK40fb9qBgWayissvtzeTv6OwAnCeJk3M7IDpHnlE2r7drjQAAOBcW7dKXbq4+hMnSo0a2RYH/6KwApClvn2lBx807VOnpLZtpRMn7EwEAACOHTOTVZw+bfqdO0tPPGFvJhgUVgCy5HBI06dLtWub/p49ptByOu3NBQCAv0pLMxNL/f676depYyaecjjszQWDwgrABRUrZiazKFPG9L/+Whoxwt5MAAD4q6FDzcRSkln89/PPpaJF7c0EFworABdVsaL08cdSwL+vFiNHSvPm2RoJAAC/88kn0ujRpl2okOlfeaW9mZAZhRWAS2rWTBo71tV/6CHp55/tywMAgD/ZuNFMJJXulVekpk1ti4MLoLACkC0DB5rruiUzmcVdd0mHD9ubCQAAX/f331KbNtKZM6b/yCNS//52JsKFUFgByBaHQ3r7bemmm0z/wAGpfXspOdneXAAA+KqkJDMD4MGDph8TI02bxmQVnorCCkC2FS0qzZ8vRUWZ/qpVZopXy7I1FgAAPseypO7dpXXrTP+KK8xkFUFB9ubChVFYAciRcuWkL76QgoNNf9Ys6fXX7c0EAICvGT9eeu890y5WTFqwQIqMtDcTLo7CCkCO1a0rzZnj6g8c6Jr+FQAA5M3XX0vPPuvqv/OOa11JeC4KKwC5cv/90pAhpu10mv7OnfZmAgDA223fLnXo4LrMftgw6Z577M2E7KGwApBrI0aYm2olKT5euvNO6dgxezMBAOCtjh41s+6ePGn67dubRYHhHSisAORaQID07rtSzZqmv2ePOXN19qy9uQAA8DapqdK990q//276tWqZSwADeLfuNfhfBSBPSpQwN9SGh5v+999LAwbYmwkAAG9iWVK/ftKyZaZftqyZKKp4cXtzIWcorADkWYUKZgrYwoVNf/Jk6Y037M0EAIC3mDRJevNN0y5SRJo3T7rySnszIee8urB6+eWX5XA41P+c5aeTkpLUq1cvlSlTRiVKlFD79u0VFxdnX0jATzRsaBYtTNenj/TNN/blAQDAGyxYID35pKs/Y4ZUv759eZB7XltYrV+/XtOnT1fN9Js7/vXkk0/qyy+/1KeffqoVK1bo0KFDuvvuu21KCfiXLl1c08M6nVKHDg5t3x5obygAADzUpk2ZZwB8/nmpc2d7MyH3vLKwSkxMVKdOnfTWW2+pVKlSGdvj4+M1c+ZMTZgwQf/73/9Up04dzZ49W6tXr9batWttTAz4j9GjXdPCJiY69PDDpXTokL2ZAADwNH/+Kd1xh3T6tOk/8IA0cqS9mZA3XvlRcq9evdS6dWs1a9ZML730Usb2jRs3KjU1Vc2aNcvYVqVKFV155ZVas2aNbr755iyfLzk5WcnJyRn9hIQESZLT6ZTT6XTTb5E9TqdTlmXZnsNXMb7uMWeO9OefDq1b59ChQ4V0552WVqxwqkQJu5P5Fo5f92J83YvxdS/G173yOr4nT0p33OHQ3387JEn161uaOdP697nzLabX8rTjN7s5vK6w+vjjj7Vp0yatX7/+vMdiY2NVpEgRhYWFZdoeERGh2NjYCz7nmDFjNGLEiPO2HzlyRElJSXnOnBdOp1Px8fGyLEsBzLeZ7xhf93nrrQC1bl1af/4ZqC1bHLr33mTNmnVChQrZncx3cPy6F+PrXoyvezG+7pWX8T17VnrkkTBt3RosSapQ4aymTz+qhARL/3627/c87fg9mb6w2CV4VWH1559/ql+/flq8eLGCg4Pz7XkHDx6sAefMD52QkKDy5csrPDxcISEh+fZzcsPpdMrhcCg8PNwjDixfw/i6T9my0ldfOdWokVMJCQH67rtgjRsXoddes+yO5jM4ft2L8XUvxte9GF/3yu34WpbUt69DS5aYM1VhYZa++SZAVaqEuyuqV/K04ze7dYdXFVYbN27U4cOHdeONN2ZsS0tL08qVKzVlyhQtWrRIKSkpOnHiRKazVnFxcYqMjLzg8wYFBSkoKOi87QEBAR7xP9PhcHhMFl/E+LrP9ddLb799Qh07ltLZsw5NmuTQtdc61Lu33cl8B8evezG+7sX4uhfj6165Gd/XX3ctR1K4sDRvnkPVqjnclNC7edLxm90M9ifNgVtvvVXbtm3Tli1bMr7q1q2rTp06ZbQLFy6sJUuWZHzPrl27dODAAcXExNiYHPBfjRql6I03XGep+vWTvv7axkAAANjgv9Oqv/WW1KSJbXHgBl51xqpkyZK6/vrrM20rXry4ypQpk7G9a9euGjBggEqXLq2QkBD16dNHMTExF5y4AoD7de0q7dsnjRljbsq9/35p1SqpVi27kwEA4H7/nVZ9yBCmVfdFXnXGKjtee+013XHHHWrfvr0aN26syMhIff7553bHAvzeSy9J995r2qdOSa1bm6lmAQDwZfv3m7956dOqd+jAtOq+yqvOWGVl+fLlmfrBwcGaOnWqpk6dak8gAFkKCJDeeccUU2vXSocOSS1bmjNX5yxHBwCAzzh61PytS5+cukEDadYsycFtVT7J585YAfBcRYuaa8yvucb0f/1VatNGsnlVAwAA8t3p09Kdd0q7dpl+5crSF19I+TixNTwMhRWAAhUeLi1caKZjl6QffpAefFBKS7M3FwAA+eXsWXPJ35o1ph8Zaf72lSljby64F4UVgAJ39dVmZsDixU3/s8+k/v1dN/UCAOCtLEvq3dtcoSFJJUtK334rVaxoaywUAAorALaoW9cUVIH/3uk5ZYo0bpy9mQAAyKtRo6Tp003brFXFLLj+gsIKgG1atJBmznT1Bw2S3nvPvjwAAOTF7NnSCy9k7t96q315ULAorADY6uGHpdGjXf0uXaTvvrMvDwAAufHNN1K3bq7+uHFSp0725UHBo7ACYLtBg6RevUz77FmpfXuzmCIAAN5g/XqzVmP6REz9+klPPWVvJhQ8CisAtnM4pNdfl+6+2/QTE6VWraTff7c3FwAAl7JnT+YFgO+9V5owgbWq/BGFFQCPUKiQ9P77UsOGpn/4sLkHKy7O3lwAAFzIoUNS8+bSkSOm37ix9O67UgDvsP0S/9sBeIyiRc3iiVWrmv6ePaa4OnHC1lgAAJzn+HGHWrZ0aP9+069eXZo/nwWA/RmFFQCPUrq0tGiRdOWVpv/zz9Idd7gusQAAwG6JidKDD5bS9u3mer+KFc3ES6VK2ZsL9qKwAuBxypeXFi+WwsNN/8cfzYQWKSn25gIAIDlZuvtuhzZtKiJJioyUvv9eioqyORhsR2EFwCNdd505cxUSYvoLF5qp2dNnXAIAoKCdPSt17CgtWWLOVIWFWVq0SLr6apuDwSNQWAHwWLVrS1995bpefe5cMy27ZdmbCwDgfyxLevxx6fPPTb9oUae+/NJSzZr25oLnoLAC4NEaNZL+7/+kwEDTnz5dev55ezMBAPyLZUnPPCPNnGn6hQtbmjnzhOrXtzcXPAuFFQCP17q1mb42fU2QMWOkV16xNxMAwH+MHSuNH2/aDof07ruWmjblxl9kRmEFwCt06CBNnerqP/OM9Pbb9uUBAPiH6dOlwYNd/WnTpPvusy8PPBeFFQCv0bOnNGqUq9+jh/Tpp/blAQD4to8+Mn970r38stS9u3154NkorAB4lcGDpYEDTdvpNLMzLVhgbyYAgO/5/HPpoYdcEyY984z07LP2ZoJno7AC4FUcDnN/Vdeupn/2rHTvvWY6dgAA8sM330gPPOBa4qNHD3O2CrgYCisAXsfhMNe8P/ig6aekSG3bSkuW2BoLAOADvv9euvtuKTXV9Dt3lt54wzWBEnAhFFYAvFKhQtLs2eZslSQlJ0t33imtXGlvLgCA91q5UrrrLvM3RZLuv99MsR7AO2ZkA4cJAK8VGCh98IHUpo3pnzljpmZfs8beXAAA77N2rfkbcuaM6bdtK733nvkgD8gOCisAXq1wYWnuXOn2200/MVFq2VLasMHeXAAA77Fpk/nbkZho+q1aSR9/bP7GANlFYQXA6wUFSZ99JjVrZvoJCdJtt0lbttgaCwDgBbZtk5o3l+LjTf9//zN/U4KC7M0F70NhBcAnBAdLX3whNW5s+sePmz+U27fbmwsA4Lm2bTOF1LFjpt+woVnCo2hRe3PBO1FYAfAZxYpJX30lxcSY/j//SLfeKu3caW8uAIDnSS+q/vnH9KOjpa+/looXtzcXvBeFFQCfUrKk9O23Ut26ph8XJzVtKu3YYW8uAIDnyKqoWrRICgmxNxe8G4UVAJ8TGmr+QNaqZfqxsaa4+vVXW2MBADzAhYqq0FB7c8H7UVgB8EmlS5sFg2vXNv24OKlJE+mXX2yNBQCwEUUV3InCCoDPSi+u6tQx/SNHzJmrrVvtzQUAKHgUVXA3CisAPq1UKen776V69Uz/n3/MH1amYgcA/7F1K0UV3I/CCoDPCwuTFi82f0gl6ehRM1vgpk22xgIAFIANG8zVChRVcDcKKwB+ITRU+u4711Tsx46Z4mrDBntzAQDcZ/Vq81qfvk7VzTdTVMF9KKwA+I2QEPMHtUED0z9xwvzBXbXK1lgAADdYvly67TYpIcH0Gzc2H7BRVMFdKKwA+JX0da4aNzb9hASpRQtzHxYAwDcsWiS1aiWdOmX6zZub1/6SJe3NBd9GYQXA76QXV7fdZvqnT0utW0tffmlvLgBA3n3xhXTXXVJSkunfcYe0YIFUrJi9ueD7KKwA+KVixcwf2jZtTD8lRbr7bmnuXHtzAQByb+5c6Z57zGu6ZNqffSYFB9ubC/6BwgqA3woKkj79VOrY0fTPnpU6dJBmzbI3FwAg5+bMMa/nZ8+a/oMPSh99JBUpYmss+BEKKwB+rXBh6d13pcceM33Lkrp2lSZPtjcXACD7JkyQHn1UcjpN/7HHTKEVGGhrLPgZCisAfq9QIWnGDKlfP9e2vn2lUaNMoQUA8EyWJQ0ZIg0c6NrWt680fbp5bQcKEoUVAEhyOKTXXjN/oNMNGSINGOD6BBQA4DnS0qQnnjAfgqUbPlyaOFEK4B0ubMBhBwD/cjikF1+Uxo51bZs4UercWUpNtS0WAOA/UlKkTp2kadNc2yZNkoYNM6/lgB0orADgP555Rpo50/WJ5/vvS23bmmnZAQD2OnXKzOiaPotroULmdbpPH3tzARRWAJCFLl3MFL1BQab/zTdmgcljx+zNBQD+7PhxswbhwoWmHxwszZ9vzl4BdqOwAoALaNtWWrRICgkx/dWrpVtukQ4etDUWAPilP/+UGjUyr8WSeW1etMgsAAx4AgorALiIW26RVqyQIiJM/5dfpAYNpN9+szcXAPiTX36RYmKk7dtNv2xZaflyqXFjW2MBmVBYAcAl1Kol/fijVKmS6f/xh1S/vrRmja2xAMAvrFghNWzoulrg6qulVauk2rXtzQX8F4UVAGTD1Veb4qpmTdM/elT63/+kefPszQUAvuyTT8w9VfHxpl+3rrkU8Npr7c0FZIXCCgCyqVw5aeVKU1BJUlKS1L69NHmyvbkAwBe9/rr0wANmanVJatVKWrbMXAYIeCIKKwDIgdBQ6dtvpQcfNH3Lkvr2lZ5+moWEASA/OJ3mNbV/f/MaK0mPPip98YVUooSt0YCLorACgBwqUkR6913puedc28aPlzp2NGexAAC5k5Rkpk4fP9617YUXzNqChQvblwvIDq8qrMaMGaN69eqpZMmSKlu2rNq2batdu3Zl2icpKUm9evVSmTJlVKJECbVv315xcXE2JQbgqxwOadQoado010LCc+dKLVqw1hUA5MaRI+ZS648/Nv2AAPMaO3Kkec0FPJ1XFVYrVqxQr169tHbtWi1evFipqam67bbbdOrUqYx9nnzySX355Zf69NNPtWLFCh06dEh33323jakB+LIePczlKcWKmf7KlWbGwD177M0FAN5kxw4pOto122qxYmbh3x49bI0F5Eig3QFyYmH6Mtv/mjNnjsqWLauNGzeqcePGio+P18yZM/Xhhx/qf//eXT579mxVrVpVa9eu1c0332xHbAA+7o47zHoqrVubT1x37TJvEObNY40VALiUpUulu+92zfwXFSV9+aV044325gJyyqsKq/+K//dfYOnSpSVJGzduVGpqqpo1a5axT5UqVXTllVdqzZo1FyyskpOTlZycnNFPSEiQJDmdTjltvhvd6XTKsizbc/gqxte9/Gl869Qxn7TedZdDv/7q0LFjUrNmlqZNs/TII+75mf40vnZgfN2L8XUvbxnfWbOknj0dOnvWXOt3ww2WFiywdMUVnj0hkLeMr7fytPHNbg6vLaycTqf69++vBg0a6Prrr5ckxcbGqkiRIgoLC8u0b0REhGJjYy/4XGPGjNGIESPO237kyBEl2XwnutPpVHx8vCzLUkCAV1256RUYX/fyt/EtXlyaN8+h7t3DtGJFkFJTHera1aHNmxM1eHCi8nsI/G18Cxrj616Mr3t5+vg6ndKYMSU0ZYprmr9mzZI0bVq8ihSxdPiwjeGywdPH19t52viePHkyW/t5bWHVq1cv/fLLL1q1alWen2vw4MEaMGBARj8hIUHly5dXeHi4QkJC8vz8eeF0OuVwOBQeHu4RB5avYXzdyx/Ht2xZ6bvvpCeftPTGG+YT2ClTSujgweJ65x1LxYvn38/yx/EtSIyvezG+7uXJ43vqlPTIIw59/rlrRoo+fSy9+moRFSoUbmOy7PPk8fUFnja+wcHB2drPKwur3r1766uvvtLKlSt1xRVXZGyPjIxUSkqKTpw4kemsVVxcnCIjIy/4fEFBQQoKCjpve0BAgEf8z3Q4HB6TxRcxvu7lj+NbpIg0dapUtarUr5/5ZHbePIf++MOhBQukyy/Pv5/lj+NbkBhf92J83csTx/ePP6Q2baSffzb9gABp4kSpTx+HJO+a+s8Tx9eXeNL4ZjeD/UlzwLIs9e7dW/PmzdPSpUtVqVKlTI/XqVNHhQsX1pIlSzK27dq1SwcOHFBMTExBxwXg53r3lr7+WipZ0vQ3bZLq1ZPWrrU3FwDY4YcfzGtgelFVsqSZpKJPH3tzAfnFqwqrXr166f3339eHH36okiVLKjY2VrGxsTpz5owkKTQ0VF27dtWAAQO0bNkybdy4UY8++qhiYmKYERCALVq2NJNaVKxo+n//Ld1yi7lhGwD8xYwZZo2qI0dM/5prpHXrpNtvtzcXkJ+8qrB68803FR8fryZNmqhcuXIZX3Pnzs3Y57XXXtMdd9yh9u3bq3HjxoqMjNTnn39uY2oA/q56demnn1xTr6ekSF27mk9pU1PtzQYA7pSaKvXqZdajOnvWbGve3LwmVq1qbzYgv3nVPVaWZV1yn+DgYE2dOlVTp04tgEQAkD3h4dL330tPPmnuv5KkKVOkX36RPvnEPA4AvuSff6R77zXr/KV78klp3Dgp0KvegQLZ41VnrADAmxUubIqpt982E1xI5g1HvXrSli12JgOA/JV+T2l6UVWkiLkEesIEiir4LgorAChgXbuaNxvlypn+H39I9etLH31kaywAyBezZ5vXtP37TT8iwrzmPfqonakA96OwAgAbxMRIGzZI0dGmf+aM1LGj1LevuQcLALxNcrK5l6pLF9OWzGvchg3mNQ/wdRRWAGCTqKjzP8WdPNnMGvjXX7bFAoAcO3BAatTIzP6XrmdPacUK6ZwlRwGfRmEFADYKDpZmzpSmT3fdd7V2rVS7tpnsAgA83ZIlUp060vr1ph8cLM2ZI73xhhQUZGs0oEBRWAGAzRwOqXt36ccfpQoVzLZ//pFuu00aNUpyOu3NBwBZcTqlMWPMa9U//5htlSqZtfs6d7Y3G2AHCisA8BB165qZtFq1Mn3LkoYMke66Szp+3N5sAHCuI0ek1q2l555zffhz++3Sxo1SrVq2RgNsQ2EFAB6kdGnpq6+kF180Z7Ik6euvzaWBa9famw0AJGnlSlM8LVxo+g6HNGyY9OWXUqlStkYDbEVhBQAeJiDAnKlatEgqU8Zs++MPc2P4uHFcGgjAHk6nuTy5aVPp0CGzrWxZ6bvvpOHDzWsX4M/4JwAAHqp5c2nzZqlBA9M/e1Z69llzqWBcnL3ZAPiXuDipZUvzoU/6hztNm5rFzZs1szUa4DEorADAg5Uvb6ZkHzLEdWngd9+Zy3CYNRBAQVi2zLzmLF5s+g6HOUO1eLFroXMAFFYA4PECA809V4sXS5GRZltsrNSypUNjxpTQ2bP25gPgm1JSpEGDpFtvNa85knkNWrLE3FNVqJC9+QBPQ2EFAF7i1luln3+WWrQwfctyaNKkEmrSxKG9e+3NBsC37NolxcRIY8eaGUolc3nyli3mEkAA56OwAgAvUras9M03ZhKLwEDzbmfNGodq1ZJmzXK9AQKA3LAsacYMMxPppk1mW+HCpsD69lspIsLefIAno7ACAC8TECA9/bS0cqWlChXMdYCJiVLXrtLdd5v1ZQAgp44ckdq1k3r0kM6cMdsqVzZLPTzzDJf+AZdCYQUAXio6Wvr++6Pq0sV1mmr+fKlGDXNWCwCya9EiqWZN6YsvXNsef9yctbrxRvtyAd6EwgoAvFiJEpbeesvSvHnSZZeZbXFxUuvWUq9e0unT9uYD4NlOnjQFVMuWrgkqLrvMFFhvvikVK2ZvPsCbUFgBgA9o21bats2scZXujTfMfRKrV9sWC4AHW7bMnKWaPt21rUUL81py11325QK8FYUVAPiIyEjp669NQVW0qNn2229Sw4bSgAGcvQJgnDol9e0r/e9/0v79ZluxYtLUqeYy4vRlHQDkDIUVAPgQh0Pq2VPavNncgyWZWb5ee0264QZp1Sp78wGw148/msV+J092bWvc2JyleuIJMzkOgNzhnw8A+KDKlc0bqFdekYKCzLY9e8wbqP79zSfWAPzH6dPSwIFSo0bmtUAyZ7YnTjSXBF51la3xAJ9AYQUAPqpQIempp8yCnjExZptlSa+/bs5erVhhazwABWTxYun666UJE1xr3cXEmNeGfv04SwXkF/4pAYCPq1JF+uEH6dVXpeBgs23vXqlJE6lbN+nYMVvjAXCTo0cdeuQRh267Tdq3z2wLCjJnsn/4QbruOnvzAb6GwgoA/EChQmYCi59/lho0cG1/+22palXpww9dn2QD8G6WJX3wgdS4cbjee8+Rsb1JE2nrVnMmm8V+gfxHYQUAfuS668wlgJMnSyVLmm2HD0udOpl1bPbutTcfgLzZv1+6/Xbp4YcDdOyYeZsXFmY+RFm6lLNUgDtRWAGAnylUSOrdW9qxQ7r7btf2774z92G8/LKUmmpfPgA5l5wsjRkjVa8uLVzo2n7PPZZ27JC6djWzhgJwHworAPBTl18uffaZ9MUX0hVXmG1JSdLgwdKNNzK5BeAtFi82C/0+95xrvbrLL7c0Z85xzZ1rsS4VUEAorADAz911l/Trr2Ya9vTZwX75xdyP0aGD9NdfdqYDcCF//inde690221mMXDJ/Bvu00f65RdLLVok2xsQ8DMUVgAAlSxpFhH+6SepTh3X9o8/NrMKvvyyudQIgP1SUqSxY82/zf/7P9f2+vWljRulSZOkkBD78gH+isIKAJChTh1p3TppxgypTBmz7dQpc3lgjRrSN9/Ymw/wZ5Zl/g3ecIM0aJDrsr/wcGnOHDOFeq1adiYE/BuFFQAgk0KFzPpWv/0m9erlujxw926pdWvpzjulnTvtzQj4m19+kVq0MP8G0//9BQSYiWh++03q3JmFfgG78U8QAJCl0qWlKVOkTZukRo1c27/6yswe2Lu3dOSIffkAf3D4sPT44+Ys1eLFru3160sbNpilE8LCbIsH4BwUVgCAi7rhBjND4AcfSFFRZltamjR1qnT11eb+qzNn7M0I+JqkJGncOOnaa6Xp0yWn02yvUEGaO1datUqqXdvejAAyo7ACAFySwyF17GguORo5Uipe3Gw/edLcf1W5svT++643fwByJy3N/FuqWlV69lkpIcFsL1nSrFO1c6d0332sSQV4IgorAEC2FS8uvfCCtGeP1L27656OP/+UHnpIqldPWrTI3GQPIPssS/rySzP5xEMPSfv3m+0BAebf2u7dZsKK4GA7UwK4GAorAECORUaay5N+/llq1cq1fdMmqWVL6ZZbzAxlAC5t5UqpYUOzptwvv7i2N28ubd5s/q1FRNiXD0D2UFgBAHLt+uvN9M/ffWfuxUr3ww9S48amyNqwwb58gCfbvNl8MHHLLdLq1a7tN90kLVli/l3VrGlfPgA5Q2EFAMiz5s3N2aqPP5auu861fdEic3ng3Xdn/iQe8GebN0vt2kk33igtXOjaXrWq9Pnn0tq10v/+Z18+ALlDYQUAyBcBAdL990vbt0uzZ0sVK7oemzfPfPJ+773Sli12JQTstWGDudzvxhul+fNd26+80vyb2bbNFFxMTAF4JworAEC+CgyUHnlE2rXLTMlerpzZblnS//2fmSL6jjukNWtsjQkUmHXrzMK+9eqZCSrSRUVJr79uZtt85BGzODcA70VhBQBwiyJFpCeeMDMIjh+f+eb7r782C5zeequ0bBmzCML3WJY5tlu0kG6+2dyLmO6KK8zi23v3Sn37SkFB9uUEkH8orAAAblWsmDRwoLRvn3kzWb6867GlS829JA0amMsF09Lsywnkh7NnzQK+9eqZY/u771yPXXmlNG2a+bChVy+mTgd8DYUVAKBAFC1q3kzu2SPNnCldc43rsTVrzAQXlSub4uvUKftyArlx6pQ0ebJ07bXSAw9IGze6HqtUSXrrLbMWVY8enKECfBWFFQCgQBUpInXpIu3YIX3wgVS9uuuxvXulPn3MWa3Bg6WDB+3LCWTHoUNm0ewrrzSX9aUv7CuZSSo++sjcQ/XYY+bYB+C7KKwAALYIDJQ6dpS2bjX3nzRr5nrs+HHp5ZfNzIIPPWRu/uc+LHgKyzJrtd1/v1ShgvTSS9KxY67HW7Y061Bt2GDOXgUG2pcVQMGhsAIA2CogwCySunix9PPPUufOUuHC5rGzZ6X33zc3/9epYy6n4jJB2OXUKWnGDKlWLbMA9iefmGNUMsXTww+bDwq+/dbcX8W06YB/obACAHiMmjWlOXOkP/6Qnn9eKl3a9djmzVL37maK6j59pF9/tS0m/MyOHdKAAdLll5t7pLZudT1Wtqw0ZIiZnOWdd6QaNezLCcBeFFYAAI9Trpy5vOrPP81EF3Xruh5LSDATXFSvLt1yi/Tee5zFQv47eVJ6+22zLEC1atJrr0nx8a7HY2LM2dQDB6QXXzRTqAPwbxRWAACPVayYmehi/Xrz1aWLmV0w3cqV5vKryEjz2MqV3IuF3Eu/d+rRR80x1a1b5oWsg4LMYxs2SKtXS506McMfABcKKwCAV6hb15y9OnhQmjhRqlLF9VhiojR7tjmDdc010siRmWdnAy5m925zzFSubO6dmjNHOn3a9XiNGuaYO3hQmjXL3O8HAP9FYQUA8CqlSkn9+pl7rH780ZxVCAlxPf7779KwYWbtoAYNpEmTzJTYwLkOHpQmTDAL+V53nTlmdu92PR4aKvXsac6U/vyzOebKlLEvLwDPR2EFAPBKDoe5/2XGDOnvv82aWM2bZ56JbfVq84b4iivM2aw33pDi4uzLDHsdOWKOl6ZNzVppAweay/rO1bSpuXfq0CFzvNSty+x+ALKHlRUAAF6vWDGzJlbHjmbCi/fekz78UNq+3TxuWeb+q5UrzYyCTZpI7dpJd95p1iGC79q7V/riC2n+fHOG0+k8f58bb5Q6dDDrUpUvX+ARAfgInz1jNXXqVFWsWFHBwcGKjo7WTz/9ZHckAEABKF9eeu456ZdfzNfQoebemXROp7R0qSmwKlY0U7wPGWIWIc7qTTe8i2VJmzaZ/+81a5p77gYONJNSnPv/N/3yv507pY0bpaeeoqgCkDc+ecZq7ty5GjBggKZNm6bo6GhNnDhRLVq00K5du1S2bFm74wEACkj16tKIEdLw4dK2bdLcueZr717XPtu2ma9Ro6SICKl1a6llS3NWC97h8GGzwPR335mv2Nis96tSRWrbVrrnHnOWikv8AOQnh2X53sS00dHRqlevnqZMmSJJcjqdKl++vPr06aNBgwZd8vsTEhIUGhqq+Ph4hZx7R7QNnE6nDh8+rLJlyyogwGdPMNqG8XUvxte9GN/csSxTSH35pflaty7r/RwOSzVqnFXLloFq3tyhBg0yT/WOvMnL8ZucbKZB/+47adEic4bqQm6+2RRTbdpknknS1/H64F6Mr3t52vhmtzbwuTNWKSkp2rhxowYPHpyxLSAgQM2aNdOacxejOEdycrKSk5Mz+gkJCZLM/1SnzdeFOJ1OWZZlew5fxfi6F+PrXoxv7l1/vfkaPNic3fj6a+mrrxxavFg6c8acxrAsh7ZuLaytW6Vx46SgIEsNG0qNGlmqX1+KjpZKlLD5F/FiOTl+T540E5GsWuXQqlWmGE5Ozvp0U7Filpo0ke64w9Jdd5nFpl0/M5/CewFeH9yL8XUvTxvf7ObwucLqn3/+UVpamiIiIjJtj4iI0M6dO7P8njFjxmjEiBHnbT9y5IiSkpLckjO7nE6n4uPjZVmWR1TsvobxdS/G170Y3/wREGAmsbjzTunMGWnNmiJatSpIK1cW0fbthTP2S052aMkSackS84a+UCFL1aqdVb16KapXL1X16qXo8ss9402AN7jQ8WtZ0oEDhfTzz4W1cWNhrV1bRL/8Eiin88LX7V1/faqaNElWkyYpqls3JdOivYcPu/O38Fy8PrgX4+tenja+J0+ezNZ+PldY5cbgwYM1YMCAjH5CQoLKly+v8PBwj7gU0OFwKDw83CMOLF/D+LoX4+tejK97VKggPfCAGd8dO+K0detlWro0QN9/Lx044Hpzn5bm0LZthbVtW2HNmmW2RURYql3b3L9Tq5alG280E2RwL8/5zCfADqWkhGvTpgBt2ODQhg1mIoljxy4+YFddZc4e3nqrpebNpYiIQpKK/fsFidcHd2N83cvTxjc4ODhb+/lcYXXZZZepUKFCivvPQiVxcXGKjIzM8nuCgoIUdO7HW/8KCAjwiP+ZDofDY7L4IsbXvRhf92J83Ss83FKHDg516uSQZUn79plL0n780Xz98os5w5IuLs6hhQulhQslyRQHYWFS7drm0sOqVc19PlWqSJGR/lNwWZY5c7R9+7lfDm3fHqHjxy997F5/vdSokdS4sfnv5ZenD5yfDGAu8frgXoyve3nS+GY3g88VVkWKFFGdOnW0ZMkStW3bVpKpepcsWaLevXvbGw4A4LUcDumqq8zXgw+abSdOSGvXmmJrzRozicKxY5m/78QJadky83Wu0FBXkXX11eZMWYUK5gzX5ZdLgV72FzotzSyq+/vvpgD9/XfX12+/SUeP/vc7HMqqMAoPl+rVM19160oxMVKZMgXxGwBA3njZy3b2DBgwQJ07d1bdunV10003aeLEiTp16pQeffRRu6MBAHxIWJiZmr1lS9M39weZAmvzZtd/Dx06/3vj480kDFnNSliokCmuKlSQoqKksmVdX+HhrnapUmYCjaCg/D/7ZVnS6dMmZ/rX0aPS33+bCT/++9+DB6WUlJz9jHLl0nT99QGqV8+hunVNIXXFFf5zJg+Ab/HJwur+++/XkSNHNHToUMXGxqpWrVpauHDheRNaAACQnxwO15mndu1c2w8flnbsMIvRpn/t2CH98UfWz5OWZgq0Awey93MDA02BVbKk+SpRQgoONgVaoULm8XPblmWKoKy+Tp1yFVJnz+Z9TCQzM1+1auaSvurVzVeVKk6lpBz5dzplKikA3s8nCytJ6t27N5f+AQA8QvoZpltuybz99Glzmdz+/abI+u/XP/9k7/nPnjWXHJ44kc/Bs6l0aXNmLf1SyauukipVMv+tWFEqlsWcEk6n/87YB8A3+WxhBQCApytWTKpVy3xl5dQpKS5OOnLEFCH//YqPlxITzTpPJ0+62omJOc8SGCgVKWIWQQ4NzfwVFmb+W6qUOftUrpyZfCMyUoqIkLKY/wkA/A6FFQAAHqp4cdcZoJxwOqXUVHNJYVqaOaOV3k5LM/sEBZlCqkgRqXBhs54XACD3KKwAAPAxAQGcRQKAgsbnUwAAAACQRxRWAAAAAJBHFFYAAAAAkEcUVgAAAACQRxRWAAAAAJBHFFYAAAAAkEcUVgAAAACQRxRWAAAAAJBHFFYAAAAAkEcUVgAAAACQRxRWAAAAAJBHFFYAAAAAkEcUVgAAAACQRxRWAAAAAJBHFFYAAAAAkEcUVgAAAACQRxRWAAAAAJBHgXYH8ESWZUmSEhISbE4iOZ1OnTx5UsHBwQoIoA7Ob4yvezG+7sX4uhfj616Mr3sxvu7F+LqXp41vek2QXiNcCIVVFk6ePClJKl++vM1JAAAAAHiCkydPKjQ09IKPO6xLlV5+yOl06tChQypZsqQcDoetWRISElS+fHn9+eefCgkJsTWLL2J83YvxdS/G170YX/difN2L8XUvxte9PG18LcvSyZMnFRUVddEzaJyxykJAQICuuOIKu2NkEhIS4hEHlq9ifN2L8XUvxte9GF/3Ynzdi/F1L8bXvTxpfC92piqd/RctAgAAAICXo7ACAAAAgDyisPJwQUFBGjZsmIKCguyO4pMYX/difN2L8XUvxte9GF/3Ynzdi/F1L28dXyavAAAAAIA84owVAAAAAOQRhRUAAAAA5BGFFQAAAADkEYUVAAAAAOQRhZXNRo0apfr166tYsWIKCwvLcp8DBw6odevWKlasmMqWLaunn35aZ8+evejzHjt2TJ06dVJISIjCwsLUtWtXJSYmuuE38C7Lly+Xw+HI8mv9+vUX/L4mTZqct//jjz9egMm9R8WKFc8bq5dffvmi35OUlKRevXqpTJkyKlGihNq3b6+4uLgCSuw99u/fr65du6pSpUoqWrSorr76ag0bNkwpKSkX/T6O3wubOnWqKlasqODgYEVHR+unn3666P6ffvqpqlSpouDgYNWoUUPffPNNASX1LmPGjFG9evVUsmRJlS1bVm3bttWuXbsu+j1z5sw57zgNDg4uoMTeZfjw4eeNVZUqVS76PRy7OZPV3zKHw6FevXpluT/H78WtXLlSd955p6KiouRwODR//vxMj1uWpaFDh6pcuXIqWrSomjVrpt27d1/yeXP6Gu5uFFY2S0lJ0b333quePXtm+XhaWppat26tlJQUrV69Wu+8847mzJmjoUOHXvR5O3XqpO3bt2vx4sX66quvtHLlSnXv3t0dv4JXqV+/vv7+++9MX4899pgqVaqkunXrXvR7u3Xrlun7xo0bV0Cpvc/IkSMzjVWfPn0uuv+TTz6pL7/8Up9++qlWrFihQ4cO6e677y6gtN5j586dcjqdmj59urZv367XXntN06ZN03PPPXfJ7+X4Pd/cuXM1YMAADRs2TJs2bdINN9ygFi1a6PDhw1nuv3r1anXo0EFdu3bV5s2b1bZtW7Vt21a//PJLASf3fCtWrFCvXr20du1aLV68WKmpqbrtttt06tSpi35fSEhIpuP0jz/+KKDE3qd69eqZxmrVqlUX3JdjN+fWr1+faXwXL14sSbr33nsv+D0cvxd26tQp3XDDDZo6dWqWj48bN06TJk3StGnTtG7dOhUvXlwtWrRQUlLSBZ8zp6/hBcKCR5g9e7YVGhp63vZvvvnGCggIsGJjYzO2vfnmm1ZISIiVnJyc5XP9+uuvliRr/fr1Gdu+/fZby+FwWAcPHsz37N4sJSXFCg8Pt0aOHHnR/W655RarX79+BRPKy1WoUMF67bXXsr3/iRMnrMKFC1uffvppxrYdO3ZYkqw1a9a4IaFvGTdunFWpUqWL7sPxm7WbbrrJ6tWrV0Y/LS3NioqKssaMGZPl/vfdd5/VunXrTNuio6OtHj16uDWnLzh8+LAlyVqxYsUF97nQ30Gcb9iwYdYNN9yQ7f05dvOuX79+1tVXX205nc4sH+f4zT5J1rx58zL6TqfTioyMtF555ZWMbSdOnLCCgoKsjz766ILPk9PX8ILAGSsPt2bNGtWoUUMREREZ21q0aKGEhARt3779gt8TFhaW6QxMs2bNFBAQoHXr1rk9szdZsGCBjh49qkcfffSS+37wwQe67LLLdP3112vw4ME6ffp0AST0Ti+//LLKlCmj2rVr65VXXrnopasbN25UamqqmjVrlrGtSpUquvLKK7VmzZqCiOvV4uPjVbp06Uvux/GbWUpKijZu3JjpuAsICFCzZs0ueNytWbMm0/6SeT3mOL20+Ph4SbrksZqYmKgKFSqofPnyatOmzQX/zkHavXu3oqKidNVVV6lTp046cODABffl2M2blJQUvf/+++rSpYscDscF9+P4zZ19+/YpNjY20zEaGhqq6OjoCx6juXkNLwiBtv1kZEtsbGymokpSRj82NvaC31O2bNlM2wIDA1W6dOkLfo+/mjlzplq0aKErrrjiovt17NhRFSpUUFRUlLZu3apnn31Wu3bt0ueff15ASb1H3759deONN6p06dJavXq1Bg8erL///lsTJkzIcv/Y2FgVKVLkvHsMIyIiOF4vYc+ePZo8ebLGjx9/0f04fs/3zz//KC0tLcvX1507d2b5PRd6PeY4vTin06n+/furQYMGuv766y+4X+XKlTVr1izVrFlT8fHxGj9+vOrXr6/t27df8jXa30RHR2vOnDmqXLmy/v77b40YMUKNGjXSL7/8opIlS563P8du3syfP18nTpzQI488csF9OH5zL/04zMkxmpvX8IJAYeUGgwYN0tixYy+6z44dOy55oymyLzdj/tdff2nRokX65JNPLvn8596fVqNGDZUrV0633nqr9u7dq6uvvjr3wb1ETsZ3wIABGdtq1qypIkWKqEePHhozZoyCgoLcHdUr5eb4PXjwoFq2bKl7771X3bp1u+j3+vvxC3v16tVLv/zyy0XvAZKkmJgYxcTEZPTr16+vqlWravr06XrxxRfdHdOrtGrVKqNds2ZNRUdHq0KFCvrkk0/UtWtXG5P5ppkzZ6pVq1aKioq64D4cv5AorNxi4MCBF/1UQ5KuuuqqbD1XZGTkeTOcpM+WFhkZecHv+e+Ne2fPntWxY8cu+D3eLjdjPnv2bJUpU0Z33XVXjn9edHS0JHPGwB/emOblmI6OjtbZs2e1f/9+Va5c+bzHIyMjlZKSohMnTmQ6axUXF+ezx+t/5XR8Dx06pKZNm6p+/fqaMWNGjn+evx2/WbnssstUqFCh82afvNhxFxkZmaP9IfXu3TtjAqWcfmpfuHBh1a5dW3v27HFTOt8RFham66677oJjxbGbe3/88Ye+//77HJ/h5/jNvvTjMC4uTuXKlcvYHhcXp1q1amX5Pbl5DS8IFFZuEB4ervDw8Hx5rpiYGI0aNUqHDx/OuLxv8eLFCgkJUbVq1S74PSdOnNDGjRtVp04dSdLSpUvldDoz3lD5mpyOuWVZmj17th5++GEVLlw4xz9vy5YtkpTpBcCX5eWY3rJliwICAs67PDVdnTp1VLhwYS1ZskTt27eXJO3atUsHDhzI9OmfL8vJ+B48eFBNmzZVnTp1NHv2bAUE5PxWWX87frNSpEgR1alTR0uWLFHbtm0lmUvWlixZot69e2f5PTExMVqyZIn69++fsW3x4sV+c5zmhGVZ6tOnj+bNm6fly5erUqVKOX6OtLQ0bdu2TbfffrsbEvqWxMRE7d27Vw899FCWj3Ps5t7s2bNVtmxZtW7dOkffx/GbfZUqVVJkZKSWLFmSUUglJCRo3bp1F5w1Ozev4QXCtmkzYFmWZf3xxx/W5s2brREjRlglSpSwNm/ebG3evNk6efKkZVmWdfbsWev666+3brvtNmvLli3WwoULrfDwcGvw4MEZz7Fu3TqrcuXK1l9//ZWxrWXLllbt2rWtdevWWatWrbKuvfZaq0OHDgX++3mq77//3pJk7dix47zH/vrrL6ty5crWunXrLMuyrD179lgjR460NmzYYO3bt8/64osvrKuuuspq3LhxQcf2eKtXr7Zee+01a8uWLdbevXut999/3woPD7cefvjhjH3+O76WZVmPP/64deWVV1pLly61NmzYYMXExFgxMTF2/Aoe7a+//rKuueYa69Zbb7X++usv6++//874Oncfjt/s+fjjj62goCBrzpw51q+//mp1797dCgsLy5iF9aGHHrIGDRqUsf+PP/5oBQYGWuPHj7d27NhhDRs2zCpcuLC1bds2u34Fj9WzZ08rNDTUWr58eabj9PTp0xn7/Hd8R4wYYS1atMjau3evtXHjRuuBBx6wgoODre3bt9vxK3i0gQMHWsuXL7f27dtn/fjjj1azZs2syy67zDp8+LBlWRy7+SUtLc268sorrWefffa8xzh+c+bkyZMZ73ElWRMmTLA2b95s/fHHH5ZlWdbLL79shYWFWV988YW1detWq02bNlalSpWsM2fOZDzH//73P2vy5MkZ/Uu9htuBwspmnTt3tiSd97Vs2bKMffbv32+1atXKKlq0qHXZZZdZAwcOtFJTUzMeX7ZsmSXJ2rdvX8a2o0ePWh06dLBKlChhhYSEWI8++mhGsQbL6tChg1W/fv0sH9u3b1+m/wcHDhywGjdubJUuXdoKCgqyrrnmGuvpp5+24uPjCzCxd9i4caMVHR1thYaGWsHBwVbVqlWt0aNHW0lJSRn7/Hd8Lcuyzpw5Yz3xxBNWqVKlrGLFilnt2rXLVCzAmD17dpavF+d+RsbxmzOTJ0+2rrzySqtIkSLWTTfdZK1duzbjsVtuucXq3Llzpv0/+eQT67rrrrOKFCliVa9e3fr6668LOLF3uNBxOnv27Ix9/ju+/fv3z/h/ERERYd1+++3Wpk2bCj68F7j//vutcuXKWUWKFLEuv/xy6/7777f27NmT8TjHbv5YtGiRJcnatWvXeY9x/OZM+nvV/36lj6HT6bReeOEFKyIiwgoKCrJuvfXW88a9QoUK1rBhwzJtu9hruB0clmVZBXJqDAAAAAB8FOtYAQAAAEAeUVgBAAAAQB5RWAEAAABAHlFYAQAAAEAeUVgBAAAAQB5RWAEAAABAHlFYAQAAAEAeUVgBAAAAQB5RWAEAAABAHlFYAQAAAEAeUVgBAAAAQB5RWAEAAABAHlFYAQDwrzNnzqhKlSqqUqWKzpw5k7H92LFjKleunOrXr6+0tDQbEwIAPBWFFQAA/ypatKjeeecd7dmzR88//3zG9l69eik+Pl5z5sxRoUKFbEwIAPBUgXYHAADAk0RHR+uZZ57R2LFj1a5dO8XFxenjjz/WxIkTdd1119kdDwDgoRyWZVl2hwAAwJOkpKSobt26SkxMVGJioqpVq6Zly5bJ4XDYHQ0A4KEorAAAyMKGDRtUr149BQcH69dff1WlSpXsjgQA8GDcYwUAQBYWLVokSUpKStLu3bttTgMA8HScsQIA4D+2bt2qevXqqVOnTtqyZYv++ecfbdu2TaGhoXZHAwB4KAorAADOkZqaqujoaB0/flxbt27Vvn37MoqsWbNm2R0PAOChuBQQAIBzvPTSS9qyZYtmzZqlkiVLqmbNmho6dKhmz56tb775xu54AAAPxRkrAAD+tWnTJkVHR6tnz56aNGlSxva0tDTFxMTo4MGD2r59u8LCwuwLCQDwSBRWAAAAAJBHXAoIAAAAAHlEYQUAAAAAeURhBQAAAAB5RGEFAAAAAHlEYQUAAAAAeURhBQAAAAB5RGEFAAAAAHlEYQUAAAAAeURhBQAAAAB5RGEFAAAAAHlEYQUAAAAAeURhBQAAAAB59P/SZ6XR01wD8wAAAABJRU5ErkJggg==', 'expression': 'x**2 - 3*x', 'x_range': [-10.0, 10.0]}\n", - "DEBUG:mathxpert:We have a plot\n" - ] - } - ], + "outputs": [], "source": [ "def chat(message: str, history: list[dict], selected_provider: str, model_selector: str):\n", " # NOTE: I'm not interesting in maintaining a conversation\n", From 4af5ebbec5935e02cee6409eb7192a2c3a071b86 Mon Sep 17 00:00:00 2001 From: Ransford Okpoti Date: Wed, 22 Oct 2025 13:02:45 +0000 Subject: [PATCH 3/3] =?UTF-8?q?fix:=20remove=20unused=20trailing=20cells?= =?UTF-8?q?=20=F0=9F=A4=A6?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../ranskills-week2-mathxpert-with-tools.ipynb | 16 ---------------- 1 file changed, 16 deletions(-) diff --git a/week2/community-contributions/ranskills-week2-mathxpert-with-tools.ipynb b/week2/community-contributions/ranskills-week2-mathxpert-with-tools.ipynb index a423a46..3891b8e 100644 --- a/week2/community-contributions/ranskills-week2-mathxpert-with-tools.ipynb +++ b/week2/community-contributions/ranskills-week2-mathxpert-with-tools.ipynb @@ -631,22 +631,6 @@ "\n", "ui.launch()" ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "9c3289fe-efda-46e8-824f-01c1e68f23f5", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "a4409824-4f7e-4ec5-b8aa-e42a0b73cc54", - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": {