letta_api

# NOTE: This file is auto generated by OpenAPI Generator 7.13.0 (https://openapi-generator.tech).
# Do not edit this file manually.

defmodule LettaAPI.Api.Tools do
  @moduledoc """
  API calls for all endpoints tagged `Tools`.
  """

  alias LettaAPI.Connection
  import LettaAPI.RequestBuilder

  @doc """
  Upsert Base Tools
  Upsert base tools

  ### Parameters

  - `connection` (LettaAPI.Connection): Connection to server
  - `opts` (keyword): Optional parameters
    - `:user_id` (String.t): 

  ### Returns

  - `{:ok, [%Tool{}, ...]}` on success
  - `{:error, Tesla.Env.t}` on failure
  """
  @spec add_base_tools(Tesla.Env.client, keyword()) :: {:ok, LettaAPI.Model.HttpValidationError.t} | {:ok, [LettaAPI.Model.Tool.t]} | {:error, Tesla.Env.t}
  def add_base_tools(connection, opts \\ []) do
    optional_params = %{
      :user_id => :headers
    }

    request =
      %{}
      |> method(:post)
      |> url("/v1/tools/add-base-tools")
      |> add_optional_params(optional_params, opts)
      |> ensure_body()
      |> Enum.into([])

    connection
    |> Connection.request(request)
    |> evaluate_response([
      {200, LettaAPI.Model.Tool},
      {422, LettaAPI.Model.HttpValidationError}
    ])
  end

  @doc """
  Add Composio Tool
  Add a new Composio tool by action name (Composio refers to each tool as an `Action`)

  ### Parameters

  - `connection` (LettaAPI.Connection): Connection to server
  - `composio_action_name` (String.t): 
  - `opts` (keyword): Optional parameters
    - `:user_id` (String.t): 

  ### Returns

  - `{:ok, LettaAPI.Model.Tool.t}` on success
  - `{:error, Tesla.Env.t}` on failure
  """
  @spec add_composio_tool(Tesla.Env.client, String.t, keyword()) :: {:ok, LettaAPI.Model.Tool.t} | {:ok, LettaAPI.Model.HttpValidationError.t} | {:error, Tesla.Env.t}
  def add_composio_tool(connection, composio_action_name, opts \\ []) do
    optional_params = %{
      :user_id => :headers
    }

    request =
      %{}
      |> method(:post)
      |> url("/v1/tools/composio/#{composio_action_name}")
      |> add_optional_params(optional_params, opts)
      |> ensure_body()
      |> Enum.into([])

    connection
    |> Connection.request(request)
    |> evaluate_response([
      {200, LettaAPI.Model.Tool},
      {422, LettaAPI.Model.HttpValidationError}
    ])
  end

  @doc """
  Add Mcp Server To Config
  Add a new MCP server to the Letta MCP server config

  ### Parameters

  - `connection` (LettaAPI.Connection): Connection to server
  - `request` (Request): 
  - `opts` (keyword): Optional parameters
    - `:user_id` (String.t): 

  ### Returns

  - `{:ok, [%ResponseListMcpServersValue{}, ...]}` on success
  - `{:error, Tesla.Env.t}` on failure
  """
  @spec add_mcp_server(Tesla.Env.client, LettaAPI.Model.Request.t, keyword()) :: {:ok, [LettaAPI.Model.ResponseListMcpServersValue.t]} | {:ok, LettaAPI.Model.HttpValidationError.t} | {:error, Tesla.Env.t}
  def add_mcp_server(connection, request, opts \\ []) do
    optional_params = %{
      :user_id => :headers
    }

    request =
      %{}
      |> method(:put)
      |> url("/v1/tools/mcp/servers")
      |> add_param(:body, :body, request)
      |> add_optional_params(optional_params, opts)
      |> Enum.into([])

    connection
    |> Connection.request(request)
    |> evaluate_response([
      {200, LettaAPI.Model.ResponseListMcpServersValue},
      {422, LettaAPI.Model.HttpValidationError}
    ])
  end

  @doc """
  Add Mcp Tool
  Register a new MCP tool as a Letta server by MCP server + tool name

  ### Parameters

  - `connection` (LettaAPI.Connection): Connection to server
  - `mcp_server_name` (String.t): 
  - `mcp_tool_name` (String.t): 
  - `opts` (keyword): Optional parameters
    - `:user_id` (String.t): 

  ### Returns

  - `{:ok, LettaAPI.Model.Tool.t}` on success
  - `{:error, Tesla.Env.t}` on failure
  """
  @spec add_mcp_tool(Tesla.Env.client, String.t, String.t, keyword()) :: {:ok, LettaAPI.Model.Tool.t} | {:ok, LettaAPI.Model.HttpValidationError.t} | {:error, Tesla.Env.t}
  def add_mcp_tool(connection, mcp_server_name, mcp_tool_name, opts \\ []) do
    optional_params = %{
      :user_id => :headers
    }

    request =
      %{}
      |> method(:post)
      |> url("/v1/tools/mcp/servers/#{mcp_server_name}/#{mcp_tool_name}")
      |> add_optional_params(optional_params, opts)
      |> ensure_body()
      |> Enum.into([])

    connection
    |> Connection.request(request)
    |> evaluate_response([
      {200, LettaAPI.Model.Tool},
      {422, LettaAPI.Model.HttpValidationError}
    ])
  end

  @doc """
  Count Tools
  Get a count of all tools available to agents belonging to the org of the user

  ### Parameters

  - `connection` (LettaAPI.Connection): Connection to server
  - `opts` (keyword): Optional parameters
    - `:user_id` (String.t): 

  ### Returns

  - `{:ok, integer()}` on success
  - `{:error, Tesla.Env.t}` on failure
  """
  @spec count_tools(Tesla.Env.client, keyword()) :: {:ok, integer()} | {:ok, LettaAPI.Model.HttpValidationError.t} | {:error, Tesla.Env.t}
  def count_tools(connection, opts \\ []) do
    optional_params = %{
      :user_id => :headers
    }

    request =
      %{}
      |> method(:get)
      |> url("/v1/tools/count")
      |> add_optional_params(optional_params, opts)
      |> Enum.into([])

    connection
    |> Connection.request(request)
    |> evaluate_response([
      {200, false},
      {422, LettaAPI.Model.HttpValidationError}
    ])
  end

  @doc """
  Create Tool
  Create a new tool

  ### Parameters

  - `connection` (LettaAPI.Connection): Connection to server
  - `tool_create` (ToolCreate): 
  - `opts` (keyword): Optional parameters
    - `:user_id` (String.t): 

  ### Returns

  - `{:ok, LettaAPI.Model.Tool.t}` on success
  - `{:error, Tesla.Env.t}` on failure
  """
  @spec create_tool(Tesla.Env.client, LettaAPI.Model.ToolCreate.t, keyword()) :: {:ok, LettaAPI.Model.Tool.t} | {:ok, LettaAPI.Model.HttpValidationError.t} | {:error, Tesla.Env.t}
  def create_tool(connection, tool_create, opts \\ []) do
    optional_params = %{
      :user_id => :headers
    }

    request =
      %{}
      |> method(:post)
      |> url("/v1/tools/")
      |> add_param(:body, :body, tool_create)
      |> add_optional_params(optional_params, opts)
      |> Enum.into([])

    connection
    |> Connection.request(request)
    |> evaluate_response([
      {200, LettaAPI.Model.Tool},
      {422, LettaAPI.Model.HttpValidationError}
    ])
  end

  @doc """
  Delete Mcp Server From Config
  Add a new MCP server to the Letta MCP server config

  ### Parameters

  - `connection` (LettaAPI.Connection): Connection to server
  - `mcp_server_name` (String.t): 
  - `opts` (keyword): Optional parameters
    - `:user_id` (String.t): 

  ### Returns

  - `{:ok, [%ResponseListMcpServersValue{}, ...]}` on success
  - `{:error, Tesla.Env.t}` on failure
  """
  @spec delete_mcp_server(Tesla.Env.client, String.t, keyword()) :: {:ok, [LettaAPI.Model.ResponseListMcpServersValue.t]} | {:ok, LettaAPI.Model.HttpValidationError.t} | {:error, Tesla.Env.t}
  def delete_mcp_server(connection, mcp_server_name, opts \\ []) do
    optional_params = %{
      :user_id => :headers
    }

    request =
      %{}
      |> method(:delete)
      |> url("/v1/tools/mcp/servers/#{mcp_server_name}")
      |> add_optional_params(optional_params, opts)
      |> Enum.into([])

    connection
    |> Connection.request(request)
    |> evaluate_response([
      {200, LettaAPI.Model.ResponseListMcpServersValue},
      {422, LettaAPI.Model.HttpValidationError}
    ])
  end

  @doc """
  Delete Tool
  Delete a tool by name

  ### Parameters

  - `connection` (LettaAPI.Connection): Connection to server
  - `tool_id` (String.t): 
  - `opts` (keyword): Optional parameters
    - `:user_id` (String.t): 

  ### Returns

  - `{:ok, any()}` on success
  - `{:error, Tesla.Env.t}` on failure
  """
  @spec delete_tool(Tesla.Env.client, String.t, keyword()) :: {:ok, any()} | {:ok, LettaAPI.Model.HttpValidationError.t} | {:error, Tesla.Env.t}
  def delete_tool(connection, tool_id, opts \\ []) do
    optional_params = %{
      :user_id => :headers
    }

    request =
      %{}
      |> method(:delete)
      |> url("/v1/tools/#{tool_id}")
      |> add_optional_params(optional_params, opts)
      |> Enum.into([])

    connection
    |> Connection.request(request)
    |> evaluate_response([
      {200, LettaAPI.Model.AnyType},
      {422, LettaAPI.Model.HttpValidationError}
    ])
  end

  @doc """
  List Composio Actions By App
  Get a list of all Composio actions for a specific app

  ### Parameters

  - `connection` (LettaAPI.Connection): Connection to server
  - `composio_app_name` (String.t): 
  - `opts` (keyword): Optional parameters
    - `:user_id` (String.t): 

  ### Returns

  - `{:ok, [%ActionModel{}, ...]}` on success
  - `{:error, Tesla.Env.t}` on failure
  """
  @spec list_composio_actions_by_app(Tesla.Env.client, String.t, keyword()) :: {:ok, LettaAPI.Model.HttpValidationError.t} | {:ok, [LettaAPI.Model.ActionModel.t]} | {:error, Tesla.Env.t}
  def list_composio_actions_by_app(connection, composio_app_name, opts \\ []) do
    optional_params = %{
      :user_id => :headers
    }

    request =
      %{}
      |> method(:get)
      |> url("/v1/tools/composio/apps/#{composio_app_name}/actions")
      |> add_optional_params(optional_params, opts)
      |> Enum.into([])

    connection
    |> Connection.request(request)
    |> evaluate_response([
      {200, LettaAPI.Model.ActionModel},
      {422, LettaAPI.Model.HttpValidationError}
    ])
  end

  @doc """
  List Composio Apps
  Get a list of all Composio apps

  ### Parameters

  - `connection` (LettaAPI.Connection): Connection to server
  - `opts` (keyword): Optional parameters
    - `:"user-id"` (String.t): 

  ### Returns

  - `{:ok, [%AppModel{}, ...]}` on success
  - `{:error, Tesla.Env.t}` on failure
  """
  @spec list_composio_apps(Tesla.Env.client, keyword()) :: {:ok, [LettaAPI.Model.AppModel.t]} | {:ok, LettaAPI.Model.HttpValidationError.t} | {:error, Tesla.Env.t}
  def list_composio_apps(connection, opts \\ []) do
    optional_params = %{
      :"user-id" => :headers
    }

    request =
      %{}
      |> method(:get)
      |> url("/v1/tools/composio/apps")
      |> add_optional_params(optional_params, opts)
      |> Enum.into([])

    connection
    |> Connection.request(request)
    |> evaluate_response([
      {200, LettaAPI.Model.AppModel},
      {422, LettaAPI.Model.HttpValidationError}
    ])
  end

  @doc """
  List Mcp Servers
  Get a list of all configured MCP servers

  ### Parameters

  - `connection` (LettaAPI.Connection): Connection to server
  - `opts` (keyword): Optional parameters
    - `:"user-id"` (String.t): 

  ### Returns

  - `{:ok, %{}}` on success
  - `{:error, Tesla.Env.t}` on failure
  """
  @spec list_mcp_servers(Tesla.Env.client, keyword()) :: {:ok, %{optional(String.t) => LettaAPI.Model.ResponseListMcpServersValue.t}} | {:ok, LettaAPI.Model.HttpValidationError.t} | {:error, Tesla.Env.t}
  def list_mcp_servers(connection, opts \\ []) do
    optional_params = %{
      :"user-id" => :headers
    }

    request =
      %{}
      |> method(:get)
      |> url("/v1/tools/mcp/servers")
      |> add_optional_params(optional_params, opts)
      |> Enum.into([])

    connection
    |> Connection.request(request)
    |> evaluate_response([
      {200, %{}},
      {422, LettaAPI.Model.HttpValidationError}
    ])
  end

  @doc """
  List Mcp Tools By Server
  Get a list of all tools for a specific MCP server

  ### Parameters

  - `connection` (LettaAPI.Connection): Connection to server
  - `mcp_server_name` (String.t): 
  - `opts` (keyword): Optional parameters
    - `:user_id` (String.t): 

  ### Returns

  - `{:ok, [%McpTool{}, ...]}` on success
  - `{:error, Tesla.Env.t}` on failure
  """
  @spec list_mcp_tools_by_server(Tesla.Env.client, String.t, keyword()) :: {:ok, LettaAPI.Model.HttpValidationError.t} | {:ok, [LettaAPI.Model.McpTool.t]} | {:error, Tesla.Env.t}
  def list_mcp_tools_by_server(connection, mcp_server_name, opts \\ []) do
    optional_params = %{
      :user_id => :headers
    }

    request =
      %{}
      |> method(:get)
      |> url("/v1/tools/mcp/servers/#{mcp_server_name}/tools")
      |> add_optional_params(optional_params, opts)
      |> Enum.into([])

    connection
    |> Connection.request(request)
    |> evaluate_response([
      {200, LettaAPI.Model.McpTool},
      {422, LettaAPI.Model.HttpValidationError}
    ])
  end

  @doc """
  List Tools
  Get a list of all tools available to agents belonging to the org of the user

  ### Parameters

  - `connection` (LettaAPI.Connection): Connection to server
  - `opts` (keyword): Optional parameters
    - `:after` (String.t): 
    - `:limit` (integer()): 
    - `:name` (String.t): 
    - `:user_id` (String.t): 

  ### Returns

  - `{:ok, [%Tool{}, ...]}` on success
  - `{:error, Tesla.Env.t}` on failure
  """
  @spec list_tools(Tesla.Env.client, keyword()) :: {:ok, LettaAPI.Model.HttpValidationError.t} | {:ok, [LettaAPI.Model.Tool.t]} | {:error, Tesla.Env.t}
  def list_tools(connection, opts \\ []) do
    optional_params = %{
      :after => :query,
      :limit => :query,
      :name => :query,
      :user_id => :headers
    }

    request =
      %{}
      |> method(:get)
      |> url("/v1/tools/")
      |> add_optional_params(optional_params, opts)
      |> Enum.into([])

    connection
    |> Connection.request(request)
    |> evaluate_response([
      {200, LettaAPI.Model.Tool},
      {422, LettaAPI.Model.HttpValidationError}
    ])
  end

  @doc """
  Modify Tool
  Update an existing tool

  ### Parameters

  - `connection` (LettaAPI.Connection): Connection to server
  - `tool_id` (String.t): 
  - `tool_update` (ToolUpdate): 
  - `opts` (keyword): Optional parameters
    - `:user_id` (String.t): 

  ### Returns

  - `{:ok, LettaAPI.Model.Tool.t}` on success
  - `{:error, Tesla.Env.t}` on failure
  """
  @spec modify_tool(Tesla.Env.client, String.t, LettaAPI.Model.ToolUpdate.t, keyword()) :: {:ok, LettaAPI.Model.Tool.t} | {:ok, LettaAPI.Model.HttpValidationError.t} | {:error, Tesla.Env.t}
  def modify_tool(connection, tool_id, tool_update, opts \\ []) do
    optional_params = %{
      :user_id => :headers
    }

    request =
      %{}
      |> method(:patch)
      |> url("/v1/tools/#{tool_id}")
      |> add_param(:body, :body, tool_update)
      |> add_optional_params(optional_params, opts)
      |> Enum.into([])

    connection
    |> Connection.request(request)
    |> evaluate_response([
      {200, LettaAPI.Model.Tool},
      {422, LettaAPI.Model.HttpValidationError}
    ])
  end

  @doc """
  Retrieve Tool
  Get a tool by ID

  ### Parameters

  - `connection` (LettaAPI.Connection): Connection to server
  - `tool_id` (String.t): 
  - `opts` (keyword): Optional parameters
    - `:user_id` (String.t): 

  ### Returns

  - `{:ok, LettaAPI.Model.Tool.t}` on success
  - `{:error, Tesla.Env.t}` on failure
  """
  @spec retrieve_tool(Tesla.Env.client, String.t, keyword()) :: {:ok, LettaAPI.Model.Tool.t} | {:ok, LettaAPI.Model.HttpValidationError.t} | {:error, Tesla.Env.t}
  def retrieve_tool(connection, tool_id, opts \\ []) do
    optional_params = %{
      :user_id => :headers
    }

    request =
      %{}
      |> method(:get)
      |> url("/v1/tools/#{tool_id}")
      |> add_optional_params(optional_params, opts)
      |> Enum.into([])

    connection
    |> Connection.request(request)
    |> evaluate_response([
      {200, LettaAPI.Model.Tool},
      {422, LettaAPI.Model.HttpValidationError}
    ])
  end

  @doc """
  Run Tool From Source
  Attempt to build a tool from source, then run it on the provided arguments

  ### Parameters

  - `connection` (LettaAPI.Connection): Connection to server
  - `tool_run_from_source` (ToolRunFromSource): 
  - `opts` (keyword): Optional parameters
    - `:user_id` (String.t): 

  ### Returns

  - `{:ok, LettaAPI.Model.ToolReturnMessage.t}` on success
  - `{:error, Tesla.Env.t}` on failure
  """
  @spec run_tool_from_source(Tesla.Env.client, LettaAPI.Model.ToolRunFromSource.t, keyword()) :: {:ok, LettaAPI.Model.ToolReturnMessage.t} | {:ok, LettaAPI.Model.HttpValidationError.t} | {:error, Tesla.Env.t}
  def run_tool_from_source(connection, tool_run_from_source, opts \\ []) do
    optional_params = %{
      :user_id => :headers
    }

    request =
      %{}
      |> method(:post)
      |> url("/v1/tools/run")
      |> add_param(:body, :body, tool_run_from_source)
      |> add_optional_params(optional_params, opts)
      |> Enum.into([])

    connection
    |> Connection.request(request)
    |> evaluate_response([
      {200, LettaAPI.Model.ToolReturnMessage},
      {422, LettaAPI.Model.HttpValidationError}
    ])
  end

  @doc """
  Upsert Tool
  Create or update a tool

  ### Parameters

  - `connection` (LettaAPI.Connection): Connection to server
  - `tool_create` (ToolCreate): 
  - `opts` (keyword): Optional parameters
    - `:user_id` (String.t): 

  ### Returns

  - `{:ok, LettaAPI.Model.Tool.t}` on success
  - `{:error, Tesla.Env.t}` on failure
  """
  @spec upsert_tool(Tesla.Env.client, LettaAPI.Model.ToolCreate.t, keyword()) :: {:ok, LettaAPI.Model.Tool.t} | {:ok, LettaAPI.Model.HttpValidationError.t} | {:error, Tesla.Env.t}
  def upsert_tool(connection, tool_create, opts \\ []) do
    optional_params = %{
      :user_id => :headers
    }

    request =
      %{}
      |> method(:put)
      |> url("/v1/tools/")
      |> add_param(:body, :body, tool_create)
      |> add_optional_params(optional_params, opts)
      |> Enum.into([])

    connection
    |> Connection.request(request)
    |> evaluate_response([
      {200, LettaAPI.Model.Tool},
      {422, LettaAPI.Model.HttpValidationError}
    ])
  end
end