Revert "test ollama and litellm" (#328)

docs/concepts/patching.md

@@ -54,7 +54,6 @@ from openai import OpenAI
 client = instructor.patch(OpenAI(), mode=Mode.MD_JSON)
 
 ```
-
 ### Schema Integration
 
 In JSON Mode, the schema is part of the system message:
@@ -83,64 +82,3 @@ user = UserExtract.from_response(response, mode=Mode.JSON)
 assert user.name.lower() == "jason"
 assert user.age == 25
 ```
-
-## Understanding the Chat Completion Parametsrs
-
-### Mode: FUNCTIONS
-
-- Adds `functions` and `function_call` keys with OpenAI schema information.
-- No direct content change in messages, but function-based response processing is guided.
-
-```python
-if mode == Mode.FUNCTIONS:
-    chat_completion_parameters["functions"] = [response_model.openai_schema]
-    chat_completion_parameters["function_call"] = {"name": response_model.openai_schema["name"]}
-```
-
-### Mode: TOOLS
-
-- Adds `tools` and `tool_choice` keys with tool details following the OpenAI schema.
-- Messages aren't modified in content; tool-based response processing is guided.
-
-```python
-if mode == Mode.TOOLS:
-    chat_completion_parameters["tools"] = [{"type": "function", "function": response_model.openai_schema}]
-    chat_completion_parameters["tool_choice"] = {"type": "function", "function": {"name": response_model.openai_schema["name"]}}
-```
-
-### Mode: JSON
-
-- Appends `response_format` to indicate a JSON object type.
-- Adds or modifies a system message for JSON format adherence and schema instructions.
-
-```python
-if mode == Mode.JSON:
-    chat_completion_parameters["response_format"] = {"type": "json_object"}
-    chat_completion_parameters["messages"].append({"role": "system", "content": "Provide response in JSON format adhering to the specified schema."})
-```
-
-### Mode: MD_JSON
-
-- Similar to JSON mode, but with Markdown code block formatting.
-- Adds a stop sequence for the Markdown JSON response and system message for instructions.
-
-````python
-if mode == Mode.MD_JSON:
-    chat_completion_parameters["response_format"] = {"type": "json_object"}
-    chat_completion_parameters["stop"] = "```"
-    chat_completion_parameters["messages"].append({"role": "system", "content": "Provide response in Markdown-formatted JSON within the code block."})
-````
-
-### Mode: JSON_SCHEMA
-
-- Appends `response_format` with a JSON object type and specific schema.
-- Modifies system messages for JSON schema formatting instructions.
-- Only supported by Anyscale!
-
-```python
-if mode == Mode.JSON_SCHEMA:
-    chat_completion_parameters["response_format"] = {"type": "json_object", "schema": response_model.model_json_schema()}
-    chat_completion_parameters["messages"].append({"role": "system", "content": "Format the response according to the following JSON schema: " + str(response_model.model_json_schema())})
-```
-
-In each mode, the chat completion parameters are adapted to ensure the assistant's response adheres to the specific format required.

examples/ollama/run.py

@@ -1,32 +0,0 @@
-from litellm import completion
-from pydantic import BaseModel
-
-import instructor
-from instructor.patch import wrap_chatcompletion
-
-completion = wrap_chatcompletion(completion, mode=instructor.Mode.MD_JSON)
-
-
-class User(BaseModel):
-    name: str
-    age: int
-
-
-response = completion(
-    model="ollama/mistral",
-    response_model=User,
-    messages=[
-        {
-            "role": "system",
-            "content": "You are a JSON Output system, only return valid JSON. YOU CAN ONLY RETURN WITH JSON NO TALKING",
-        },
-        {
-            "role": "user",
-            "content": "Extract `My name is John and I am 25 years old` into JSON",
-        },
-    ],
-    api_base="http://localhost:11434",
-)
-
-assert response.name == "John", "Name is not John"
-assert response.age == 25, "Age is not 25"

instructor/patch.py

@@ -49,10 +49,10 @@ def dump_message(message: ChatCompletionMessage) -> ChatCompletionMessageParam:
         "role": message.role,
         "content": message.content or "",
     }
-    if message.get("tool_calls", None) is not None:
+    if message.tool_calls is not None:
         ret["tool_calls"] = message.model_dump()["tool_calls"]
         ret["content"] += json.dumps(message.model_dump()["tool_calls"])
-    if message.get("function_call", None) is not None:
+    if message.function_call is not None:
         ret["content"] += json.dumps(message.model_dump()["function_call"])
     return ret
 
@@ -247,9 +247,9 @@ async def retry_async(
                         "role": "tool",
                         "tool_call_id": response.choices[0].message.tool_calls[0].id,
                         "name": response.choices[0].message.tool_calls[0].function.name,
-                        "content": "failure",
+                        "content": "failure"
                     }
-                )
+            )
             kwargs["messages"].append(
                 {
                     "role": "user",
@@ -302,7 +302,7 @@ def retry_sync(
                         "role": "tool",
                         "tool_call_id": response.choices[0].message.tool_calls[0].id,
                         "name": response.choices[0].message.tool_calls[0].function.name,
-                        "content": "failure",
+                        "content": "failure"
                     }
                 )
             kwargs["messages"].append(
@@ -417,4 +417,4 @@ def apatch(client: AsyncOpenAI, mode: Mode = Mode.FUNCTIONS):
     - `validation_context` parameter to validate the response using the pydantic model
     - `strict` parameter to use strict json parsing
     """
-    return patch(client, mode=mode)
+    return patch(client, mode=mode)