Removing LangChain and Rebuilding Executor (#1322)

* rebuilding executor

* removing langchain

* Making all tests good

* fixing types and adding ability for nor using system prompts

* improving types

* pleasing the types gods

* pleasing the types gods

* fixing parser, tools and executor

* making sure all tests pass

* final pass

* fixing type

* Updating Docs

* preparing to cut new version

src/crewai/utilities/converter.py

@@ -2,8 +2,7 @@ import json
 import re
 from typing import Any, Optional, Type, Union
 
-from langchain.schema import HumanMessage, SystemMessage
-from langchain_openai import ChatOpenAI
+from crewai.llm import LLM
 from pydantic import BaseModel, ValidationError
 
 from crewai.agents.agent_builder.utilities.base_output_converter import OutputConverter
@@ -28,7 +27,12 @@ class Converter(OutputConverter):
             if self.is_gpt:
                 return self._create_instructor().to_pydantic()
             else:
-                return self._create_chain().invoke({})
+                return LLM(model=self.llm).call(
+                    [
+                        {"role": "system", "content": self.instructions},
+                        {"role": "user", "content": self.text},
+                    ]
+                )
         except Exception as e:
             if current_attempt < self.max_attempts:
                 return self.to_pydantic(current_attempt + 1)
@@ -42,7 +46,14 @@ class Converter(OutputConverter):
             if self.is_gpt:
                 return self._create_instructor().to_json()
             else:
-                return json.dumps(self._create_chain().invoke({}).model_dump())
+                return json.dumps(
+                    LLM(model=self.llm).call(
+                        [
+                            {"role": "system", "content": self.instructions},
+                            {"role": "user", "content": self.text},
+                        ]
+                    )
+                )
         except Exception as e:
             if current_attempt < self.max_attempts:
                 return self.to_json(current_attempt + 1)
@@ -50,33 +61,39 @@ class Converter(OutputConverter):
 
     def _create_instructor(self):
         """Create an instructor."""
-        from crewai.utilities import Instructor
+        from crewai.utilities import InternalInstructor
 
-        inst = Instructor(
+        inst = InternalInstructor(
             llm=self.llm,
-            max_attempts=self.max_attempts,
             model=self.model,
             content=self.text,
             instructions=self.instructions,
         )
         return inst
 
-    def _create_chain(self):
+    def _convert_with_instructions(self):
         """Create a chain."""
         from crewai.utilities.crew_pydantic_output_parser import (
             CrewPydanticOutputParser,
         )
 
         parser = CrewPydanticOutputParser(pydantic_object=self.model)
-        new_prompt = SystemMessage(content=self.instructions) + HumanMessage(
-            content=self.text
+        result = LLM(model=self.llm).call(
+            [
+                {"role": "system", "content": self.instructions},
+                {"role": "user", "content": self.text},
+            ]
         )
-        return new_prompt | self.llm | parser
+        return parser.parse_result(result)
 
     @property
     def is_gpt(self) -> bool:
         """Return if llm provided is of gpt from openai."""
-        return isinstance(self.llm, ChatOpenAI) and self.llm.openai_api_base is None
+        return (
+            "gpt" in str(self.llm).lower()
+            or "o1-preview" in str(self.llm).lower()
+            or "o1-mini" in str(self.llm).lower()
+        )
 
 
 def convert_to_model(
@@ -89,23 +106,14 @@ def convert_to_model(
     model = output_pydantic or output_json
     if model is None:
         return result
-
     try:
         escaped_result = json.dumps(json.loads(result, strict=False))
         return validate_model(escaped_result, model, bool(output_json))
-    except json.JSONDecodeError as e:
-        Printer().print(
-            content=f"Error parsing JSON: {e}. Attempting to handle partial JSON.",
-            color="yellow",
-        )
+    except json.JSONDecodeError:
         return handle_partial_json(
             result, model, bool(output_json), agent, converter_cls
         )
-    except ValidationError as e:
-        Printer().print(
-            content=f"Pydantic validation error: {e}. Attempting to handle partial JSON.",
-            color="yellow",
-        )
+    except ValidationError:
         return handle_partial_json(
             result, model, bool(output_json), agent, converter_cls
         )
@@ -140,16 +148,10 @@ def handle_partial_json(
             if is_json_output:
                 return exported_result.model_dump()
             return exported_result
-        except json.JSONDecodeError as e:
-            Printer().print(
-                content=f"Error parsing JSON: {e}. The extracted JSON-like string is not valid JSON. Attempting alternative conversion method.",
-                color="yellow",
-            )
-        except ValidationError as e:
-            Printer().print(
-                content=f"Pydantic validation error: {e}. The JSON structure doesn't match the expected model. Attempting alternative conversion method.",
-                color="yellow",
-            )
+        except json.JSONDecodeError:
+            pass
+        except ValidationError:
+            pass
         except Exception as e:
             Printer().print(
                 content=f"Unexpected error during partial JSON handling: {type(e).__name__}: {e}. Attempting alternative conversion method.",
@@ -170,7 +172,6 @@ def convert_with_instructions(
 ) -> Union[dict, BaseModel, str]:
     llm = agent.function_calling_llm or agent.llm
     instructions = get_conversion_instructions(model, llm)
-
     converter = create_converter(
         agent=agent,
         converter_cls=converter_cls,
@@ -179,6 +180,7 @@ def convert_with_instructions(
         model=model,
         instructions=instructions,
     )
+
     exported_result = (
         converter.to_pydantic() if not is_json_output else converter.to_json()
     )
@@ -202,9 +204,12 @@ def get_conversion_instructions(model: Type[BaseModel], llm: Any) -> str:
 
 
 def is_gpt(llm: Any) -> bool:
-    from langchain_openai import ChatOpenAI
-
-    return isinstance(llm, ChatOpenAI) and llm.openai_api_base is None
+    """Return if llm provided is of gpt from openai."""
+    return (
+        "gpt" in str(llm).lower()
+        or "o1-preview" in str(llm).lower()
+        or "o1-mini" in str(llm).lower()
+    )
 
 
 def create_converter(