code: def completion(
      model: str,
      messages: list,
      model_response: ModelResponse,
      print_verbose: Callable,
      encoding,
      logging_obj,
      custom_prompt_dict={},
      hf_model_name=None,
      optional_params=None,
      litellm_params=None,
      logger_fn=None,
  ):
      import boto3
  
      # pop aws_secret_access_key, aws_access_key_id, aws_region_name from kwargs, since completion calls fail with them
      aws_secret_access_key = optional_params.pop(
          "aws_secret_access_key", None
      )
      aws_access_key_id = optional_params.pop("aws_access_key_id", None)
      aws_region_name = optional_params.pop("aws_region_name", None)
  
      if aws_access_key_id != None:
          # uses auth params passed to completion
          # aws_access_key_id is not None, assume user is trying to auth using litellm.completion
          client = boto3.client(
              service_name="sagemaker-runtime",
              aws_access_key_id=aws_access_key_id,
              aws_secret_access_key=aws_secret_access_key,
              region_name=aws_region_name,
          )
      else:
          # aws_access_key_id is None, assume user is trying to auth using env variables
          # boto3 automaticaly reads env variables
  
          # we need to read region name from env
          # I assume majority of users use .env for auth
          region_name = (
              get_secret("AWS_REGION_NAME")
              or "us-west-2"  # default to us-west-2 if user not specified
          )
          client = boto3.client(
              service_name="sagemaker-runtime",
              region_name=region_name,
          )
  
      # pop streaming if it's in the optional params as 'stream' raises an error with sagemaker
      inference_params = deepcopy(optional_params)
      inference_params.pop("stream", None)
  
      ## Load Config
      config = litellm.SagemakerConfig.get_config()
      for k, v in config.items():
          if (
              k not in inference_params
          ):  # completion(top_k=3) > sagemaker_config(top_k=3) <- allows for dynamic variables to be passed in
              inference_params[k] = v
  
      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", None),
              initial_prompt_value=model_prompt_details.get(
                  "initial_prompt_value", ""
              ),
              final_prompt_value=model_prompt_details.get(
                  "final_prompt_value", ""
              ),
              messages=messages,
          )
      else:
          if hf_model_name is None:
              if "llama-2" in model.lower():  # llama-2 model
                  if (
                      "chat" in model.lower()
                  ):  # apply llama2 chat template
                      hf_model_name = "meta-llama/Llama-2-7b-chat-hf"
                  else:  # apply regular llama2 template
                      hf_model_name = "meta-llama/Llama-2-7b"
          hf_model_name = (
              hf_model_name or model
          )  # pass in hf model name for pulling it's prompt template - (e.g. `hf_model_name="meta-llama/Llama-2-7b-chat-hf` applies the llama2 chat template to the prompt)
          prompt = prompt_factory(
              model=hf_model_name, messages=messages
          )
  
      data = json.dumps(
          {"inputs": prompt, "parameters": inference_params}
      ).encode("utf-8")
  
      ## LOGGING
      request_str = f"""
      response = client.invoke_endpoint(
          EndpointName={model},
          ContentType="application/json",
          Body={data},
          CustomAttributes="accept_eula=true",
      )
      """  # type: ignore
      logging_obj.pre_call(
          input=prompt,
          api_key="",
          additional_args={
              "complete_input_dict": data,
              "request_str": request_str,
              "hf_model_name": hf_model_name,
          },
      )
      ## COMPLETION CALL
      try:
          response = client.invoke_endpoint(
              EndpointName=model,
              ContentType="application/json",
              Body=data,
              CustomAttributes="accept_eula=true",
          )
      except Exception as e:
          status_code = (
              getattr(e, "response", {})
              .get("ResponseMetadata", {})
              .get("HTTPStatusCode", 500)
          )
          error_message = (
              getattr(e, "response", {})
              .get("Error", {})
              .get("Message", str(e))
          )
          raise SagemakerError(
              status_code=status_code, message=error_message
          )
  
      response = response["Body"].read().decode("utf8")
      ## LOGGING
      logging_obj.post_call(
          input=prompt,
          api_key="",
          original_response=response,
          additional_args={"complete_input_dict": data},
      )
      print_verbose(f"raw model_response: {response}")
      ## RESPONSE OBJECT
      completion_response = json.loads(response)
      try:
          completion_response_choices = completion_response[0]
          completion_output = ""
          if "generation" in completion_response_choices:
              completion_output += completion_response_choices[
                  "generation"
              ]
          elif "generated_text" in completion_response_choices:
              completion_output += completion_response_choices[
                  "generated_text"
              ]
  
          # check if the prompt template is part of output, if so - filter it out
          if completion_output.startswith(prompt) and "<s>" in prompt:
              completion_output = completion_output.replace(
                  prompt, "", 1
              )
  
          model_response["choices"][0]["message"][
              "content"
          ] = completion_output
      except:
          raise SagemakerError(
              message=f"LiteLLM Error: Unable to parse sagemaker RAW RESPONSE {json.dumps(completion_response)}",
              status_code=500,
          )
  
      ## CALCULATING USAGE - baseten charges on time, not tokens - have some mapping of cost here.
      prompt_tokens = len(encoding.encode(prompt))
      completion_tokens = len(
          encoding.encode(
              model_response["choices"][0]["message"].get("content", "")
          )
      )
  
      model_response["created"] = int(time.time())
      model_response["model"] = model
      usage = Usage(
          prompt_tokens=prompt_tokens,
          completion_tokens=completion_tokens,
          total_tokens=prompt_tokens + completion_tokens,
      )
      model_response.usage = usage
      return model_response
  
imports: import os, types
  from enum import Enum
  import json
  import requests
  import time
  from typing import Callable, Optional, Any
  import litellm
  from litellm.utils import ModelResponse, EmbeddingResponse, get_secret, Usage
  import sys
  from copy import deepcopy
  import httpx
  from .prompt_templates.factory import prompt_factory, custom_prompt
label_desc: Use image node_id 1 for calling a global function with example usage: completion(model, messages, model_response, print_verbose, encoding, logging_obj, custom_prompt_dict, hf_model_name, optional_params, litellm_params, logger_fn) and returns: model_response