npcsh 0.3.30__py3-none-any.whl → 0.3.32__py3-none-any.whl

npcsh/llm_funcs.py

@@ -19,7 +19,7 @@ from google.generativeai import types
 import google.generativeai as genai
 from sqlalchemy import create_engine
 
-from .npc_sysenv import (
+from npcsh.npc_sysenv import (
     get_system_message,
     get_available_models,
     get_model_and_provider,
@@ -35,50 +35,41 @@ from .npc_sysenv import (
     NPCSH_REASONING_PROVIDER,
     NPCSH_IMAGE_GEN_MODEL,
     NPCSH_IMAGE_GEN_PROVIDER,
-    NPCSH_API_URL,
+    NPCSH_VIDEO_GEN_MODEL,
+    NPCSH_VIDEO_GEN_PROVIDER,
     NPCSH_VISION_MODEL,
     NPCSH_VISION_PROVIDER,
     available_reasoning_models,
     available_chat_models,
 )
 
-from .stream import (
-    get_ollama_stream,
-    get_openai_stream,
-    get_anthropic_stream,
-    get_openai_like_stream,
-    get_deepseek_stream,
-    get_gemini_stream,
+from npcsh.stream import get_litellm_stream
+from npcsh.conversation import (
+    get_litellm_conversation,
 )
-from .conversation import (
-    get_ollama_conversation,
-    get_openai_conversation,
-    get_openai_like_conversation,
-    get_anthropic_conversation,
-    get_deepseek_conversation,
-    get_gemini_conversation,
+from npcsh.response import (
+    get_litellm_response,
 )
-
-from .response import (
-    get_ollama_response,
-    get_openai_response,
-    get_anthropic_response,
-    get_openai_like_response,
-    get_deepseek_response,
-    get_gemini_response,
+from npcsh.image_gen import (
+    generate_image_litellm,
 )
-from .image_gen import (
-    generate_image_openai,
-    generate_image_hf_diffusion,
+from npcsh.video_gen import (
+    generate_video_diffusers,
 )
 
-from .embeddings import (
+from npcsh.embeddings import (
     get_ollama_embeddings,
     get_openai_embeddings,
     get_anthropic_embeddings,
     store_embeddings_for_model,
 )
 
+import asyncio
+import sys
+from queue import Queue
+from threading import Thread
+import select
+
 
 def generate_image(
     prompt: str,
@@ -87,9 +78,7 @@ def generate_image(
     filename: str = None,
     npc: Any = None,
 ):
-    """
-    Function Description:
-        This function generates an image using the specified provider and model.
+    """This function generates an image using the specified provider and model.
     Args:
         prompt (str): The prompt for generating the image.
     Keyword Args:
@@ -118,23 +107,11 @@ def generate_image(
             os.path.expanduser("~/.npcsh/images/")
             + f"image_{datetime.now().strftime('%Y%m%d_%H%M%S')}.png"
         )
-
-    # if provider == "ollama":
-    #    image = generate_image_ollama(prompt, model)
-    if provider == "openai":
-        image = generate_image_openai(
-            prompt,
-            model,
-            npc=npc,
-        )
-    # elif provider == "anthropic":
-    #    image = generate_image_anthropic(prompt, model, anthropic_api_key)
-    # elif provider == "openai-like":
-    #    image = generate_image_openai_like(prompt, model, npc.api_url, openai_api_key)
-    elif provider == "diffusers":
-        image = generate_image_hf_diffusion(prompt, model)
-    else:
-        image = None
+    generate_image_litellm(
+        prompt=prompt,
+        model=model,
+        provider=provider,
+    )
     # save image
     # check if image is a PIL image
     if isinstance(image, PIL.Image.Image):
@@ -191,9 +168,7 @@ def get_llm_response(
     context=None,
     **kwargs,
 ):
-    """
-    Function Description:
-        This function generates a response using the specified provider and model.
+    """This function generates a response using the specified provider and model.
     Args:
         prompt (str): The prompt for generating the response.
     Keyword Args:
@@ -208,6 +183,7 @@ def get_llm_response(
     """
     if model is not None and provider is not None:
         pass
+
     elif provider is None and model is not None:
         provider = lookup_provider(model)
 
@@ -227,84 +203,17 @@ def get_llm_response(
             model = "llama3.2"
     # print(provider, model)
     # print(provider, model)
-    if provider == "ollama":
-        if model is None:
-            if images is not None:
-                model = "llama:7b"
-            else:
-                model = "llama3.2"
-        elif images is not None and model not in [
-            "x/llama3.2-vision",
-            "llama3.2-vision",
-            "llava-llama3",
-            "bakllava",
-            "moondream",
-            "llava-phi3",
-            "minicpm-v",
-            "hhao/openbmb-minicpm-llama3-v-2_5",
-            "aiden_lu/minicpm-v2.6",
-            "xuxx/minicpm2.6",
-            "benzie/llava-phi-3",
-            "mskimomadto/chat-gph-vision",
-            "xiayu/openbmb-minicpm-llama3-v-2_5",
-            "0ssamaak0/xtuner-llava",
-            "srizon/pixie",
-            "jyan1/paligemma-mix-224",
-            "qnguyen3/nanollava",
-            "knoopx/llava-phi-2",
-            "nsheth/llama-3-lumimaid-8b-v0.1-iq-imatrix",
-            "bigbug/minicpm-v2.5",
-        ]:
-            model = "llava:7b"
-        # print(model)
-        return get_ollama_response(
-            prompt, model, npc=npc, messages=messages, images=images, **kwargs
-        )
-    elif provider == "gemini":
-        if model is None:
-            model = "gemini-2.0-flash"
-        return get_gemini_response(
-            prompt, model, npc=npc, messages=messages, images=images, **kwargs
-        )
 
-    elif provider == "deepseek":
-        if model is None:
-            model = "deepseek-chat"
-        # print(prompt, model, provider)
-        return get_deepseek_response(
-            prompt, model, npc=npc, messages=messages, images=images, **kwargs
-        )
-    elif provider == "openai":
-        if model is None:
-            model = "gpt-4o-mini"
-        # print(model)
-        return get_openai_response(
-            prompt, model, npc=npc, messages=messages, images=images, **kwargs
-        )
-    elif provider == "openai-like":
-        if api_url is None:
-            raise ValueError("api_url is required for openai-like provider")
-        return get_openai_like_response(
-            prompt,
-            model,
-            api_url,
-            api_key,
-            npc=npc,
-            messages=messages,
-            images=images,
-            **kwargs,
-        )
-
-    elif provider == "anthropic":
-        if model is None:
-            model = "claude-3-haiku-20240307"
-        return get_anthropic_response(
-            prompt, model, npc=npc, messages=messages, images=images, **kwargs
-        )
-    else:
-        # print(provider)
-        # print(model)
-        return "Error: Invalid provider specified."
+    response = get_litellm_response(
+        prompt,
+        model=model,
+        provider=provider,
+        npc=npc,
+        api_url=api_url,
+        api_key=api_key,
+        **kwargs,
+    )
+    return response
 
 
 def get_stream(
@@ -318,9 +227,7 @@ def get_stream(
     context=None,
     **kwargs,
 ) -> List[Dict[str, str]]:
-    """
-    Function Description:
-        This function generates a streaming response using the specified provider and model
+    """This function generates a streaming response using the specified provider and model
     Args:
         messages (List[Dict[str, str]]): The list of messages in the conversation.
     Keyword Args:
@@ -335,6 +242,7 @@ def get_stream(
     if model is not None and provider is not None:
         pass
     elif model is not None and provider is None:
+        print(provider)
         provider = lookup_provider(model)
     elif npc is not None:
         if npc.provider is not None:
@@ -347,32 +255,50 @@ def get_stream(
         provider = "ollama"
         model = "llama3.2"
     # print(model, provider)
-    if provider == "ollama":
-        return get_ollama_stream(messages, model, npc=npc, images=images, **kwargs)
-    elif provider == "openai":
-        return get_openai_stream(
-            messages, model, npc=npc, api_key=api_key, images=images, **kwargs
-        )
-    elif provider == "anthropic":
-        return get_anthropic_stream(
-            messages, model, npc=npc, api_key=api_key, images=images, **kwargs
-        )
-    elif provider == "openai-like":
-        return get_openai_like_stream(
-            messages,
-            model,
-            api_url,
-            npc=npc,
-            api_key=api_key,
-            images=images,
-            **kwargs,
-        )
-    elif provider == "deepseek":
-        return get_deepseek_stream(messages, model, npc=npc, api_key=api_key, **kwargs)
-    elif provider == "gemini":
-        return get_gemini_stream(messages, model, npc=npc, api_key=api_key, **kwargs)
-    else:
-        return "Error: Invalid provider specified."
+
+    return get_litellm_stream(
+        messages,
+        model=model,
+        provider=provider,
+        npc=npc,
+        api_url=api_url,
+        api_key=api_key,
+        images=images,
+        **kwargs,
+    )
+
+
+def generate_video(
+    prompt,
+    model: str = NPCSH_VIDEO_GEN_MODEL,
+    provider: str = NPCSH_VIDEO_GEN_PROVIDER,
+    npc: Any = None,
+    device: str = "cpu",
+    output_path="",
+    num_inference_steps=10,
+    num_frames=10,
+    height=256,
+    width=256,
+    messages: list = None,
+):
+    """
+    Function Description:
+        This function generates a video using the Stable Diffusion API.
+    Args:
+        prompt (str): The prompt for generating the video.
+        model_id (str): The Hugging Face model ID to use for Stable Diffusion.
+        device (str): The device to run the model on ('cpu' or 'cuda').
+    Returns:
+        PIL.Image: The generated image.
+    """
+    output_path = generate_video_diffusers(
+        prompt,
+        model,
+        npc=npc,
+        device=device,
+    )
+    if provider == "diffusers":
+        return {"output": "output path at " + output_path, "messages": messages}
 
 
 def get_conversation(
@@ -385,9 +311,7 @@ def get_conversation(
     context=None,
     **kwargs,
 ) -> List[Dict[str, str]]:
-    """
-    Function Description:
-        This function generates a conversation using the specified provider and model.
+    """This function generates a conversation using the specified provider and model.
     Args:
         messages (List[Dict[str, str]]): The list of messages in the conversation.
     Keyword Args:
@@ -397,7 +321,6 @@ def get_conversation(
     Returns:
         List[Dict[str, str]]: The list of messages in the conversation.
     """
-
     if model is not None and provider is not None:
         pass  # Use explicitly provided model and provider
     elif model is not None and provider is None:
@@ -410,30 +333,15 @@ def get_conversation(
         provider = "ollama"
         model = "llava:7b" if images is not None else "llama3.2"
 
-    # print(provider, model)
-    if provider == "ollama":
-        return get_ollama_conversation(
-            messages, model, npc=npc, images=images, **kwargs
-        )
-    elif provider == "openai":
-        return get_openai_conversation(
-            messages, model, npc=npc, images=images, **kwargs
-        )
-    elif provider == "openai-like":
-        return get_openai_like_conversation(
-            messages, model, api_url, npc=npc, images=images, **kwargs
-        )
-    elif provider == "anthropic":
-        return get_anthropic_conversation(
-            messages, model, npc=npc, images=images, **kwargs
-        )
-    elif provider == "gemini":
-        return get_gemini_conversation(messages, model, npc=npc, **kwargs)
-    elif provider == "deepseek":
-        return get_deepseek_conversation(messages, model, npc=npc, **kwargs)
-
-    else:
-        return "Error: Invalid provider specified."
+    return get_litellm_conversation(
+        messages,
+        model=model,
+        provider=provider,
+        npc=npc,
+        api_url=api_url,
+        images=images,
+        **kwargs,
+    )
 
 
 def execute_llm_question(
@@ -540,9 +448,7 @@ def execute_llm_command(
     stream=False,
     context=None,
 ) -> str:
-    """
-    Function Description:
-        This function executes an LLM command.
+    """This function executes an LLM command.
     Args:
         command (str): The command to execute.
 
@@ -749,16 +655,16 @@ def check_llm_command(
     api_url: str = NPCSH_API_URL,
     api_key: str = None,
     npc: Any = None,
+    npc_team: Any = None,
     retrieved_docs=None,
     messages: List[Dict[str, str]] = None,
     images: list = None,
     n_docs=5,
     stream=False,
     context=None,
+    whisper=False,
 ):
-    """
-    Function Description:
-        This function checks an LLM command.
+    """This function checks an LLM command.
     Args:
         command (str): The command to check.
     Keyword Args:
@@ -814,71 +720,73 @@ ReAct choices then will enter reasoning flow
 
     4. Is it a complex request that actually requires more than one
         tool to be called, perhaps in a sequence?
+        Sequences should only be used for more than one consecutive tool call. do not invoke seequences for single tool calls.
 
     5. is there a need for the user to provide additional input to fulfill the request?
 
 
 
-    Available tools:
     """
 
-    if (npc.tools_dict is None or npc.tools_dict == {}) & (
-        npc.all_tools_dict is None or npc.all_tools_dict == {}
-    ):
-        prompt += "No tools available. Do not invoke tools."
-    else:
-        tools_set = {}
-
-        if npc.tools_dict is not None:
-            for tool_name, tool in npc.tools_dict.items():
-                if tool_name not in tools_set:
-                    tools_set[tool_name] = tool.description
-        if npc.all_tools_dict is not None:
-            for tool_name, tool in npc.all_tools_dict.items():
-                if tool_name not in tools_set:
-                    tools_set[tool_name] = tool.description
-
-        for tool_name, tool_description in tools_set.items():
-            prompt += f"""
-
-                        {tool_name} : {tool_description} \n
-                        """
+    if npc is not None or npc_team is not None:
+        if (npc.tools_dict is None or npc.tools_dict == {}) & (
+            npc.all_tools_dict is None or npc.all_tools_dict == {}
+        ):
+            prompt += "No tools available. Do not invoke tools."
+        else:
+            prompt += "Available tools: \n"
+            tools_set = {}
+
+            if npc.tools_dict is not None:
+                for tool_name, tool in npc.tools_dict.items():
+                    if tool_name not in tools_set:
+                        tools_set[tool_name] = tool.description
+            if npc.all_tools_dict is not None:
+                for tool_name, tool in npc.all_tools_dict.items():
+                    if tool_name not in tools_set:
+                        tools_set[tool_name] = tool.description
+
+            for tool_name, tool_description in tools_set.items():
+                prompt += f"""
 
-    prompt += f"""
-    Available NPCs for alternative answers:
+                            {tool_name} : {tool_description} \n
+                            """
 
-    """
-    if len(npc.resolved_npcs) == 0:
-        prompt += "No NPCs available for alternative answers."
-    else:
-        print(npc.resolved_npcs)
-        for i, npc_in_network in enumerate(npc.resolved_npcs):
-            name = list(npc_in_network.keys())[0]
-            npc_obj = npc_in_network[name]
-
-            if hasattr(npc_obj, "name"):
-                name_to_include = npc_obj.name
-            elif "name " in npc_obj:
-                name_to_include = npc_obj["name"]
-
-            if hasattr(npc_obj, "primary_directive"):
-                primary_directive_to_include = npc_obj.primary_directive
-            elif "primary_directive" in npc_obj:
-                primary_directive_to_include = npc_obj["primary_directive"]
+        if len(npc.resolved_npcs) == 0:
+            prompt += "No NPCs available for alternative answers."
+        else:
             prompt += f"""
-            ({i})
+            Available NPCs for alternative answers:
 
-            NPC: {name_to_include}
-            Primary Directive : {primary_directive_to_include}
+            """
+            print(npc.resolved_npcs)
+            for i, npc_in_network in enumerate(npc.resolved_npcs):
+                name = list(npc_in_network.keys())[0]
+                npc_obj = npc_in_network[name]
+
+                if hasattr(npc_obj, "name"):
+                    name_to_include = npc_obj.name
+                elif "name " in npc_obj:
+                    name_to_include = npc_obj["name"]
+
+                if hasattr(npc_obj, "primary_directive"):
+                    primary_directive_to_include = npc_obj.primary_directive
+                elif "primary_directive" in npc_obj:
+                    primary_directive_to_include = npc_obj["primary_directive"]
+                prompt += f"""
+                ({i})
 
+                NPC: {name_to_include}
+                Primary Directive : {primary_directive_to_include}
+
+                """
+        if npc.shared_context:
+            prompt += f"""
+            Relevant shared context for the npc:
+            {npc.shared_context}
             """
-    if npc.shared_context:
-        prompt += f"""
-        Relevant shared context for the npc:
-        {npc.shared_context}
-        """
-        # print("shared_context: " + str(npc.shared_context))
-    # print(prompt)
+            # print("shared_context: " + str(npc.shared_context))
+        # print(prompt)
 
     prompt += f"""
     In considering how to answer this, consider:
@@ -891,7 +799,7 @@ ReAct choices then will enter reasoning flow
     - Whether a tool should be used.
 
 
-    Excluding time-sensitive phenomena,
+    Excluding time-sensitive phenomena or ones that require external data inputs /information,
     most general questions can be answered without any
     extra tools or agent passes.
     Only use tools or pass to other NPCs
@@ -926,7 +834,8 @@ ReAct choices then will enter reasoning flow
     }}
 
     If you execute a sequence, ensure that you have a specified NPC for each tool use.
-
+        question answering is not a tool use.
+        "invoke_tool" should never be used in the list of tools when executing a sequence.
     Remember, do not include ANY ADDITIONAL MARKDOWN FORMATTING.
     There should be no leading ```json.
 
@@ -946,6 +855,27 @@ ReAct choices then will enter reasoning flow
         {context}
 
         """
+    if whisper:
+        prompt += f"""
+        IMPORTANT!!!
+
+        This check is part of a npcsh whisper mode conversation.
+
+        This mode is a mode wherein the user speaks and receives
+        audio that has been played through TTS.
+        Thus, consider it to be a more casual conversation
+        and engage in regular conversation
+        unless they specifically mention in their request.
+        And if something is confusing or seems like it needs
+        additional context,
+        do not worry too mucuh about it because this
+        information is likely contained within the historical messages between
+        the user and the LLM and you can let the downstream
+        agent navigate asking followup questions .
+
+
+        """
+
     action_response = get_llm_response(
         prompt,
         model=model,
@@ -975,10 +905,11 @@ ReAct choices then will enter reasoning flow
         response_content_parsed = response_content
 
     action = response_content_parsed.get("action")
-    explanation = response_content["explanation"]
+    explanation = response_content_parsed.get("explanation")
     print(f"action chosen: {action}")
     print(f"explanation given: {explanation}")
 
+    # print(response_content)
     if response_content_parsed.get("tool_name"):
         print(f"tool name: {response_content_parsed.get('tool_name')}")
 
@@ -1110,15 +1041,22 @@ ReAct choices then will enter reasoning flow
     elif action == "execute_sequence":
         tool_names = response_content_parsed.get("tool_name")
         npc_names = response_content_parsed.get("npc_name")
+
         # print(npc_names)
         npcs = []
         # print(tool_names, npc_names)
         if isinstance(npc_names, list):
+            if len(npc_names) == 0:
+                # if no npcs are specified, just have the npc take care of it itself instead of trying to force it to generate npc names for sequences all the time
+
+                npcs = [npc] * len(tool_names)
             for npc_name in npc_names:
                 for npc_obj in npc.resolved_npcs:
                     if npc_name in npc_obj:
                         npcs.append(npc_obj[npc_name])
                         break
+                if len(npcs) < len(tool_names):
+                    npcs.append(npc)
 
         output = ""
         results_tool_calls = []
@@ -1137,10 +1075,11 @@ ReAct choices then will enter reasoning flow
                     retrieved_docs=retrieved_docs,
                     stream=stream,
                 )
+                # print(result)
                 results_tool_calls.append(result)
                 messages = result.get("messages", messages)
                 output += result.get("output", "")
-                print(output)
+                # print(results_tool_calls)
         else:
             for npc_obj in npcs:
                 result = npc.handle_agent_pass(
@@ -1154,7 +1093,7 @@ ReAct choices then will enter reasoning flow
 
                 messages = result.get("messages", messages)
                 results_tool_calls.append(result.get("response"))
-                print(messages[-1])
+                # print(messages[-1])
         # import pdb
 
         # pdb.set_trace()
@@ -1181,9 +1120,7 @@ def handle_tool_call(
     attempt=0,
     context=None,
 ) -> Union[str, Dict[str, Any]]:
-    """
-    Function Description:
-        This function handles a tool call.
+    """This function handles a tool call.
     Args:
         command (str): The command.
         tool_name (str): The tool name.
@@ -1312,22 +1249,22 @@ def handle_tool_call(
     # try:
     print("Executing tool with input values:", input_values)
 
-    try:
-        tool_output = tool.execute(
-            input_values,
-            npc.all_tools_dict,
-            jinja_env,
-            command,
-            model=model,
-            provider=provider,
-            npc=npc,
-            stream=stream,
-            messages=messages,
-        )
-        if not stream:
-            if "Error" in tool_output:
-                raise Exception(tool_output)
-    except Exception as e:
+    # try:
+    tool_output = tool.execute(
+        input_values,
+        npc.all_tools_dict,
+        jinja_env,
+        command,
+        model=model,
+        provider=provider,
+        npc=npc,
+        stream=stream,
+        messages=messages,
+    )
+    if not stream:
+        if "Error" in tool_output:
+            raise Exception(tool_output)
+        # except Exception as e:
         # diagnose_problem = get_llm_response(
         ##    f"""a problem has occurred.
         #                                    Please provide a diagnosis of the problem and a suggested #fix.
@@ -1352,24 +1289,32 @@ def handle_tool_call(
         # suggested_solution = diagnose_problem.get("response", {}).get(
         #    "suggested_solution"
         # )
-
-        tool_output = handle_tool_call(
-            command,
-            tool_name,
-            model=model,
-            provider=provider,
-            messages=messages,
-            npc=npc,
-            api_url=api_url,
-            api_key=api_key,
-            retrieved_docs=retrieved_docs,
-            n_docs=n_docs,
-            stream=stream,
-            attempt=attempt + 1,
-            n_attempts=n_attempts,
-            context=f""" \n \n \n "tool failed: {e}  \n \n \n here was the previous attempt: {input_values}""",
-        )
-
+        '''
+        print(f"An error occurred while executing the tool: {e}")
+        print(f"trying again, attempt {attempt+1}")
+        if attempt < n_attempts:
+            tool_output = handle_tool_call(
+                command,
+                tool_name,
+                model=model,
+                provider=provider,
+                messages=messages,
+                npc=npc,
+                api_url=api_url,
+                api_key=api_key,
+                retrieved_docs=retrieved_docs,
+                n_docs=n_docs,
+                stream=stream,
+                attempt=attempt + 1,
+                n_attempts=n_attempts,
+                context=f""" \n \n \n "tool failed: {e}  \n \n \n here was the previous attempt: {input_values}""",
+            )
+        else:
+            user_input = input(
+                "the tool execution has failed after three tries, can you add more context to help or would you like to run again?"
+            )
+            return
+        '''
     if stream:
         return tool_output
     # print(f"Tool output: {tool_output}")
@@ -1388,9 +1333,7 @@ def execute_data_operations(
     npc: Any = None,
     db_path: str = "~/npcsh_history.db",
 ):
-    """
-    Function Description:
-        This function executes data operations.
+    """This function executes data operations.
     Args:
         query (str): The query to execute.
 
@@ -1777,7 +1720,7 @@ def get_data_response(
     #    failures.append(str(e))
 
 
-def enter_reasoning_human_in_the_loop(
+def enter_chat_human_in_the_loop(
     messages: List[Dict[str, str]],
     reasoning_model: str = NPCSH_REASONING_MODEL,
     reasoning_provider: str = NPCSH_REASONING_PROVIDER,
@@ -1826,7 +1769,35 @@ def enter_reasoning_human_in_the_loop(
     in_think_block = False
 
     for chunk in response_stream:
-        # Extract content based on provider/model type
+        # Check for user interrupt
+        if not input_queue.empty():
+            user_interrupt = input_queue.get()
+            yield "\n[Stream interrupted by user]\n"
+            yield "Enter your additional input: "
+
+            # Get the full interrupt message
+            full_interrupt = user_interrupt
+            while not input_queue.empty():
+                full_interrupt += "\n" + input_queue.get()
+
+            # Add the interruption to messages and restart stream
+            messages.append(
+                {"role": "user", "content": f"[INTERRUPT] {full_interrupt}"}
+            )
+
+            yield f"\n[Continuing with added context...]\n"
+            yield from enter_chat_human_in_the_loop(
+                messages,
+                reasoning_model=reasoning_model,
+                reasoning_provider=reasoning_provider,
+                chat_model=chat_model,
+                chat_provider=chat_provider,
+                npc=npc,
+                answer_only=True,
+            )
+            return
+
+        # Extract content based on provider
         if reasoning_provider == "ollama":
             chunk_content = chunk.get("message", {}).get("content", "")
         elif reasoning_provider == "openai" or reasoning_provider == "deepseek":
@@ -1841,80 +1812,191 @@ def enter_reasoning_human_in_the_loop(
             else:
                 chunk_content = ""
         else:
-            # Default extraction
             chunk_content = str(chunk)
 
-        # Always yield the chunk whether in think block or not
         response_chunks.append(chunk_content)
-        # Track think block state and accumulate thoughts
-        if answer_only:
+        combined_text = "".join(response_chunks)
+
+        # Check for LLM request block
+        if (
+            "<request_for_input>" in combined_text
+            and "</request_for_input>" not in combined_text
+        ):
+            in_think_block = True
+
+        if in_think_block:
+            thoughts.append(chunk_content)
             yield chunk
-        else:
-            if "<th" in "".join(response_chunks) and "/th" not in "".join(
-                response_chunks
-            ):
-                in_think_block = True
-
-            if in_think_block:
-                thoughts.append(chunk_content)
-                yield chunk  # Show the thoughts as they come
-
-            if "</th" in "".join(response_chunks):
-                thought_text = "".join(thoughts)
-                # Analyze thoughts before stopping
-                input_needed = analyze_thoughts_for_input(
-                    thought_text, model=chat_model, provider=chat_provider
-                )
 
-                if input_needed:
-                    # If input needed, get it and restart with new context
-                    user_input = request_user_input(input_needed)
+        if "</request_for_input>" in combined_text:
+            # Process the LLM's input request
+            request_text = "".join(thoughts)
+            yield "\nPlease provide the requested information: "
+
+            # Wait for user input (blocking here is OK since we explicitly asked)
+            user_input = input()
+
+            # Add the interaction to messages and restart stream
+            messages.append({"role": "assistant", "content": request_text})
+            messages.append({"role": "user", "content": user_input})
+
+            yield "\n[Continuing with provided information...]\n"
+            yield from enter_chat_human_in_the_loop(
+                messages,
+                reasoning_model=reasoning_model,
+                reasoning_provider=reasoning_provider,
+                chat_model=chat_model,
+                chat_provider=chat_provider,
+                npc=npc,
+                answer_only=True,
+            )
+            return
 
-                    messages.append(
-                        {
-                            "role": "assistant",
-                            "content": f"""its clear that extra input is required.
-                                            could you please provide it? Here is the reason:
+        if not in_think_block:
+            yield chunk
 
-                                            {input_needed['reason']},
 
-                                            and the prompt: {input_needed['prompt']}""",
-                        }
-                    )
+def enter_reasoning_human_in_the_loop(
+    messages: List[Dict[str, str]],
+    reasoning_model: str = NPCSH_REASONING_MODEL,
+    reasoning_provider: str = NPCSH_REASONING_PROVIDER,
+    chat_model: str = NPCSH_CHAT_MODEL,
+    chat_provider: str = NPCSH_CHAT_PROVIDER,
+    npc: Any = None,
+    answer_only: bool = False,
+    context=None,
+) -> Generator[str, None, None]:
+    """
+    Stream responses while checking for think tokens and handling human input when needed.
 
-                    messages.append({"role": "user", "content": user_input})
-                    yield from enter_reasoning_human_in_the_loop(
-                        messages,
-                        reasoning_model=reasoning_model,
-                        reasoning_provider=reasoning_provider,
-                        chat_model=chat_model,
-                        chat_provider=chat_provider,
-                        npc=npc,
-                        answer_only=True,
-                    )
-                else:
-                    # If no input needed, just get the answer
-                    messages.append({"role": "assistant", "content": thought_text})
-                    messages.append(
-                        {"role": "user", "content": messages[-2]["content"]}
-                    )
-                    yield from enter_reasoning_human_in_the_loop(  # Restart with new context
-                        messages,
-                        reasoning_model=reasoning_model,
-                        reasoning_provider=reasoning_provider,
-                        chat_model=chat_model,
-                        chat_provider=chat_provider,
-                        npc=npc,
-                        answer_only=True,
-                    )
+    Args:
+        messages: List of conversation messages
+        model: LLM model to use
+        provider: Model provider
+        npc: NPC instance if applicable
 
-                return  # Stop the original stream in either case
+    Yields:
+        Streamed response chunks
+    """
+    # Get the initial stream
+    if answer_only:
+        messages[-1]["content"] = (
+            messages[-1]["content"].replace(
+                "Think first though and use <think> tags", ""
+            )
+            + " Do not think just answer. "
+        )
+    else:
+        messages[-1]["content"] = (
+            messages[-1]["content"]
+            + "         Think first though and use <think> tags.  "
+        )
+
+    response_stream = get_stream(
+        messages,
+        model=reasoning_model,
+        provider=reasoning_provider,
+        npc=npc,
+        context=context,
+    )
+
+    thoughts = []
+    response_chunks = []
+    in_think_block = False
+
+    for chunk in response_stream:
+        # Check for user interrupt
+        if not input_queue.empty():
+            user_interrupt = input_queue.get()
+            yield "\n[Stream interrupted by user]\n"
+            yield "Enter your additional input: "
+
+            # Get the full interrupt message
+            full_interrupt = user_interrupt
+            while not input_queue.empty():
+                full_interrupt += "\n" + input_queue.get()
+
+            # Add the interruption to messages and restart stream
+            messages.append(
+                {"role": "user", "content": f"[INTERRUPT] {full_interrupt}"}
+            )
+
+            yield f"\n[Continuing with added context...]\n"
+            yield from enter_reasoning_human_in_the_loop(
+                messages,
+                reasoning_model=reasoning_model,
+                reasoning_provider=reasoning_provider,
+                chat_model=chat_model,
+                chat_provider=chat_provider,
+                npc=npc,
+                answer_only=True,
+            )
+            return
+
+        # Extract content based on provider
+        if reasoning_provider == "ollama":
+            chunk_content = chunk.get("message", {}).get("content", "")
+        elif reasoning_provider == "openai" or reasoning_provider == "deepseek":
+            chunk_content = "".join(
+                choice.delta.content
+                for choice in chunk.choices
+                if choice.delta.content is not None
+            )
+        elif reasoning_provider == "anthropic":
+            if chunk.type == "content_block_delta":
+                chunk_content = chunk.delta.text
+            else:
+                chunk_content = ""
+        else:
+            chunk_content = str(chunk)
+
+        response_chunks.append(chunk_content)
+        combined_text = "".join(response_chunks)
+
+        # Check for LLM request block
+        if (
+            "<request_for_input>" in combined_text
+            and "</request_for_input>" not in combined_text
+        ):
+            in_think_block = True
+
+        if in_think_block:
+            thoughts.append(chunk_content)
+            yield chunk
+
+        if "</request_for_input>" in combined_text:
+            # Process the LLM's input request
+            request_text = "".join(thoughts)
+            yield "\nPlease provide the requested information: "
+
+            # Wait for user input (blocking here is OK since we explicitly asked)
+            user_input = input()
+
+            # Add the interaction to messages and restart stream
+            messages.append({"role": "assistant", "content": request_text})
+            messages.append({"role": "user", "content": user_input})
+
+            yield "\n[Continuing with provided information...]\n"
+            yield from enter_reasoning_human_in_the_loop(
+                messages,
+                reasoning_model=reasoning_model,
+                reasoning_provider=reasoning_provider,
+                chat_model=chat_model,
+                chat_provider=chat_provider,
+                npc=npc,
+                answer_only=True,
+            )
+            return
+
+        if not in_think_block:
+            yield chunk
 
 
 def handle_request_input(
     context: str,
     model: str = NPCSH_CHAT_MODEL,
     provider: str = NPCSH_CHAT_PROVIDER,
+    whisper: bool = False,
 ):
     """
     Analyze text and decide what to request from the user
@@ -1947,7 +2029,7 @@ def handle_request_input(
         result = json.loads(result)
 
     user_input = request_user_input(
-        {"reason": result["request_reason"], "prompt": result["request_prompt"]}
+        {"reason": result["request_reason"], "prompt": result["request_prompt"]},
     )
     return user_input
 
@@ -2025,3 +2107,89 @@ def request_user_input(input_request: Dict[str, str]) -> str:
     """
     print(f"\nAdditional input needed: {input_request['reason']}")
     return input(f"{input_request['prompt']}: ")
+
+
+def check_user_input() -> Optional[str]:
+    """
+    Non-blocking check for user input.
+    Returns None if no input is available, otherwise returns the input string.
+    """
+    if select.select([sys.stdin], [], [], 0.0)[0]:
+        return input()
+    return None
+
+
+def input_listener(input_queue: Queue):
+    """
+    Continuously listen for user input in a separate thread.
+    """
+    while True:
+        try:
+            user_input = input()
+            input_queue.put(user_input)
+        except EOFError:
+            break
+
+
+def stream_with_interrupts(
+    messages: List[Dict[str, str]],
+    model: str,
+    provider: str,
+    npc: Any = None,
+    context=None,
+) -> Generator[str, None, None]:
+    """Stream responses with basic Ctrl+C handling and recursive conversation loop."""
+    response_stream = get_stream(
+        messages, model=model, provider=provider, npc=npc, context=context
+    )
+
+    try:
+        # Flag to track if streaming is complete
+        streaming_complete = False
+
+        for chunk in response_stream:
+            if provider == "ollama":
+                chunk_content = chunk.get("message", {}).get("content", "")
+            elif provider in ["openai", "deepseek"]:
+                chunk_content = "".join(
+                    choice.delta.content
+                    for choice in chunk.choices
+                    if choice.delta.content is not None
+                )
+            elif provider == "anthropic":
+                chunk_content = (
+                    chunk.delta.text if chunk.type == "content_block_delta" else ""
+                )
+            else:
+                chunk_content = str(chunk)
+
+            yield chunk_content
+
+            # Optional: Mark streaming as complete when no more chunks
+            if not chunk_content:
+                streaming_complete = True
+
+    except KeyboardInterrupt:
+        # Handle keyboard interrupt by getting user input
+        user_input = input("\n> ")
+        messages.append({"role": "user", "content": user_input})
+        yield from stream_with_interrupts(
+            messages, model=model, provider=provider, npc=npc, context=context
+        )
+
+    finally:
+        # Prompt for next input and continue conversation
+        while True:
+            user_input = input("\n> ")
+
+            # Option to exit the loop
+            if user_input.lower() in ["exit", "quit", "q"]:
+                break
+
+            # Add user input to messages
+            messages.append({"role": "user", "content": user_input})
+
+            # Recursively continue the conversation
+            yield from stream_with_interrupts(
+                messages, model=model, provider=provider, npc=npc, context=context
+            )