Add callbacks for debugging

.gitignore

@@ -24,3 +24,6 @@ instructor-*.tar
 
 # Temporary files, for example, from tests.
 /tmp/
+
+*.DS_Store
+llama.log

lib/instructor.ex

@@ -32,6 +32,8 @@ defmodule Instructor do
     * `:mode` - The mode to use when parsing the response, :tools, :json, :md_json (defaults to `:tools`), generally speaking you don't need to change this unless you are not using OpenAI.
     * `:max_retries` - The maximum number of times to retry the LLM call if it fails, or does not pass validations.
                        (defaults to `0`)
+    * `:before_request` - An optional callback function, to run just before passing a request to the LLM, useful for debugging.
+    * `:after_response` - An optional callback function to run after receiving a response from the LLM, and before processing the response, useful for debugging.
 
   ## Examples
 

lib/instructor/adapters/llamacpp.ex

@@ -34,38 +34,51 @@ defmodule Instructor.Adapters.Llamacpp do
   def chat_completion(params, _config \\ nil) do
     {response_model, _} = Keyword.pop!(params, :response_model)
     {messages, _} = Keyword.pop!(params, :messages)
+    {before_request, params} = Keyword.pop(params, :before_request)
+    {after_response, params} = Keyword.pop(params, :after_response)
 
     json_schema = JSONSchema.from_ecto_schema(response_model)
     grammar = GBNF.from_json_schema(json_schema)
     prompt = apply_chat_template(chat_template(), messages)
     stream = Keyword.get(params, :stream, false)
 
     if stream do
-      do_streaming_chat_completion(prompt, grammar)
+      do_streaming_chat_completion(prompt, grammar, before_request, after_response)
     else
-      do_chat_completion(prompt, grammar)
+      do_chat_completion(prompt, grammar, before_request, after_response)
     end
   end
 
-  defp do_streaming_chat_completion(prompt, grammar) do
+  defp do_streaming_chat_completion(prompt, grammar, before_request, after_response) do
     pid = self()
 
     Stream.resource(
       fn ->
         Task.async(fn ->
-          Req.post!(url(),
-            json: %{
-              grammar: grammar,
-              prompt: prompt,
-              stream: true
-            },
-            receive_timeout: 60_000,
-            into: fn {:data, data}, {req, resp} ->
-              send(pid, data)
-              {:cont, {req, resp}}
-            end
-          )
-
+          req =
+            Req.new(
+              url: url(),
+              json: %{
+                grammar: grammar,
+                prompt: prompt,
+                stream: true
+              },
+              receive_timeout: 60_000,
+              into: fn {:data, data}, {req, resp} ->
+                if is_function(after_response) do
+                  after_response.({{:data, data}, {req, resp}})
+                end
+
+                send(pid, data)
+                {:cont, {req, resp}}
+              end
+            )
+
+          if is_function(before_request) do
+            before_request.(req)
+          end
+
+          Req.post!(req)
           send(pid, :done)
         end)
       end,
@@ -94,16 +107,27 @@ defmodule Instructor.Adapters.Llamacpp do
     }
   end
 
-  defp do_chat_completion(prompt, grammar) do
-    response =
-      Req.post!(url(),
+  defp do_chat_completion(prompt, grammar, before_request, after_response) do
+    req =
+      Req.new(
+        url: url(),
         json: %{
           grammar: grammar,
           prompt: prompt
         },
         receive_timeout: 60_000
       )
 
+    if is_function(before_request) do
+      before_request.(req)
+    end
+
+    response = Req.post!(req)
+
+    if is_function(after_response) do
+      after_response.(response)
+    end
+
     case response do
       %{status: 200, body: %{"content" => params}} ->
         {:ok, to_openai_response(params)}

lib/instructor/adapters/openai.ex

@@ -13,17 +13,19 @@ defmodule Instructor.Adapters.OpenAI do
     {_, params} = Keyword.pop(params, :validation_context)
     {_, params} = Keyword.pop(params, :max_retries)
     {_, params} = Keyword.pop(params, :mode)
+    {before_request, params} = Keyword.pop(params, :before_request)
+    {after_response, params} = Keyword.pop(params, :after_response)
     stream = Keyword.get(params, :stream, false)
     params = Enum.into(params, %{})
 
     if stream do
-      do_streaming_chat_completion(params, config)
+      do_streaming_chat_completion(params, config, before_request, after_response)
     else
-      do_chat_completion(params, config)
+      do_chat_completion(params, config, before_request, after_response)
     end
   end
 
-  defp do_streaming_chat_completion(params, config) do
+  defp do_streaming_chat_completion(params, config, before_request, after_response) do
     pid = self()
     options = http_options(config)
 
@@ -35,6 +37,10 @@ defmodule Instructor.Adapters.OpenAI do
               json: params,
               auth: {:bearer, api_key(config)},
               into: fn {:data, data}, {req, resp} ->
+                if is_function(after_response) do
+                  after_response.({{:data, data}, {req, resp}})
+                end
+
                 chunks =
                   data
                   |> String.split("\n")
@@ -55,7 +61,13 @@ defmodule Instructor.Adapters.OpenAI do
               end
             )
 
-          Req.post!(url(config), options)
+          req = Req.new([url: url(config)] ++ options)
+
+          if is_function(before_request) do
+            before_request.(req)
+          end
+
+          Req.post!(req)
           send(pid, :done)
         end)
       end,
@@ -75,9 +87,19 @@ defmodule Instructor.Adapters.OpenAI do
     )
   end
 
-  defp do_chat_completion(params, config) do
+  defp do_chat_completion(params, config, before_request, after_response) do
     options = Keyword.merge(http_options(config), json: params, auth: {:bearer, api_key(config)})
-    response = Req.post!(url(config), options)
+    req = Req.new([url: url(config)] ++ options)
+
+    if is_function(before_request) do
+      before_request.(req)
+    end
+
+    response = Req.post!(req)
+
+    if is_function(after_response) do
+      after_response.(response)
+    end
 
     case response.status do
       200 -> {:ok, response.body}