fix: open intepreter not properly working with ollama (#845)

* fix: consider the tool role when being in open interpreter

It uses a new message role tool, that contains some context for using
internal tools and the data it provides. So we need to consider it when
parsing messages, or when inserting context messages

Closes: #820

* fix lint

* fix tests

* change logic for open interpreter

* fix linting

* fix: open intepreter not properly working with ollama

It needs fixes in cli commands

* fixes in chunk and cli formattig

Author: yrobla

src/codegate/pipeline/cli/cli.py

@@ -1,5 +1,6 @@
 import re
 import shlex
+from typing import Optional
 
 from litellm import ChatCompletionRequest
 
@@ -46,6 +47,42 @@ async def codegate_cli(command):
     return await out_func(command[1:])
 
 
+def _get_cli_from_cline(
+    codegate_regex: re.Pattern[str], last_user_message_str: str
+) -> Optional[re.Match[str]]:
+    # Check if there are <task> or <feedback> tags
+    tag_match = re.search(r"<(task|feedback)>(.*?)</\1>", last_user_message_str, re.DOTALL)
+    if tag_match:
+        # Extract the content between the tags
+        stripped_message = tag_match.group(2).strip()
+    else:
+        # If no <task> or <feedback> tags, use the entire message
+        stripped_message = last_user_message_str.strip()
+
+    # Remove all other XML tags and trim whitespace
+    stripped_message = re.sub(r"<[^>]+>", "", stripped_message).strip()
+
+    # Check if "codegate" is the first word
+    match = codegate_regex.match(stripped_message)
+
+    return match
+
+
+def _get_cli_from_open_interpreter(last_user_message_str: str) -> Optional[re.Match[str]]:
+    # Find all occurrences of "### User:" blocks
+    user_blocks = re.findall(r"### User:\s*(.*?)(?=\n###|\Z)", last_user_message_str, re.DOTALL)
+
+    if user_blocks:
+        # Extract the last "### User:" block
+        last_user_block = user_blocks[-1].strip()
+
+        # Match "codegate" only in the last "### User:" block
+        codegate_regex = re.compile(r"^codegate\s*(.*?)\s*$", re.IGNORECASE)
+        match = codegate_regex.match(last_user_block)
+        return match
+    return None
+
+
 class CodegateCli(PipelineStep):
     """Pipeline step that handles codegate cli."""
 
@@ -83,25 +120,13 @@ async def process(
             codegate_regex = re.compile(r"^codegate(?:\s+(.*))?", re.IGNORECASE)
 
             if base_tool and base_tool in ["cline", "kodu"]:
-                # Check if there are <task> or <feedback> tags
-                tag_match = re.search(
-                    r"<(task|feedback)>(.*?)</\1>", last_user_message_str, re.DOTALL
-                )
-                if tag_match:
-                    # Extract the content between the tags
-                    stripped_message = tag_match.group(2).strip()
-                else:
-                    # If no <task> or <feedback> tags, use the entire message
-                    stripped_message = last_user_message_str.strip()
-
-                # Remove all other XML tags and trim whitespace
-                stripped_message = re.sub(r"<[^>]+>", "", stripped_message).strip()
-
-                # Check if "codegate" is the first word
-                match = codegate_regex.match(stripped_message)
+                match = _get_cli_from_cline(codegate_regex, last_user_message_str)
+            elif base_tool == "open interpreter":
+                match = _get_cli_from_open_interpreter(last_user_message_str)
             else:
                 # Check if "codegate" is the first word in the message
                 match = codegate_regex.match(last_user_message_str)
+
             if match:
                 command = match.group(1) or ""
                 command = command.strip()

src/codegate/providers/base.py

@@ -200,6 +200,13 @@ def _is_fim_request(self, request_url_path: str, data: Dict) -> bool:
         """
         Determine if the request is FIM by the URL or the data of the request.
         """
+        # first check if we are in specific tools to discard FIM
+        prompt = data.get("prompt", "")
+        tools = ["cline", "kodu", "open interpreter"]
+        for tool in tools:
+            if tool in prompt.lower():
+                #  those tools can never be FIM
+                return False
         # Avoid more expensive inspection of body by just checking the URL.
         if self._is_fim_request_url(request_url_path):
             return True

src/codegate/providers/ollama/adapter.py

@@ -33,7 +33,6 @@ def normalize(self, data: Dict) -> ChatCompletionRequest:
         # with a direct HTTP request. Since Ollama is local this is not critical.
         # if normalized_data.get("stream", False):
         #     normalized_data["stream_options"] = {"include_usage": True}
-
         return ChatCompletionRequest(**normalized_data)
 
     def denormalize(self, data: ChatCompletionRequest) -> Dict:

src/codegate/providers/ollama/completion_handler.py

@@ -11,7 +11,7 @@
 logger = structlog.get_logger("codegate")
 
 
-async def ollama_stream_generator(
+async def ollama_stream_generator(  # noqa: C901
     stream: AsyncIterator[ChatResponse], base_tool: str
 ) -> AsyncIterator[str]:
     """OpenAI-style SSE format"""
@@ -21,9 +21,7 @@ async def ollama_stream_generator(
                 # TODO We should wire in the client info so we can respond with
                 # the correct format and start to handle multiple clients
                 # in a more robust way.
-                if base_tool != "cline":
-                    yield f"{chunk.model_dump_json()}\n"
-                else:
+                if base_tool in ["cline", "kodu"]:
                     # First get the raw dict from the chunk
                     chunk_dict = chunk.model_dump()
                     # Create response dictionary in OpenAI-like format
@@ -64,6 +62,14 @@ async def ollama_stream_generator(
                             response[field] = chunk_dict[field]
 
                     yield f"\ndata: {json.dumps(response)}\n"
+                else:
+                    # if we do not have response, we set it
+                    chunk_dict = chunk.model_dump()
+                    if "response" not in chunk_dict:
+                        chunk_dict["response"] = chunk_dict.get("message", {}).get("content", "\n")
+                    if not chunk_dict["response"]:
+                        chunk_dict["response"] = "\n"
+                    yield f"{json.dumps(chunk_dict)}\n"
             except Exception as e:
                 logger.error(f"Error in stream generator: {str(e)}")
                 yield f"\ndata: {json.dumps({'error': str(e), 'type': 'error', 'choices': []})}\n"