use OpenAgentsWeb, :controller

  alias OpenAgents.Inference.Models

  alias OpenAgents.Providers.Request

  alias OpenAgents.Providers.{Request, ToolDefinition, ToolOutput}

  alias OpenAgentsWeb.ApiError

  @default_model "gemini-3.7-flash"

  defp input_of(params) do

    case params["input"] do

      input when is_binary(input) and input != "" ->

        {:ok, [%{role: "user", content: input}]}

        {:ok, {[%{role: "user", content: input}], []}}

      [_ | _] = items ->

        {:ok, Enum.flat_map(items, &item_message/1)}

        {:ok, {Enum.flat_map(items, &item_message/1), Enum.flat_map(items, &item_output/1)}}

      _missing ->

        {:error, :input_missing}

  end

  # One OpenResponses input item as a provider message. Text rides in

  # `content` as a string or as `input_text`/`output_text` blocks; anything

  # `content` as a string or as `input_text`/`output_text` blocks; a replayed

  # `function_call` item becomes the assistant turn that asked for it, its

  # arguments the raw string the model produced, never interpreted. Anything

  # else contributes nothing rather than failing the request.

  defp item_message(%{"type" => "function_call"} = item) do

    call_id = string_or(item["call_id"], "")

    name = string_or(item["name"], "")

    if call_id == "" or name == "" do

      []

    else

      [

        %{

          role: "assistant",

          content: item_text(item["content"]),

          tool_calls: [

            %{call_id: call_id, name: name, arguments: string_or(item["arguments"], "{}")}

          ]

        }

      ]

    end

  end

  defp item_message(%{"type" => "function_call_output"}), do: []

  defp item_message(%{"role" => role} = item) when role in ["user", "assistant", "system"] do

    case item_text(item["content"]) do

      "" -> []

  defp item_message(_item), do: []

  # A `function_call_output` item answers a replayed call; the provider takes

  # it as a tool output keyed by the call id.

  defp item_output(%{"type" => "function_call_output"} = item) do

    call_id = string_or(item["call_id"], "")

    if call_id == "" do

      []

    else

      [%ToolOutput{call_id: call_id, output: %{"content" => item_text(item["output"])}}]

    end

  end

  defp item_output(_item), do: []

  defp string_or(value, _fallback) when is_binary(value) and value != "", do: value

  defp string_or(_value, fallback), do: fallback

  # OpenResponses function tools are flat (`{type, name, description,

  # parameters}`); the chat-completions nesting is accepted too, because the

  # first client of this surface converted from that shape.

  defp declared_tools(tools) when is_list(tools) do

    Enum.flat_map(tools, fn

      %{"name" => name} = tool when is_binary(name) and name != "" ->

        [

          %ToolDefinition{

            name: name,

            description: string_or(tool["description"], ""),

            input_schema: Map.get(tool, "parameters") || %{},

            strict: false

          }

        ]

      %{"function" => %{"name" => name} = function} when is_binary(name) ->

        [

          %ToolDefinition{

            name: name,

            description: string_or(function["description"], ""),

            input_schema: Map.get(function, "parameters") || %{},

            strict: false

          }

        ]

      _other ->

        []

    end)

  end

  defp declared_tools(_tools), do: []

  defp item_text(content) when is_binary(content), do: content

  defp item_text(blocks) when is_list(blocks) do

    if Models.available?(model), do: :ok, else: {:error, :model_unavailable}

  end

  defp build_request(model, input, params) do

    {system, turns} = Enum.split_with(input, &(&1.role == "system"))

  defp build_request(model, {messages, tool_outputs}, params) do

    {system, turns} = Enum.split_with(messages, &(&1.role == "system"))

    instructions =

      case params["instructions"] do

      model_id: model.provider_model,

      instructions: instructions,

      input: turns,

      tool_definitions: declared_tools(params["tools"]),

      tool_outputs: tool_outputs,

      max_output: max_output

    }

  end

    Process.put(:responses_seq, 0)

    Process.put(:responses_text, [])

    Process.put(:responses_usage, %{})

    Process.put(:responses_calls, [])

    # The conn rides the process dictionary too: `chunk/2` returns the conn

    # that carries what has been sent — on the test adapter, literally the

    # accumulated body — and a closure cannot rebind the outer variable.

          Process.put(:responses_usage, usage)

          :ok

        # A tool call the model asked for: one function_call item, whole,

        # because the provider hands the call assembled rather than in

        # fragments. The item's own done-events follow immediately.

        {:tool_call, call} ->

          calls = Process.get(:responses_calls)

          Process.put(:responses_calls, calls ++ [call])

          index = length(calls) + 1

          item = function_call_item(call, "completed")

          emit.("response.output_item.added", %{

            "output_index" => index,

            "item" => %{item | "status" => "in_progress"}

          })

          emit.("response.function_call_arguments.done", %{

            "item_id" => item["id"],

            "output_index" => index,

            "arguments" => item["arguments"]

          })

          emit.("response.output_item.done", %{"output_index" => index, "item" => item})

        _other ->

          :ok

      end)

    text = IO.iodata_to_binary(Process.get(:responses_text))

    usage = Process.get(:responses_usage)

    calls = Process.get(:responses_calls)

    case result do

      :ok ->

        completed =

          shell(response_id, model_name(model), "completed", [

            message(message_id, "completed", [text_part(text)])

            | Enum.map(calls, &function_call_item(&1, "completed"))

          ])

          |> Map.put("usage", usage_view(usage))

        _other -> nil

      end)

    calls =

      Enum.flat_map(events, fn

        {:tool_call, call} -> [call]

        _other -> []

      end)

    case result do

      :ok ->

        response_id = "resp_" <> identifier()

          conn,

          shell(response_id, model_name(model), "completed", [

            message(message_id, "completed", [text_part(text)])

            | Enum.map(calls, &function_call_item(&1, "completed"))

          ])

          |> Map.put("usage", usage_view(usage))

        )

    }

  end

  # One function_call output item, in the specification's shape. The

  # arguments are the raw JSON string the model produced; this surface

  # replays, never interprets.

  defp function_call_item(call, status) do

    %{

      "type" => "function_call",

      "id" => "fc_" <> identifier(),

      "call_id" => call.call_id,

      "name" => call.name,

      "arguments" => call.raw_arguments,

      "status" => status

    }

  end

  defp usage_view(usage) do

    input = whole(usage["input_tokens"])

    output = whole(usage["output_tokens"])

  alias OpenAgents.Providers.{

    FailingTestProvider,

    RecordingTestProvider,

    ToolCallingTestProvider,

    UnconfiguredTestProvider

  }

      assert body["code"] == "model_unavailable"

    end

  end

  describe "tools through the surface" do

    setup do

      swap_lane(ToolCallingTestProvider)

      :ok

    end

    @tools [

      %{

        type: "function",

        name: "read_conversation",

        description: "Read a conversation back.",

        parameters: %{type: "object", properties: %{}}

      }

    ]

    test "a declared tool comes back as a function_call output item", %{conn: conn} do

      conn = post(conn, ~p"/api/v1/responses", %{input: "read it", tools: @tools})

      assert %{"output" => [_message, call]} = json_response(conn, 200)

      assert %{

               "type" => "function_call",

               "call_id" => "call_1",

               "name" => "read_conversation",

               "arguments" => ~s({"max_turns":4}),

               "status" => "completed"

             } = call

    end

    test "streams the function_call item with its own events", %{conn: conn} do

      conn = post(conn, ~p"/api/v1/responses", %{input: "read it", tools: @tools, stream: true})

      body = response(conn, 200)

      assert body =~ "event: response.function_call_arguments.done"

      assert body =~ ~s("name":"read_conversation")

      assert body =~ ~s("output_index":1)

      assert body =~ "event: response.completed"

    end

    test "replayed calls and outputs reach the provider, and it answers from them", %{conn: conn} do

      conn =

        post(conn, ~p"/api/v1/responses", %{

          input: [

            %{role: "user", content: "read it"},

            %{

              type: "function_call",

              call_id: "call_1",

              name: "read_conversation",

              arguments: ~s({"max_turns":4})

            },

            %{type: "function_call_output", call_id: "call_1", output: "four turns of text"}

          ],

          tools: @tools

        })

      assert %{"output" => [message]} = json_response(conn, 200)

      assert %{"content" => [%{"text" => "The tool said: four turns of text"}]} = message

    end

  end

end

defmodule OpenAgents.Providers.ToolCallingTestProvider do

  @moduledoc false

  @behaviour OpenAgents.Providers.Provider

  alias OpenAgents.Providers.Request

  @impl true

  def id, do: "test.tool_calling_provider"

  @impl true

  def capabilities, do: [:text, :tools, :usage]

  @impl true

  def configured?, do: true

  # First call: ask for a tool. Second call — recognizable by the outputs the

  # caller replays — answer from them. The two-step is the whole agentic loop

  # in miniature, which is what a surface carrying tools must survive.

  @impl true

  def stream(%Request{} = request, on_event) when is_function(on_event, 1) do

    on_event.({:response_started, "tool-calling-response"})

    if request.tool_outputs == [] do

      on_event.(

        {:tool_call,

         %{call_id: "call_1", name: "read_conversation", raw_arguments: ~s({"max_turns":4})}}

      )

    else

      [output | _rest] = request.tool_outputs

      on_event.({:text_delta, "The tool said: "})

      on_event.({:text_delta, output.output["content"]})

    end

    on_event.({:usage, %{"input_tokens" => 6, "output_tokens" => 3}})

    on_event.({:response_completed, "tool-calling-response"})

    :ok

  end

end