code: def completion(
      model: str,
      messages: list,
      api_base: str,
      model_response: ModelResponse,
      print_verbose: Callable,
      encoding,
      api_key,
      logging_obj,
      custom_prompt_dict={},
      optional_params=None,
      litellm_params=None,
      logger_fn=None,
  ):
      headers = validate_environment(api_key)
  
      ## Load Config
      config = litellm.CloudflareConfig.get_config()
      for k, v in config.items():
          if k not in optional_params:
              optional_params[k] = v
  
      print_verbose(
          f"CUSTOM PROMPT DICT: {custom_prompt_dict}; model: {model}"
      )
      if model in custom_prompt_dict:
          # check if the model has a registered custom prompt
          model_prompt_details = custom_prompt_dict[model]
          prompt = custom_prompt(
              role_dict=model_prompt_details.get("roles", {}),
              initial_prompt_value=model_prompt_details.get(
                  "initial_prompt_value", ""
              ),
              final_prompt_value=model_prompt_details.get(
                  "final_prompt_value", ""
              ),
              bos_token=model_prompt_details.get("bos_token", ""),
              eos_token=model_prompt_details.get("eos_token", ""),
              messages=messages,
          )
  
      # cloudflare adds the model to the api base
      api_base = api_base + model
  
      data = {
          "messages": messages,
          **optional_params,
      }
  
      ## LOGGING
      logging_obj.pre_call(
          input=messages,
          api_key=api_key,
          additional_args={
              "headers": headers,
              "api_base": api_base,
              "complete_input_dict": data,
          },
      )
  
      ## COMPLETION CALL
      if (
          "stream" in optional_params
          and optional_params["stream"] == True
      ):
          response = requests.post(
              api_base,
              headers=headers,
              data=json.dumps(data),
              stream=optional_params["stream"],
          )
          return response.iter_lines()
      else:
          response = requests.post(
              api_base, headers=headers, data=json.dumps(data)
          )
          ## LOGGING
          logging_obj.post_call(
              input=messages,
              api_key=api_key,
              original_response=response.text,
              additional_args={"complete_input_dict": data},
          )
          print_verbose(f"raw model_response: {response.text}")
          ## RESPONSE OBJECT
          if response.status_code != 200:
              raise CloudflareError(
                  status_code=response.status_code,
                  message=response.text,
              )
          completion_response = response.json()
  
          model_response["choices"][0]["message"][
              "content"
          ] = completion_response["result"]["response"]
  
          ## CALCULATING USAGE
          print_verbose(
              f"CALCULATING CLOUDFLARE TOKEN USAGE. Model Response: {model_response}; model_response['choices'][0]['message'].get('content', ''): {model_response['choices'][0]['message'].get('content', None)}"
          )
          prompt_tokens = litellm.utils.get_token_count(
              messages=messages, model=model
          )
          completion_tokens = len(
              encoding.encode(
                  model_response["choices"][0]["message"].get(
                      "content", ""
                  )
              )
          )
  
          model_response["created"] = int(time.time())
          model_response["model"] = "cloudflare/" + model
          usage = Usage(
              prompt_tokens=prompt_tokens,
              completion_tokens=completion_tokens,
              total_tokens=prompt_tokens + completion_tokens,
          )
          model_response.usage = usage
          return model_response
  
file_path: litellm/litellm/llms/cloudflare.py
imports: import os, types
  import json
  from enum import Enum
  import requests
  import time
  from typing import Callable, Optional
  import litellm
  import httpx
  from litellm.utils import ModelResponse, Usage
  from .prompt_templates.factory import prompt_factory, custom_prompt
label_desc: Use image node_id 2 for calling a global function with example usage: completion(model, messages, api_base, model_response, print_verbose, encoding, api_key, logging_obj, custom_prompt_dict, optional_params, litellm_params, logger_fn) and returns: response, model_response