langchain

defmodule LangChain.Message.ToolResult do
  @moduledoc """
  Represents a the result of running a requested tool. The LLM's requests a tool
  use through a `ToolCall`. A `ToolResult` returns the answer or result from the
  application back to the AI.
  """
  use Ecto.Schema
  import Ecto.Changeset
  require Logger
  alias __MODULE__
  alias LangChain.LangChainError

  @primary_key false
  embedded_schema do
    field :type, Ecto.Enum, values: [:function], default: :function
    # When a unique ID is given for a ToolCall, the same ID is used in the
    # return to the a response to a specific request.
    field :tool_call_id, :string
    # the name of the tool that was run.
    field :name, :string
    # the content returned to the LLM/AI.
    field :content, :string
    # Text to display in a UI for the result. Optional.
    field :display_text, :string
    # flag if the result is an error
    field :is_error, :boolean, default: false
  end

  @type t :: %ToolResult{}

  @update_fields [:type, :tool_call_id, :name, :content, :display_text, :is_error]
  @create_fields @update_fields
  @required_fields [:type, :tool_call_id, :content]

  @doc """
  Build a new ToolResult and return an `:ok`/`:error` tuple with the result.
  """
  @spec new(attrs :: map()) :: {:ok, t()} | {:error, Ecto.Changeset.t()}
  def new(attrs \\ %{}) do
    %ToolResult{}
    |> cast(attrs, @create_fields)
    |> common_validations()
    |> apply_action(:insert)
  end

  @doc """
  Build a new ToolResult and return it or raise an error if invalid.
  """
  @spec new!(attrs :: map()) :: t() | no_return()
  def new!(attrs \\ %{}) do
    case new(attrs) do
      {:ok, message} ->
        message

      {:error, changeset} ->
        raise LangChainError, changeset
    end
  end

  defp common_validations(changeset) do
    validate_required(changeset, @required_fields)
  end
end