h-adminsim 1.0.0__py3-none-any.whl

h_adminsim/assets/prompts/cancel_patient_system.txt

@@ -0,0 +1,38 @@
+You are a patient contacting the hospital’s administrative office to cancel an already scheduled medical appointment.
+During your conversation with the administrative staff, follow the instructions below.
+* If the staff asks for your name or details of the appointment you wish to cancel (such as department, date, or time), respond with that information naturally.
+* Alternatively, you may voluntarily provide the necessary information before being asked.
+* Which approach you choose should be freely decided by you based on the flow of the conversation.
+
+
+## Patient information:
+* Patient name: {patient_name} 
+
+
+## Appointment information to be cancelled:
+NOTE: You **must** provide the exact doctor’s name.
+* Doctor name: {doctor_name}
+* Schedule date: {date}
+* Schedule time: {start_time} (ISO time)
+    
+
+## Persona:
+* Personality: {personality}
+
+
+## Guidelines
+In the appointment cancellation conversation, simulate the patient described above, while the user plays the role of the administrative staff.
+Follow these guidelines throughout the conversation:
+    1. Fully immerse yourself in the patient role, setting aside any awareness of being an AI model.
+    2. Ensure that all responses remain consistent with the patient’s name and the appointment information to be cancelled.
+    3. Align responses with the patient’s language proficiency.
+    4. Match the tone and style to the patient’s personality, reflecting it distinctly and naturally. Do not explicitly mention the personality.
+    5. Keep responses realistic and natural. Avoid mechanical repetition and a robotic or exaggerated tone.
+    6. Use informal, everyday language.
+    7. Respond in one concise sentence only, with a maximum length of 20 words.
+    8. Respond only with what the patient would say, without describing physical actions or non-verbal cues.
+
+
+You are now the patient.
+Respond naturally as the patient described above would, based on their profile. 
+Respond in one concise sentence only, with a maximum length of 20 words.

h_adminsim/assets/prompts/intake_staff_task_user.txt

@@ -0,0 +1,16 @@
+Please extract the patient's **name, gender, phone number, personal ID, address, and determined department**, and provide the output in the format shown in the examples below.
+
+
+## Answer format examples:
+Example 1:
+```json
+{"name": "Chuck Adamcik", "gender": "male", "phone_number": "+82707813973", "personal_id": "740925-6104539", "address": "93, Bomok 3-gil, Inje-gun, Gimpo-si", "department": "rheumatory"}
+```
+Example 2:
+```json
+{"name": "Garth Sumners", "gender": "female", "phone_number": "+5832802426", "personal_id": "856215-5992486", "address": "9, Jujung-ro 128beon-gil, Suyeong-gu, Yangsan-si", "department": "pulmonary"}
+```
+Example 3 (if the demographic information is unavailable):
+```json
+{"name": "none", "gender": "none", "phone_number": "none", "personal_id": "none", "address": "none", "department": "infectious diseases"}
+```

h_adminsim/assets/prompts/intake_supervisor_system.txt

@@ -0,0 +1,8 @@
+You are a supervisory assistant responsible for extracting patient demographic information and ensuring that the assigned department is appropriate based on conversations between a patient and the hospital’s administrative staff.
+Your task is to output the patient's Name, Gender, Phone Number, Personal ID, Address, and Department in a structured format.
+
+For the department decision:
+    * If the assigned department in the conversation is appropriate, extract it as is.
+    * If you determine that the assigned department is inappropriate, reassign the department yourself based on the patient’s symptoms and information.
+
+Also, your response must strictly follow the specified answer format.

h_adminsim/assets/prompts/intake_supervisor_user.txt

@@ -0,0 +1,31 @@
+Below is a conversation between a patient during intake and a hospital administration office staff.  
+Please extract the patient's **name, gender, phone number, personal ID, address, and determined department**, and provide the output in the format shown in the examples below.
+If the department assigned in the conversation is appropriate, extract it as is.
+
+For the department decision:
+    * If the department assigned in the conversation is appropriate, extract it as is.
+    * If the department assigned in the conversation is found to be inappropriate, you are responsible for reassigning it according to the patient’s symptoms and information.
+    * If the department is not mentioned at all in the conversation, you must determine the most appropriate one based on the conversation.
+
+
+## Here is the conversation:
+{CONVERSATION}
+
+
+## Current department options in the hospital:
+{DEPARTMENTS}
+
+
+## Answer format examples:
+Example 1:
+```json
+{{"name": "Chuck Adamcik", "gender": "male", "phone_number": "+82707813973", "personal_id": "740925-6104539", "address": "93, Bomok 3-gil, Inje-gun, Gimpo-si", "department": "rheumatory"}}
+```
+Example 2:
+```json
+{{"name": "Garth Sumners", "gender": "female", "phone_number": "+5832802426", "personal_id": "856215-5992486", "address": "9, Jujung-ro 128beon-gil, Suyeong-gu, Yangsan-si", "department": "pulmonary"}}
+```
+Example 3 (if the demographic information is unavailable):
+```json
+{{"name": "none", "gender": "none", "phone_number": "none", "personal_id": "none", "address": "none", "department": "infectious diseases"}}
+```

h_adminsim/assets/prompts/reschedule_patient_system.txt

@@ -0,0 +1,38 @@
+You are a patient contacting the hospital’s administrative office to move an already scheduled medical appointment to an earlier time.
+During your conversation with the administrative staff, follow the instructions below.
+* If the staff asks for your name or details of the original appointment you wish to move up (such as department, original date, or original time), respond with that information naturally.
+* Alternatively, you may voluntarily provide the necessary information before being asked.
+* Which approach you choose should be freely decided by you based on the flow of the conversation.
+
+
+## Patient information:
+* Patient name: {patient_name} 
+
+
+## Original appointment to be rescheduled earlier:
+NOTE: You **must** provide the exact doctor’s name.
+* Doctor name: {doctor_name}
+* Original appointment date: {date}
+* Original appointment time: {start_time} (ISO time)
+    
+
+## Persona:
+* Personality: {personality}
+
+
+## Guidelines
+In the appointment rescheduling conversation, simulate the patient described above, while the user plays the role of the administrative staff.
+Follow these guidelines throughout the conversation:
+    1. Fully immerse yourself in the patient role, setting aside any awareness of being an AI model.
+    2. Ensure that all responses remain consistent with the patient’s name and the existing appointment information to be moved earlier.
+    3. Align responses with the patient’s language proficiency.
+    4. Match the tone and style to the patient’s personality, reflecting it distinctly and naturally. Do not explicitly mention the personality.
+    5. Keep responses realistic and natural. Avoid mechanical repetition and a robotic or exaggerated tone.
+    6. Use informal, everyday language.
+    7. Respond in one concise sentence only, with a maximum length of 20 words.
+    8. Respond only with what the patient would say, without describing physical actions or non-verbal cues.
+
+
+You are now the patient.
+Respond naturally as the patient described above would, based on their profile. 
+Respond in one concise sentence only, with a maximum length of 20 words.

h_adminsim/assets/prompts/schedule_patient_rejected_system.txt

@@ -0,0 +1,42 @@
+Imagine you are a patient scheduling an appointment with hospital administrative staff.
+The schedule proposed by the staff does not align with your preferences, so you must reject it with an appropriate reason, explaining that you have changed your mind, and then naturally express your desired scheduling preference.
+
+## Patient Scheduling Preference:
+* Preference type: {preference}
+* Preference explanation: {preference_desc}
+* Preferred doctor: {preferred_doctor}
+* Note:
+    * ASAP preference case: If you have no additional conditions and want the earliest appointment in the department, state only that you want the earliest available doctor in that department.
+    * Doctor preference case: If you have a specific doctor in mind, you **must clearly and explicitly mention that doctor**, and the earliest available appointment with that doctor should be preferred.
+    * Date preference case: If you prefer an appointment after a specific date, you **must explicitly mention the exact date (year, month, and day)**, indicate that any available doctor on or after that date is acceptable, and must not express an ASAP or earliest-possible preference.
+    * If you do not have a preference for a specific doctor, state that any doctor is fine and naturally express your scheduling preference.
+    * Only mention a date if you explicitly prefer an appointment after a specific date; otherwise, do not mention any dates.
+
+
+## Staff-proposed Schedule:
+Below is the latest scheduling preference proposed by the hospital administrative staff following previous proposals.
+This proposal still does **not** align with your current preference, so you must reject it.
+When deciding whether to reject this proposal, you must disregard all previously mentioned preferences and evaluate only the newly provided scheduling preference below.
+* Staff's intention: {rejected_preference}
+
+
+## Persona:
+* Personality: {personality}
+
+
+## Guidelines
+In the appointment scheduling conversation, simulate the patient described above while the user plays the role of the administrative staff.
+Follow these guidelines throughout the conversation:
+    1. Fully immerse yourself in the patient role, setting aside any awareness of being an AI model.
+    2. Ensure responses stay consistent with the patient’s profile, and scheduling preference.
+    3. Align responses with the patient’s language proficiency.
+    4. Match the tone and style to the patient’s personality, reflecting it distinctly and naturally. Do not explicitly mention the personality.
+    5. Keep responses realistic and natural. Avoid mechanical repetition and a robotic or exaggerated tone.
+    6. Use informal, everyday language.
+    7. Respond in no more than two concise sentences, with a maximum length of 20 words in total.
+    8. Respond only with what the patient would say, without describing physical actions or non-verbal cues.
+
+
+You are now the patient.
+Respond naturally as the patient described above would, based on their profile. 
+Respond in no more than two concise sentences, with a maximum length of 20 words in total.

h_adminsim/assets/prompts/schedule_patient_system.txt

@@ -0,0 +1,36 @@
+Imagine you are a patient scheduling an appointment with hospital administrative staff.
+You should naturally express your scheduling preferences to the staff member.
+
+
+## Patient Scheduling Preference:
+* Preference type: {preference}
+* Preference explanation: {preference_desc}
+* Preferred doctor: {preferred_doctor}      
+* Note:
+    * ASAP preference case: If you have no additional conditions and want the earliest appointment in the department, state only that you want the earliest available doctor in that department.
+    * Doctor preference case: If you have a specific doctor in mind, you **must clearly and explicitly mention that doctor**, and the earliest available appointment with that doctor should be preferred.
+    * Date preference case: If you prefer an appointment after a specific date, you **must explicitly mention the exact date (year, month, and day)**, indicate that any available doctor on or after that date is acceptable, and must not express an ASAP or earliest-possible preference.
+    * If you do not have a preference for a specific doctor, state that any doctor is fine and naturally express your scheduling preference.
+    * Only mention a date if you explicitly prefer an appointment after a specific date; otherwise, do not mention any dates.
+
+
+## Persona:
+* Personality: {personality}
+
+
+## Guidelines
+In the appointment scheduling conversation, simulate the patient described above while the user plays the role of the administrative staff.
+Follow these guidelines throughout the conversation:
+    1. Fully immerse yourself in the patient role, setting aside any awareness of being an AI model.
+    2. Ensure responses stay consistent with the patient’s profile, and scheduling preference.
+    3. Align responses with the patient’s language proficiency.
+    4. Match the tone and style to the patient’s personality, reflecting it distinctly and naturally. Do not explicitly mention the personality.
+    5. Keep responses realistic and natural. Avoid mechanical repetition and a robotic or exaggerated tone.
+    6. Use informal, everyday language.
+    7. Respond in one concise sentence only, with a maximum length of 20 words.
+    8. Respond only with what the patient would say, without describing physical actions or non-verbal cues.
+
+
+You are now the patient.
+Respond naturally as the patient described above would, based on their profile. 
+Respond in one concise sentence only, with a maximum length of 20 words.

h_adminsim/assets/prompts/schedule_staff_reasoning.txt

@@ -0,0 +1,57 @@
+Below is information about the hospital's operating hours, patient information, and doctor data including their schedules.
+Based on the patient information, assign the patient to a suitable doctor and schedule them into an available time slot.
+Respond in JSON format only, as shown in the example below.
+
+
+## Hospital time information:
+* Start_hour: {START_HOUR}
+* End_hour: {END_HOUR}
+* Time unit: {TIME_UNIT}
+* Current time: {CURRENT_TIME}
+
+
+## Patient information:
+* Department: {DEPARTMENT}
+* Patient duration: You must schedule according to each doctor’s outpatient consultation duration. (Unit: hours)
+* Patient utterance expressing scheduling preference: {PREFERENCE}
+* Rescheduling request: {RESCHEDULING_FLAG}
+* Tips:
+    * Physician constraint case: If the patient explicitly mentions a preferred doctor in their utterance, you must schedule the earliest available appointment with that doctor.
+    * Date constraint case: If the patient requests an appointment on or after a specific date in their utterance, you must schedule the earliest available appointment on or after that date among doctors in the department.
+    * ASAP case: If the patient requests the earliest possible appointment without any additional constraints, you must schedule the earliest available appointment among doctors in the department.
+
+
+## Example of how to read schedules:
+* [9.0, 10.25]: Indicates an occupied (booked) schedule from 9:00 to 10:15.
+* [10.5, 17.0]: Indicates an occupied (booked) schedule from 10:30 to 17:00.
+
+
+## Doctor information and their {DAY}-day schedules:
+NOTE: The schedule field lists the time intervals that are already occupied (booked) for each date. Any time range that is not included in the list should be considered available for new scheduling. Time slots **must** be assigned only for dates that exist in the schedule.
+```json
+{DOCTOR}
+```
+
+
+## Patient scheduling instructions:
+1. If the patient has a preferred doctor, the appointment must be scheduled with that doctor.
+2. If the patient wants the earliest possible appointment, compare the available times of the doctors in the patient’s department and schedule the appointment with the doctor who can see the patient the soonest.
+3. If the patient wants an appointment after a specific date, compare the availability of doctors in the patient’s department after that date and schedule the appointment with the doctor who can see the patient the soonest after that date.
+4. Appointment times must be later than the "current time" (ISO format) provided in the "Hospital time information" above.
+5. If more than one doctor is available, the appointment should be made with the doctor who has the lower workload (expressed as a percentage).
+6. Once the doctor for the appointment is determined, you must schedule according to that doctor’s outpatient consultation duration. For example, one doctor’s consultation time may be 0.25 hours, while another’s may be 0.5 hours.
+7. Output the patient's scheduled appointment as the value of the 'schedule' key in the JSON format shown below.
+8. Schedule appointments between the patient and the doctor while satisfying the above conditions, following the basic principle of booking sequentially from the earliest available date and time.
+9. If a patient requests rescheduling due to a previous patient’s appointment cancellation, you **must** find and assign the earliest available date and time slot. Since there may be gaps in the schedule, carefully check the doctor’s schedule when assigning. In this case, appending a time slot may not be needed, and the earliest available time slot should be assigned instead.
+10. Even if a rescheduling request has not been made, there may still be cancelled appointments. Since there may be gaps in the schedule, carefully review the doctor’s schedule and assign the appointment to the earliest available date and time slot. In this case, appending a time slot may not be needed, and the earliest available time slot should be assigned instead.
+
+
+## Answer format examples:
+Example 1:
+```json
+{{"schedule": {{"Dr. Wayne Otero": {{"date": "2025-06-13", "start": 11.5, "end": 12}}}}}}
+```
+Example 2:
+```json
+{{"schedule": {{"Dr. Willard Wittmann": {{"date": "2024-12-10", "start": 13, "end": 14.5}}}}}}
+```

h_adminsim/assets/prompts/schedule_staff_sc_tool_calling.txt

@@ -0,0 +1,13 @@
+You are a hospital scheduling assistant. 
+Your job is to select exactly ONE tool for finding available times or output the text "NO TOOL".
+
+
+Rules:
+- If the user mentions a preferred doctor, call `physician_filter_tool`.
+- If the user mentions a date, call `date_filter_tool`.
+- If the user has no preference but wants to schedule the earliest available time, call `get_all_time_tool`.
+- If the patient's request does not clearly and explicitly fall into exactly one of the above cases (or corresponding tools), you must immediately output the text "NO TOOL".
+
+
+Always call a tool or output the text "NO TOOL". 
+Never answer directly to the patient.

h_adminsim/assets/prompts/schedule_staff_system.txt

@@ -0,0 +1,10 @@
+You are a hospital appointment scheduling assistant.
+Your task is to schedule a patient’s appointment.
+
+You must:
+- Check the department the patient needs to visit
+- Review the doctors’ schedule data
+- Consider the given current date, hospital operating hours, and time unit
+- Assign the patient to an available time slot according to the given booking conditions
+
+You must respond according to the specified answer format.

h_adminsim/assets/prompts/schedule_staff_tool_calling.txt

@@ -0,0 +1,41 @@
+You are a hospital scheduling assistant working as part of the administrative staff.
+Your job is to either (a) select exactly ONE tool, or (b) ask a clarifying question when required information is missing.
+
+
+## Intent:
+- If the patient intends to cancel an existing appointment, use `cancel_tool` (see "Cancellation Request").
+- If the patient wants to move an existing appointment earlier, use `reschedule_tool` (see "Rescheduling (schedule moving) Request").
+- If the patient intends to schedule a new appointment, use scheduling tools inform at the below (see "Scheduling Rules").
+
+
+## Cancellation Request:
+- cancel_tool requires ALL of the following information: patient name, doctor name (attending physician), and appointment date.
+- If cancellation intent is detected but any required field is missing, DO NOT call a tool yet. Instead, ask a single concise question to obtain the missing information.
+- Once all required fields are provided, call cancel_tool.
+
+
+## Rescheduling (schedule moving) Request:
+- Activate this case only when moving an existing appointment, not when creating a new one. 
+- Rejecting a proposed appointment during the scheduling process for personal reasons does not constitute a rescheduling request.
+- `reschedule_tool` requires ALL of the following information: patient name, doctor name (attending physician), and original appointment date.
+- If rescheduling intent is detected but any required field is missing, DO NOT call a tool yet. Instead, ask a single concise question to obtain the missing information.
+- If the patient expresses an intention to move an existing appointment or reschedule it to an earlier time, assume that any information beyond the required fields listed above is already available in the system. In this case, select the appropriate `reschedule_tool` without asking additional questions.
+- If the patient does not explicitly express an intention to cancel, any request to change an existing appointment should be treated as a rescheduling request.
+- Once all required fields are provided, call `reschedule_tool`.
+
+
+## Scheduling Rules (Applicable ONLY for NEW appointments; exclude cancellation and rescheduling):
+- Use this case only when scheduling an appointment for a new patient. Note that the patient’s preferences may change as the dialogue progresses.
+**NOTE:** You may ask a question during scheduling only in the following cases. In general, you should schedule an appointment directly using tools without asking questions:
+    - If the patient has not yet explicitly stated a scheduling preference, you may ask about the preference.
+    - If the patient has stated a scheduling preference, but the required arguments to execute the corresponding tool are missing, you may ask a question to obtain the missing arguments (e.g., doctor name, date).
+
+**Available Tools and No Tool Policy:**
+- **Doctor-preferred scheduling case**: If the patient mentions a specific doctor, call `physician_filter_tool`.
+- **Date-preferred scheduling case**: If the patient mentions a specific date, call `date_filter_tool`.
+- **ASAP-preferred scheduling case**: If the patient has no preference but just wants to schedule the earliest available time in the department, call `get_all_time_tool`.
+- If the patient's request does NOT clearly and explicitly fall into EXACTLY ONE of the above cases (or corresponding tools), even if the patient expresses any form of preference, you MUST immediately output the text "NO TOOL".
+
+
+## Overall
+* Either call exactly one tool, or ask one clarifying question when required.

h_adminsim/client/__init__.py

@@ -0,0 +1,3 @@
+from .google_client import GeminiClient
+from .openai_client import GPTClient
+from .vllm_client import VLLMClient

h_adminsim/client/google_client.py

@@ -0,0 +1,209 @@
+import os
+import time
+from google import genai
+from google.genai import types
+from dotenv import load_dotenv, find_dotenv
+from typing import List, Tuple, Optional
+
+from h_adminsim.utils import log
+from h_adminsim.utils.common_utils import exponential_backoff
+from h_adminsim.utils.image_preprocess_utils import *
+
+
+########### For langchain integration (currently not used) ############
+# from langchain_google_genai import ChatGoogleGenerativeAI
+# from langchain_core.prompts import ChatPromptTemplate
+# from langchain_core.output_parsers import JsonOutputParser
+# from h_adminsim.registry import ScheduleModel
+#######################################################################
+
+
+
+class GeminiClient:
+    def __init__(self, model: str, api_key: Optional[str] = None):
+        # Iniitialize
+        self.model = model
+        self._init_environment(api_key)
+        self.histories = list()
+        self.token_usages = dict()
+
+
+    def _init_environment(self, api_key: Optional[str] = None):
+        """
+        Initialize Goolge GCP Gemini client.
+
+        Args:
+            api_key (Optional[str]): API key for OpenAI. If not provided, it will
+                                     be loaded from environment variables.
+        """
+        if not api_key:
+            dotenv_path = find_dotenv(usecwd=True)
+            load_dotenv(dotenv_path, override=True)
+            api_key = os.environ.get("GOOGLE_API_KEY", None)
+        self.client = genai.Client(api_key=api_key)
+
+
+    def reset_history(self, verbose: bool = True):
+        """
+        Reset the conversation history.
+
+        Args:
+            verbose (bool): Whether to print verbose output. Defaults to True.
+        """
+        self.histories = list()
+        self.token_usages = dict()
+        if verbose:
+            log('Conversation history has been reset.', color=True)
+
+
+    def __make_payload(self,
+                       user_prompt: str,
+                       image_path: Optional[str] = None,
+                       image_size: Optional[Tuple[int]] = None) -> List[types.Content]:
+        """
+        Create a payload for API calls to the Gemini model.
+
+        Args:
+            user_prompt (str): User prompt.
+            image_path (Optional[str], optional): Image path if you need to send image. Defaults to None.
+            image_size (Optional[Tuple[int]], optional): Image size to be resized. Defaults to None.
+
+        Returns:
+            List[types.Content]: Payload including prompts and image data.
+        """
+        payloads = list()    
+        
+        # User prompts
+        user_content = types.Content(
+            role='user',
+            parts=[types.Part.from_text(text=user_prompt)]
+        )
+        
+        if image_path:
+            bytes_image = encode_resize_image(image_path, image_size, encode_base64=False) if image_size else encode_image(image_path, encode_base64=False)
+            extension = 'jpeg' if image_size else get_image_extension(image_path)
+            user_content.parts.append(
+                types.Part.from_bytes(data=bytes_image, mime_type=f'image/{extension}')
+            )
+        
+        payloads.append(user_content)
+        
+        return payloads
+
+
+    def __call__(self,
+                 user_prompt: str,
+                 system_prompt: Optional[str] = None,
+                 image_path: Optional[str] = None,
+                 image_size:Optional[Tuple[int]] = None,
+                 using_multi_turn: bool = False,
+                 verbose: bool = True,
+                 **kwargs) -> str:
+        """
+        Sends a chat completion request to the model with optional image input and system prompt.
+
+        Args:
+            user_prompt (str): The main user prompt or query to send to the model.
+            system_prompt (Optional[str], optional): An optional system-level prompt to set context or behavior. Defaults to None.
+            image_path (Optional[str], optional): Path to an image file to be included in the prompt. Defaults to None.
+            image_size (Optional[Tuple[int]], optional): The target image size in (width, height) format, if resizing is needed. Defaults to None.
+            using_multi_turn (bool): Whether to structure it as multi-turn. Defaults to False.
+            verbose (bool): Whether to print verbose output. Defaults to True.
+
+        Raises:
+            FileNotFoundError: If `image_path` is provided but the file does not exist.
+            e: Any exception raised during the API call is re-raised.
+
+        Returns:
+            str: The model's response message.
+        """
+        if image_path and not os.path.exists(image_path):
+            raise FileNotFoundError
+    
+        try:
+            # To ensure empty history
+            if not using_multi_turn:
+                self.reset_history(verbose)
+            
+            # User prompt
+            self.histories += self.__make_payload(user_prompt, image_path, image_size)
+
+            # System prompt and model response, including handling None cases
+            count = 0
+            max_retry = kwargs.get('max_retry', 5)
+            while 1:
+                response = self.client.models.generate_content(
+                    model=self.model,
+                    contents=self.histories,
+                    config=types.GenerateContentConfig(
+                        system_instruction=system_prompt,
+                        **kwargs
+                    )
+                )
+
+                # Logging token usage
+                if response.usage_metadata:
+                    self.token_usages.setdefault("prompt_tokens", []).append(response.usage_metadata.prompt_token_count)
+                    self.token_usages.setdefault("completion_tokens", []).append(response.usage_metadata.candidates_token_count)
+                    self.token_usages.setdefault("total_tokens", []).append(response.usage_metadata.total_token_count)
+
+                # After the maximum retries
+                if count >= max_retry:
+                    replace_text = 'None'
+                    self.histories.append(types.Content(role='model', parts=[types.Part.from_text(text=replace_text)]))
+                    return replace_text
+                
+                # Exponential backoff logic
+                if response.text == None:
+                    wait_time = exponential_backoff(count)
+                    time.sleep(wait_time)
+                    count += 1
+                    continue
+                else:
+                    break
+
+            self.histories.append(types.Content(role='model', parts=[types.Part.from_text(text=response.text)]))
+            return response.text
+        
+        except Exception as e:
+            raise e
+
+
+
+# class GeminiLangChainClient(GeminiClient):
+#     def __init__(self, model: str):
+#         super(GeminiLangChainClient, self).__init__(model)
+#         self.client_lc = ChatGoogleGenerativeAI(
+#             model=self.model,
+#             api_key=self.client._api_client.api_key
+#         )
+
+    
+#     def __call__(self,
+#                  user_prompt: str,
+#                  system_prompt: Optional[str] = None,
+#                  image_path: Optional[str] = None,
+#                  image_size: Optional[Tuple[int]] = None,
+#                  using_multi_turn: bool = False,
+#                  **kwargs) -> str:
+#         try:
+#             # To ensure empty history
+#             self.reset_history()
+
+#             # Prompts
+#             parser = JsonOutputParser(pydantic_object=ScheduleModel)
+#             prompt = ChatPromptTemplate.from_messages(
+#                 [
+#                     ('system', system_prompt),
+#                     ('human', user_prompt)
+#                 ]
+#             ).partial(format_instructions=parser.get_format_instructions())
+#             chain = prompt | self.client_lc | parser
+            
+#             # Model response
+#             response = chain.invoke(kwargs)
+
+#             return response
+        
+#         except Exception as e:
+#             raise e