"""

if not DB_INITIALIZED_SUCCESSFULLY or not DB_PATH:

return None # Not ready

usage_date = datetime.datetime.utcnow().strftime('%Y-%m-%d')

daily_usage = _get_daily_usage_sync(DB_PATH, usage_date)

"""

model = (model or "").strip().lower()

"""

tools = []

for item in function_specs or []:

if isinstance(item, dict) and item.get("type") == "function" and "function" in item:

tools.append(item)

else:

tools.append({

"type": "function",

"function": item

})

"""

payload = {

"model": bot.model,

"messages": messages,

}

if max_tokens is not None:

if model_supports_temperature(bot.model):

payload["max_tokens"] = max_tokens

else:

payload["max_completion_tokens"] = max_tokens

if model_supports_temperature(bot.model):

payload["temperature"] = bot.temperature

else:

bot.logger.info(

"Model %s is not gpt-4*; omitting temperature.",

bot.model

)

if include_functions:

tools = build_openai_tools(custom_functions)

if tools:

payload["tools"] = tools

payload["tool_choice"] = "auto"

if include_functions:

tools = build_openai_tools(custom_functions)

if tools:

payload["tools"] = tools

payload["tool_choice"] = "auto"

payload["parallel_tool_calls"] = False

"""

if not isinstance(response_json, dict):

raise RuntimeError(f"OpenAI response was not a JSON object: {response_json!r}")

if "error" in response_json:

raise RuntimeError(f"OpenAI API error: {response_json['error']}")

if "choices" not in response_json:

raise RuntimeError(f"OpenAI response missing 'choices': {response_json}")

choices = response_json.get("choices") or []

if not choices:

raise RuntimeError(f"OpenAI response had empty choices: {response_json}")

message = choices[0].get("message") or {}

content = message.get("content") or ""

"""

if not isinstance(response_json, dict):

raise RuntimeError(f"OpenAI response was not a JSON object: {response_json!r}")

if "error" in response_json:

raise RuntimeError(f"OpenAI API error: {response_json['error']}")

choices = response_json.get("choices") or []

if not choices:

raise RuntimeError(f"OpenAI response had empty choices: {response_json}")

message_obj = choices[0].get("message") or {}

# Modern tools/tool_calls path.

tool_calls = message_obj.get("tool_calls") or []

if tool_calls:

first_tool_call = tool_calls[0]

if first_tool_call.get("type") == "function":

fn = first_tool_call.get("function") or {}

return {

"name": fn.get("name"),

"arguments": fn.get("arguments") or "{}",

"tool_call_id": first_tool_call.get("id"),

}

# Legacy functions/function_call path.

legacy_function_call = message_obj.get("function_call")

if legacy_function_call:

return {

"name": legacy_function_call.get("name"),

"arguments": legacy_function_call.get("arguments") or "{}",

"tool_call_id": None,

}

if not config_auto.has_section('ModelAutoSwitch'):

logging.info("Auto-switch is not configured. Using default model: %s", bot.model)

return True

if not config_auto['ModelAutoSwitch'].getboolean('Enabled', fallback=False):

logging.info("ModelAutoSwitch.Enabled = False => skipping auto-switch, using %s", bot.model)

return True

premium_model = config_auto['ModelAutoSwitch'].get('PremiumModel', 'gpt-4')

fallback_model = config_auto['ModelAutoSwitch'].get('FallbackModel', 'gpt-3.5-turbo')

premium_limit = config_auto['ModelAutoSwitch'].getint('PremiumTokenLimit', 500000)

fallback_limit = config_auto['ModelAutoSwitch'].getint('MiniTokenLimit', 10000000)

fallback_action = config_auto['ModelAutoSwitch'].get('FallbackLimitAction', 'Deny')

if not DB_INITIALIZED_SUCCESSFULLY or not DB_PATH:

logging.warning("DB not initialized or path missing — can't auto-switch, fallback to default model.")

return True

usage_date = datetime.datetime.utcnow().strftime('%Y-%m-%d')

daily_usage = _get_daily_usage_sync(DB_PATH, usage_date)

if not daily_usage:

daily_premium_tokens, daily_fallback_tokens = (0, 0)

else:

daily_premium_tokens, daily_fallback_tokens = daily_usage

# --> NOW WE CAN SAFELY LOG THE USAGE & LIMITS <--

logging.info(f"Daily premium tokens = {daily_premium_tokens}, daily fallback tokens = {daily_fallback_tokens}")

logging.info(f"Premium limit = {premium_limit}, Fallback limit = {fallback_limit}, fallback_action = {fallback_action}")

# Decide if we can still use the premium model

if daily_premium_tokens < premium_limit:

bot.model = premium_model

logging.info("Using premium model: %s, daily usage = %d", bot.model, daily_premium_tokens)

return True

else:

# Premium limit exceeded => check fallback usage

if daily_fallback_tokens < fallback_limit:

bot.model = fallback_model

logging.info("Premium limit reached; using fallback model: %s, fallback usage = %d",

bot.model, daily_fallback_tokens)

return True

else:

# Fallback usage also exceeded => check action

if fallback_action.lower() == 'deny':

logging.warning("Fallback limit also reached => Deny further usage.")

return False

elif fallback_action.lower() == 'warn':

logging.warning("Fallback limit reached but ignoring => 'Warn' => proceed with fallback anyway.")

bot.model = fallback_model

return True

else:

logging.info("Fallback limit reached => 'Proceed' => continuing anyway with fallback.")

bot.model = fallback_model

# 1) Auto-switch first if applicable

can_proceed = pick_model_auto_switch(bot)

if not can_proceed:

bot.logger.warning("Denied request because daily usage limits are exceeded for both premium & fallback.")

await context.bot.send_message(

chat_id=update.effective_chat.id,

text="Sorry, we've hit today's usage limit — cannot proceed. ☹️ Please try again tomorrow!"

)

return

else:

bot.logger.info(f"Proceeding with the request using model '{bot.model}'.")

# Extract chat_id as soon as possible from the update object

chat_id = update.effective_chat.id

# Initialize a flag to indicate whether a response has been sent

response_sent = False

# send a "holiday message" if the bot is on a break

if bot.is_bot_disabled:

await context.bot.send_message(chat_id=update.message.chat_id, text=bot.bot_disabled_msg)

return

# Before anything else, check the global rate limit

if bot.check_global_rate_limit():

await context.bot.send_message(chat_id=update.message.chat_id, text="The bot is currently busy. Please try again in a minute.")

return

# process a text message

try:

# Create an Event to control the typing animation

stop_typing_event = asyncio.Event()

# Start the typing animation in a background task

typing_task = asyncio.create_task(send_typing_animation(context.bot, chat_id, stop_typing_event))

# Check if there is a transcribed text available

if 'transcribed_text' in context.user_data:

user_message = context.user_data['transcribed_text']

# Clear the transcribed text after using it

del context.user_data['transcribed_text']

else:

user_message = update.message.text

chat_id = update.message.chat_id

user_token_count = bot.count_tokens(user_message)

# Debug print to check types

bot.logger.info(f"[Token counting/debug] user_token_count type: {type(user_token_count)}, value: {user_token_count}")

bot.logger.info(f"[Token counting/debug] bot.total_token_usage type: {type(bot.total_token_usage)}, value: {bot.total_token_usage}")

# Convert max_tokens_config to an integer

# Attempt to read max_tokens_config as an integer

try:

# max_tokens_config = int(bot.config.get('GlobalMaxTokenUsagePerDay', '100000'))

max_tokens_config = bot.config.getint('GlobalMaxTokenUsagePerDay', 100000)

is_no_limit = max_tokens_config == 0

bot.logger.info(f"[Token counting/debug] max_tokens_config type: {type(max_tokens_config)}, value: {max_tokens_config}")

# Debug: Print the value read from token_usage.json

bot.logger.info(f"[Debug] Total token usage from file: {bot.total_token_usage}")

except ValueError:

bot.logger.error("Invalid value for GlobalMaxTokenUsagePerDay in the configuration file.")

await update.message.reply_text("An error occurred while processing your request: couldn't get proper token count. Please try again later.")

return

# Safely compare user_token_count and max_tokens_config

if not is_no_limit and (bot.total_token_usage + user_token_count) > max_tokens_config:

await update.message.reply_text("The bot has reached its daily token limit. Please try again tomorrow.")

return

# Debug: Print before token limit checks

bot.logger.info(f"[Debug] is_no_limit: {is_no_limit}, user_token_count: {user_token_count}, max_tokens_config: {max_tokens_config}")

# ~~~~~~~~~~~~~~~

# Make timestamp

# ~~~~~~~~~~~~~~~

now_utc = datetime.datetime.utcnow()

# We'll keep this for session timeout comparisons

current_time = now_utc

day_of_week = now_utc.strftime("%A")

system_timestamp = now_utc.strftime("%Y-%m-%d %H:%M:%S UTC")

english_line = get_english_timestamp_str(now_utc)

finnish_line = get_finnish_timestamp_str(now_utc)

# Combine them however you like, e.g.:

#

# Monday, April 9th, 2025 | Time (UTC): 12:34:56

# maanantai, 9. huhtikuuta 2025, klo 15:34:56 Suomen aikaa

#

current_timestamp_str = f"{english_line}\n{finnish_line}"

# We'll put that into a system message

timestamp_system_msg = {

"role": "system",

"content": current_timestamp_str

}

# Add the user's tokens to the total usage (JSON style)

bot.total_token_usage += user_token_count

# Log the incoming user message

bot.logger.info(f"Received message from {update.message.from_user.username} ({chat_id}): {user_message}")

# Check if session timeout is enabled and if session is timed out

if bot.session_timeout_minutes > 0:

timeout_seconds = bot.session_timeout_minutes * 60 # Convert minutes to seconds

if 'last_message_time' in context.chat_data:

last_message_time = context.chat_data['last_message_time']

elapsed_time = (current_time - last_message_time).total_seconds()

if elapsed_time > timeout_seconds:

# Log the length of chat history before trimming

chat_history_length_before = len(context.chat_data.get('chat_history', []))

bot.logger.info(f"Chat history length before trimming: {chat_history_length_before}")

# Session timeout logic

if bot.max_retained_messages == 0:

# Clear entire history

context.chat_data['chat_history'] = []

bot.logger.info(f"'MaxRetainedMessages' set to 0, cleared the entire chat history due to session timeout.")

else:

# Keep the last N messages

context.chat_data['chat_history'] = context.chat_data['chat_history'][-bot.max_retained_messages:]

bot.logger.info(f"Retained the last {bot.max_retained_messages} messages due to session timeout.")

# Log the length of chat history after trimming

chat_history_length_after = len(context.chat_data.get('chat_history', []))

bot.logger.info(f"Chat history length after trimming: {chat_history_length_after}")

bot.logger.info(f"[DebugInfo] Session timed out. Chat history updated.")

else:

# Log the skipping of session timeout check

bot.logger.info(f"[DebugInfo] Session timeout check skipped as 'SessionTimeoutMinutes' is set to 0.")

# Update the time of the last message

context.chat_data['last_message_time'] = current_time

# Log the current chat history

bot.logger.debug(f"Current chat history: {context.chat_data.get('chat_history')}")

# Initialize chat_history as an empty list if it doesn't exist

chat_history = context.chat_data.get('chat_history', [])

# ~~~~~~~~~~~~~~~~~~~~~~~~~~~

# Insert the new system msg

# ~~~~~~~~~~~~~~~~~~~~~~~~~~~

# logger info on the appended system message

logger.info(f"Inserting timestamp system message: {current_timestamp_str}")

chat_history.append(timestamp_system_msg)

# Append the new user message to the chat history

chat_history.append({"role": "user", "content": user_message})

# Prepare the conversation history to send to the OpenAI API

# # // old method that included the timestamp in the original system message

# system_timestamp = datetime.datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S UTC")

# system_message = {"role": "system", "content": f"System time+date: {system_timestamp}, {day_of_week}): {bot.system_instructions}"}

system_message = {"role": "system", "content": f"Instructions: {bot.system_instructions}"}

chat_history_with_system_message = [system_message] + chat_history

# Trim chat history if it exceeds a specified length or token limit

bot.trim_chat_history(chat_history, bot.max_tokens)

# Log the incoming user message

bot.log_message('User', update.message.from_user.id, update.message.text)

# Check if holiday notification is enabled

if enable_holiday_notification:

# Get the current date and time in Finland's timezone

now = datetime.datetime.now(pytz.timezone('Europe/Helsinki'))

# Create a holidays object for Finland

fi_holidays = holidays.Finland()

# Add non-official but widely celebrated holidays

additional_holidays = {

datetime.date(now.year, 4, 30): "[en] May Day Eve [fi] vappuaatto",

datetime.date(now.year, 7, 26): "[fi] ChatKeken syntymäpäivät! Ole iloinen koko päivän ajan! [en] ChatKeke's Birthday! Be cheerful the entire day!",

datetime.date(now.year, 12, 31): "[en] New Year's Eve [fi] uudenvuodenaatto"

}

# Update the holidays object with the additional holidays

fi_holidays.update(additional_holidays)

# Check if the current date is a holiday

if now.date() in fi_holidays:

holiday_name = fi_holidays.get(now.date())

finnish_name = holiday_replacements.get(holiday_name, holiday_name)

holiday_message = f"HUOMIO: Suomessa on tänään juhlapäivä: {finnish_name}. Muista mainita juhlapyhästä käyttäjälle tervehtiessäsi (käytä suomeksi tervehtiessäsi VAIN suomenkielistä juhlapyhän nimeä) ja kysellessä kuulumisia! (esim. hyvää joulua!, hauskaa vappua!, hyvää juhannusta!, iloista uutta vuotta!, jne. \n(In English: Today is a Finnish holiday: {finnish_name}. Include that in your current understanding and mention it, especially if you're talking about anything current.)"

chat_history_with_system_message.insert(1, {"role": "system", "content": holiday_message})

# (old) // Show typing animation

# await context.bot.send_chat_action(chat_id=update.effective_message.chat_id, action=constants.ChatAction.TYPING)

# Process any YouTube URLs before the Elasticsearch RAG

youtube_context_messages = await process_url_message(user_message)

logger.info(f"YouTube context messages: {youtube_context_messages}")

# # Process YouTube URLs and append data.

# for youtube_context in youtube_context_messages:

# chat_history_with_system_message.append({

# "role": "system",

# "content": youtube_context

# })

for youtube_context in youtube_context_messages:

chat_history_with_system_message.append({

"role": "system",

"content": youtube_context

})

logger.info(f"Added YouTube context: {youtube_context}")

# ~~~~~~~~~~~~~~~~~

# Elasticsearch RAG

# ~~~~~~~~~~~~~~~~~

# es_context = await search_es_for_context(user_message)

# Initialize chat_history_with_es_context to default value

chat_history_with_es_context = chat_history_with_system_message

# Assuming ELASTICSEARCH_ENABLED is true and we have fetched es_context

if elasticsearch_enabled and search_es_for_context:

logger.info(f"Elasticsearch is enabled, searching for context for user message: {user_message}")

# es_context = await search_es_for_context(user_message)

es_context = await search_es_for_context(user_message, config)

action_triggered = False # Flag to check if an action was triggered based on tokens

if es_context and es_context.strip():

logger.info(f"Elasticsearch found additional context: {es_context}")

# Iterate through your action tokens and check if any exist in the es_context

for token, function in action_token_functions.items():

if token in es_context:

logger.info(f"Action token found: {token}. Executing corresponding function.")

# Execute the mapped function

chat_history_with_es_context = await function(context, update, chat_history_with_system_message)

action_triggered = True

break # Stop checking after the first match to avoid multiple actions

# If no action token was found, just add the Elasticsearch context to the chat history

if not action_triggered:

chat_history_with_es_context = [{"role": "system", "content": "Elasticsearch RAG data: " + es_context}] + chat_history_with_system_message

else:

logger.info("No relevant or non-empty context found via Elasticsearch. Proceeding.")

chat_history_with_es_context = chat_history_with_system_message

else:

chat_history_with_es_context = chat_history_with_system_message

# ~~~~~~~~~~~

# API request

# ~~~~~~~~~~~

for attempt in range(bot.max_retries):

try:

# Prepare the payload for the API request

# payload = {

# "model": bot.model,

# #"messages": context.chat_data['chat_history'],

# # "messages": chat_history_with_system_message, # Updated to include system message

# "messages": chat_history_with_es_context,

# "temperature": bot.temperature, # Use the TEMPERATURE variable loaded from config.ini

# "functions": custom_functions,

# "function_call": 'auto' # Allows the model to dynamically choose the function

# }

# // new payload build method

payload = build_chat_payload(bot, chat_history_with_es_context)

# Make the API request

headers = {

"Content-Type": "application/json",

"Authorization": f"Bearer {openai.api_key}"

}

async with httpx.AsyncClient() as client:

response = await client.post("https://api.openai.com/v1/chat/completions",

data=json.dumps(payload),

headers=headers,

timeout=bot.timeout)

# Check if response status is 401 (Unauthorized)

if response.status_code == 401:

bot.logger.error("Received 401 Unauthorized: Invalid OpenAI API key. Please set up your API key correctly.")

await context.bot.send_message(

chat_id=chat_id,

text="😐", # First message with just the emoji

parse_mode=ParseMode.HTML

)

await context.bot.send_message(

chat_id=chat_id,

text="Error: Invalid OpenAI API key. Please contact the administrator to resolve this issue.",

parse_mode=ParseMode.HTML

)

return # Stop further execution in case of 401 error

raw_response_text = response.text

if response.status_code >= 400:

bot.logger.error(

"OpenAI API call failed, status code = %d, body = %s",

response.status_code,

raw_response_text[:4000],

)

await context.bot.send_message(

chat_id=chat_id,

text=f"OpenAI API error {response.status_code}. Check logs.",

parse_mode=ParseMode.HTML

)

stop_typing_event.set()

return

try:

response_json = response.json()

except Exception as e:

bot.logger.error(

"OpenAI returned non-JSON response: %s; parse error: %s",

raw_response_text[:4000],

e,

)

await context.bot.send_message(

chat_id=chat_id,

text="OpenAI returned a non-JSON response. Check logs.",

parse_mode=ParseMode.HTML

)

stop_typing_event.set()

return

if "choices" not in response_json:

bot.logger.error("OpenAI response missing 'choices': %s", response_json)

await context.bot.send_message(

chat_id=chat_id,

text="OpenAI response had no choices. Check logs.",

parse_mode=ParseMode.HTML

)

stop_typing_event.set()

return

bot.logger.info("OpenAI API call succeeded, status code = %d", response.status_code)

# ~~~~~ read the usage once we have the `response_json` ~~~~~

if "usage" in response_json:

usage_obj = response_json["usage"]

# Log everything we got

bot.logger.info(f"OpenAI usage field => {usage_obj}")

# They typically have 'prompt_tokens', 'completion_tokens', and 'total_tokens'

prompt_used = usage_obj.get("prompt_tokens", 0)

completion_used = usage_obj.get("completion_tokens", 0)

total_used = usage_obj.get("total_tokens", 0)

bot.logger.info(f"Used {prompt_used} prompt tokens + {completion_used} completion tokens = {total_used} total tokens in this request.")

# Figure out if we're “premium” or “mini”

# (If your config has multiple fallback possibilities, do it your own way.

# For simplicity, we just compare the current `bot.model` to the PremiumModel from config.)

premium_model_name = config_auto["ModelAutoSwitch"].get("PremiumModel", "gpt-4")

if bot.model == premium_model_name:

tier = "premium"

bot.logger.info(f"We're using the premium model => usage credited to 'premium_tokens'.")

else:

tier = "mini"

bot.logger.info(f"We're using the fallback model => usage credited to 'mini_tokens'.")

# Now actually log it to SQLite

if DB_INITIALIZED_SUCCESSFULLY and DB_PATH:

usage_date = datetime.datetime.utcnow().strftime('%Y-%m-%d')

bot.logger.info(f"Updating DB with {total_used} tokens on {usage_date} for tier='{tier}'.")

_update_daily_usage_sync(DB_PATH, usage_date, tier, total_used)

else:

bot.logger.warning("DB not initialized => can't store usage info in daily_usage table.")

else:

bot.logger.warning("No 'usage' field found in the API response. Could not update daily usage stats.")

# Log the API request payload

bot.logger.info(f"API Request Payload: {payload}")

# ~~~~~~~~~~~~~~~~~~

# > function calling

# ~~~~~~~~~~~~~~~~~~

# Check for a modern tool_call or legacy function_call in the response

function_call = extract_function_call_or_none(response_json)

if function_call:

function_name = function_call["name"]

# ~~~~~~~~~~~~~~~~~~~~~~

# Calculator Function

# ~~~~~~~~~~~~~~~~~~~~~~

# calculator module for mathematical equations

if function_name == 'calculate_expression':

arguments = json.loads(function_call.get('arguments', '{}'))

expression = arguments.get('expression', '')

if expression:

try:

# Set a timeout of 5 seconds (adjust as needed)

calc_result = await asyncio.wait_for(calculate_expression(expression), timeout=5)

if calc_result is None or calc_result.strip() == "":

# Handle the case where the calculation returned None or an empty result

system_message = "Calculator returned None or an empty result. Please ensure the expression is valid."

bot.logger.warning(f"Calculator returned None or empty result for expression: '{expression}'")

else:

# Proper result was returned, log and format it

# calc_result = f"`{calc_result}`" # Wrap the result in backticks for code formatting in Markdown.

calc_result = f"{calc_result}" # Wrap the result in <code> tags for HTML formatting.

system_message = (

f"[Calculator result, explain to the user in their language if needed. "

"IMPORTANT: Do not translate or simplify the mathematical expressions themselves. "

"NOTE: Telegram doesn't support LaTeX. Use simple HTML formatting, i.e. <code></code> if need be, note that <pre> or <br> are NOT allowed HTML tags. If the user explicitly asks for LaTeX or mentions LaTeX, use LaTeX formatting; "

f"otherwise, use plain text or Unicode with simple HTML.] Result:\n{calc_result}\n\n"

"[NOTE: format your response appropriately, possibly incorporating additional context or user intent, TRANSLATE it to the user's language if needed.]"

).format(calc_result=calc_result) # This ensures the result is inserted correctly

bot.logger.info(f"Calculation result: {calc_result}")

except asyncio.TimeoutError:

# Handle the case where the calculation took too long

system_message = "Calculation timed out after 5 seconds. Please try a simpler expression."

bot.logger.error(f"TimeoutError: Calculation for expression '{expression}' exceeded the time limit.")

except Exception as e:

# Handle other exceptions

system_message = f"An error occurred while evaluating the expression: {str(e)}"

bot.logger.error(f"Error evaluating expression '{expression}': {e}")

else:

system_message = "Please provide a valid expression for calculation."

bot.logger.warning("Received an empty expression for calculation.")

# Append the calculation result or the error message as a system message

chat_history.append({"role": "system", "content": system_message})

context.chat_data['chat_history'] = chat_history

# Debugging: Log the updated chat history

bot.logger.info(f"Updated chat history with calculator result: {chat_history}")

# Make an API request using the updated chat history

response_json = await make_api_request(

bot,

chat_history,

bot.timeout,

include_functions=False

)

# Extract and handle the content from the API response

bot_reply_content = extract_chat_reply_or_raise(response_json)

bot.logger.info(f"Bot's response content: '{bot_reply_content}'")

bot_reply = bot_reply_content.strip() if bot_reply_content else ""

# Update usage metrics and logs

bot_token_count = bot.count_tokens(bot_reply)

bot.total_token_usage += bot_token_count

bot.write_total_token_usage(bot.total_token_usage)

bot.logger.info(f"Bot's response to {update.message.from_user.username} ({chat_id}): '{bot_reply}'")

# Ensure the bot has a substantive response to send

if bot_reply:

# escaped_reply = markdown_to_html(bot_reply)

escaped_reply = bot_reply

# Log the bot's response

bot.log_message(

message_type='Bot',

message=bot_reply,

source='Calculator Module'

)

await context.bot.send_message(chat_id=chat_id, text=escaped_reply, parse_mode=ParseMode.HTML)

else:

# If no content to send, log and add a system message

bot.logger.error("Attempted to send an empty message.")

system_message = "Calculator returned an empty result or encountered an error, resulting in no response to send."

chat_history.append({"role": "system", "content": system_message})

context.chat_data['chat_history'] = chat_history

# Optionally, you can log this as a fallback

bot.logger.info("Added system message indicating an empty result.")

# Finalize the function call

stop_typing_event.set()

context.user_data.pop('active_translation', None)

return

# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

# weather via openweathermap api

# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

elif function_name == 'get_weather':

# Fetch the weather data

arguments = json.loads(function_call.get('arguments', '{}'))

city_name = arguments.get('city_name', 'DefaultCity')

country = arguments.get('country', None) # Fetch the country parameter, defaulting to None if not provided

# Now pass the country parameter to your get_weather function

weather_info = await get_weather(city_name, country=country) # Assuming get_weather is updated to accept country

# Add the received weather data as a system message

if weather_info:

system_message = f"[OpenWeatherMap API request returned data, use according to your own discernment as to what include and what format, by default, use emojis (you're in Telegram)]: {weather_info}"

else:

system_message = "[OpenWeatherMap API request failed to retrieve data]"

# Append the system message to the chat history

chat_history.append({"role": "system", "content": system_message})

context.chat_data['chat_history'] = chat_history

# Prepare the payload for the API request with updated chat history

response_json = await make_api_request(

bot,

chat_history,

bot.timeout,

include_functions=False

)

# Log the API request payload

bot.logger.info(f"API Request Payload: {payload}")

# Safely get the content or default to an empty string if not found

bot_reply_content = extract_chat_reply_or_raise(response_json)

# Only call strip if bot_reply_content is not None

bot_reply = bot_reply_content.strip() if bot_reply_content else "🤔"

# Count tokens in the bot's response

bot_token_count = bot.count_tokens(bot_reply)

# Add the bot's tokens to the total usage

bot.total_token_usage += bot_token_count

# Update the total token usage file

bot.write_total_token_usage(bot.total_token_usage)

# Log the bot's response

bot.logger.info(f"Bot's response to {update.message.from_user.username} ({chat_id}): {bot_reply}")

# Append the bot's response to the chat history

chat_history.append({"role": "assistant", "content": bot_reply})

# Update the chat history in context with the new messages

context.chat_data['chat_history'] = chat_history

# View the output (i.e. for markdown etc formatting debugging)

logger.info(f"[Debug] Reply message before escaping: {bot_reply}")

# escaped_reply = markdown_to_html(bot_reply)

try:

escaped_reply = markdown_to_html(bot_reply)

except Exception as e:

bot.logger.error(f"markdown_to_html failed: {e}")

escaped_reply = html.escape(bot_reply) # Safe fallback

# escaped_reply = bot_reply

logger.info(f"[Debug] Reply message after escaping: {escaped_reply}")

# Log the bot's response

bot.log_message(

message_type='Bot',

message=bot_reply,

source='Weather API'

)

await context.bot.send_message(

chat_id=chat_id,

text=escaped_reply,

parse_mode=ParseMode.HTML

)

stop_typing_event.set()

context.user_data.pop('active_translation', None)

return # Exit the loop after handling the custom function

# ~~~~~~~~~~~~~~~~~

# DuckDuckGo Search

# ~~~~~~~~~~~~~~~~~

elif function_name == 'get_duckduckgo_search':

arguments = json.loads(function_call.get('arguments', '{}'))

search_query = arguments.get('search_query', '')

if search_query:

search_results = await get_duckduckgo_search(search_query, user_message)

if search_results:

system_message = f"[DuckDuckGo Search Results]: {search_results}\n\n[NOTE: format your response as Telegram-compatible HTML with links. Translate your response to the user's language if necessary (= if the user talked to you in Finnish, respond in Finnish).][Use SIMPLE, Telegram-compliant HTML: Use these HTML tags if needed: <b> for bold, <i> for italics, <u> for underline, <s> for strikethrough, <code> for inline code, <pre> for preformatted blocks, and <a href=...> for hyperlinks.. Do NOT use <pre>, <br>, <ul>, <li> or Markdown in your response!]"

else:

system_message = "No results found for your query."

else:

system_message = "Please provide a search query."

# Append the search results or the relevant message as a system message

chat_history.append({"role": "system", "content": system_message})

context.chat_data['chat_history'] = chat_history

# Debugging: Log the updated chat history

bot.logger.info(f"Updated chat history: {chat_history}")

# Make an API request using the updated chat history

response_json = await make_api_request(

bot,

chat_history,

bot.timeout,

include_functions=False

)

# Extract and handle the content from the API response

bot_reply_content = extract_chat_reply_or_raise(response_json)

bot.logger.info(f"Bot's response content: '{bot_reply_content}'")

bot_reply = bot_reply_content.strip() if bot_reply_content else ""

# Update usage metrics and logs

bot_token_count = bot.count_tokens(bot_reply)

bot.total_token_usage += bot_token_count

bot.write_total_token_usage(bot.total_token_usage)

bot.logger.info(f"Bot's response to {update.message.from_user.username} ({chat_id}): '{bot_reply}'")

# Ensure the bot has a substantive response to send

if bot_reply:

# Function to clean unsupported tags

# # // old method

# def sanitize_html(content):

# # Remove unsupported HTML tags

# for tag in ['<pre>', '</pre>', '<br>', '<br/>', '</br>', '<div>', '</div>', '<span>', '</span>', '<p>', '</p>']:

# content = content.replace(tag, '')

# # Optionally: Replace line breaks with "\n" to preserve formatting

# content = content.replace('<br>', '\n').replace('<br/>', '\n')

# return content

# Convert markdown to HTML

# escaped_reply = markdown_to_html(bot_reply)

try:

escaped_reply = markdown_to_html(bot_reply)

except Exception as e:

bot.logger.error(f"markdown_to_html failed: {e}")

escaped_reply = html.escape(bot_reply) # Safe fallback

# Sanitize the HTML to remove any unsupported tags

escaped_reply = sanitize_html(escaped_reply)

# Log the bot's response from DuckDuckGo Search

bot.log_message(

message_type='Bot',

message=bot_reply,

source='DuckDuckGo Search'

)

await context.bot.send_message(chat_id=chat_id, text=escaped_reply, parse_mode=ParseMode.HTML)