[proxy users] Possible regression after upgrading to 0.0.194: InvalidRequestError: Unrecognized request argument supplied: proxy

### System Info

Mac M1 
I've just upgraded to Langchain 0.0.194
I need to pass through a proxy, so I set HTTP_PROXY, HTTPS_PROXY, OPENAI_PROXY and REQUEST_BUNDLE_CA= for the https certificate. 




```
InvalidRequestError: Unrecognized request argument supplied: proxy
```

### Who can help?

_No response_

### Information

- [ ] The official example notebooks/scripts
- [X] My own modified scripts

### Related Components

- [X] LLMs/Chat Models
- [X] Embedding Models
- [ ] Prompts / Prompt Templates / Prompt Selectors
- [ ] Output Parsers
- [ ] Document Loaders
- [ ] Vector Stores / Retrievers
- [ ] Memory
- [ ] Agents / Agent Executors
- [ ] Tools / Toolkits
- [ ] Chains
- [ ] Callbacks/Tracing
- [ ] Async

### Reproduction

Roughly this is the code to reproduce the issue: 


```python
llm = PromptLayerChatOpenAI(model_name="gpt-3.5-turbo",
                            temperature=0,
                            return_pl_id=True,
                            pl_tags=["question-answering", "chatgpt"])

chain = load_qa_chain(llm, chain_type="stuff")

query_main_magnet = "Extract the starting magnets or main materials being studied in the text. Include all the compositions mentioned."
relevant_documents = db.as_retriever().get_relevant_documents(query)
chain.run(input_documents=relevant_documents, question=query)
```


and the issue 

```
---------------------------------------------------------------------------
InvalidRequestError                       Traceback (most recent call last)
Cell In[40], line 10
      8 query_main_magnet = "Extract the starting magnets or main materials being studied in the text. Include all the compositions mentioned."
      9 relevant_documents = embeddings_dict['Lit_120_To'].as_retriever().get_relevant_documents(query_main_magnet)
---> 10 chain.run(input_documents=relevant_documents, question=query_main_magnet)

File ~/anaconda3/envs/magneto/lib/python3.9/site-packages/langchain/chains/base.py:259, in Chain.run(self, callbacks, *args, **kwargs)
    256     return self(args[0], callbacks=callbacks)[self.output_keys[0]]
    258 if kwargs and not args:
--> 259     return self(kwargs, callbacks=callbacks)[self.output_keys[0]]
    261 if not kwargs and not args:
    262     raise ValueError(
    263         "`run` supported with either positional arguments or keyword arguments,"
    264         " but none were provided."
    265     )

File ~/anaconda3/envs/magneto/lib/python3.9/site-packages/langchain/chains/base.py:145, in Chain.__call__(self, inputs, return_only_outputs, callbacks, include_run_info)
    143 except (KeyboardInterrupt, Exception) as e:
    144     run_manager.on_chain_error(e)
--> 145     raise e
    146 run_manager.on_chain_end(outputs)
    147 final_outputs: Dict[str, Any] = self.prep_outputs(
    148     inputs, outputs, return_only_outputs
    149 )

File ~/anaconda3/envs/magneto/lib/python3.9/site-packages/langchain/chains/base.py:139, in Chain.__call__(self, inputs, return_only_outputs, callbacks, include_run_info)
    133 run_manager = callback_manager.on_chain_start(
    134     {"name": self.__class__.__name__},
    135     inputs,
    136 )
    137 try:
    138     outputs = (
--> 139         self._call(inputs, run_manager=run_manager)
    140         if new_arg_supported
    141         else self._call(inputs)
    142     )
    143 except (KeyboardInterrupt, Exception) as e:
    144     run_manager.on_chain_error(e)

File ~/anaconda3/envs/magneto/lib/python3.9/site-packages/langchain/chains/combine_documents/base.py:84, in BaseCombineDocumentsChain._call(self, inputs, run_manager)
     82 # Other keys are assumed to be needed for LLM prediction
     83 other_keys = {k: v for k, v in inputs.items() if k != self.input_key}
---> 84 output, extra_return_dict = self.combine_docs(
     85     docs, callbacks=_run_manager.get_child(), **other_keys
     86 )
     87 extra_return_dict[self.output_key] = output
     88 return extra_return_dict

File ~/anaconda3/envs/magneto/lib/python3.9/site-packages/langchain/chains/combine_documents/stuff.py:87, in StuffDocumentsChain.combine_docs(self, docs, callbacks, **kwargs)
     85 inputs = self._get_inputs(docs, **kwargs)
     86 # Call predict on the LLM.
---> 87 return self.llm_chain.predict(callbacks=callbacks, **inputs), {}

File ~/anaconda3/envs/magneto/lib/python3.9/site-packages/langchain/chains/llm.py:213, in LLMChain.predict(self, callbacks, **kwargs)
    198 def predict(self, callbacks: Callbacks = None, **kwargs: Any) -> str:
    199     """Format prompt with kwargs and pass to LLM.
    200 
    201     Args:
   (...)
    211             completion = llm.predict(adjective="funny")
    212     """
--> 213     return self(kwargs, callbacks=callbacks)[self.output_key]

File ~/anaconda3/envs/magneto/lib/python3.9/site-packages/langchain/chains/base.py:145, in Chain.__call__(self, inputs, return_only_outputs, callbacks, include_run_info)
    143 except (KeyboardInterrupt, Exception) as e:
    144     run_manager.on_chain_error(e)
--> 145     raise e
    146 run_manager.on_chain_end(outputs)
    147 final_outputs: Dict[str, Any] = self.prep_outputs(
    148     inputs, outputs, return_only_outputs
    149 )

File ~/anaconda3/envs/magneto/lib/python3.9/site-packages/langchain/chains/base.py:139, in Chain.__call__(self, inputs, return_only_outputs, callbacks, include_run_info)
    133 run_manager = callback_manager.on_chain_start(
    134     {"name": self.__class__.__name__},
    135     inputs,
    136 )
    137 try:
    138     outputs = (
--> 139         self._call(inputs, run_manager=run_manager)
    140         if new_arg_supported
    141         else self._call(inputs)
    142     )
    143 except (KeyboardInterrupt, Exception) as e:
    144     run_manager.on_chain_error(e)

File ~/anaconda3/envs/magneto/lib/python3.9/site-packages/langchain/chains/llm.py:69, in LLMChain._call(self, inputs, run_manager)
     64 def _call(
     65     self,
     66     inputs: Dict[str, Any],
     67     run_manager: Optional[CallbackManagerForChainRun] = None,
     68 ) -> Dict[str, str]:
---> 69     response = self.generate([inputs], run_manager=run_manager)
     70     return self.create_outputs(response)[0]

File ~/anaconda3/envs/magneto/lib/python3.9/site-packages/langchain/chains/llm.py:79, in LLMChain.generate(self, input_list, run_manager)
     77 """Generate LLM result from inputs."""
     78 prompts, stop = self.prep_prompts(input_list, run_manager=run_manager)
---> 79 return self.llm.generate_prompt(
     80     prompts, stop, callbacks=run_manager.get_child() if run_manager else None
     81 )

File ~/anaconda3/envs/magneto/lib/python3.9/site-packages/langchain/chat_models/base.py:148, in BaseChatModel.generate_prompt(self, prompts, stop, callbacks)
    141 def generate_prompt(
    142     self,
    143     prompts: List[PromptValue],
    144     stop: Optional[List[str]] = None,
    145     callbacks: Callbacks = None,
    146 ) -> LLMResult:
    147     prompt_messages = [p.to_messages() for p in prompts]
--> 148     return self.generate(prompt_messages, stop=stop, callbacks=callbacks)

File ~/anaconda3/envs/magneto/lib/python3.9/site-packages/langchain/chat_models/base.py:92, in BaseChatModel.generate(self, messages, stop, callbacks)
     90 except (KeyboardInterrupt, Exception) as e:
     91     run_manager.on_llm_error(e)
---> 92     raise e
     93 llm_output = self._combine_llm_outputs([res.llm_output for res in results])
     94 generations = [res.generations for res in results]

File ~/anaconda3/envs/magneto/lib/python3.9/site-packages/langchain/chat_models/base.py:84, in BaseChatModel.generate(self, messages, stop, callbacks)
     80 new_arg_supported = inspect.signature(self._generate).parameters.get(
     81     "run_manager"
     82 )
     83 try:
---> 84     results = [
     85         self._generate(m, stop=stop, run_manager=run_manager)
     86         if new_arg_supported
     87         else self._generate(m, stop=stop)
     88         for m in messages
     89     ]
     90 except (KeyboardInterrupt, Exception) as e:
     91     run_manager.on_llm_error(e)

File ~/anaconda3/envs/magneto/lib/python3.9/site-packages/langchain/chat_models/base.py:85, in <listcomp>(.0)
     80 new_arg_supported = inspect.signature(self._generate).parameters.get(
     81     "run_manager"
     82 )
     83 try:
     84     results = [
---> 85         self._generate(m, stop=stop, run_manager=run_manager)
     86         if new_arg_supported
     87         else self._generate(m, stop=stop)
     88         for m in messages
     89     ]
     90 except (KeyboardInterrupt, Exception) as e:
     91     run_manager.on_llm_error(e)

File ~/anaconda3/envs/magneto/lib/python3.9/site-packages/langchain/chat_models/promptlayer_openai.py:50, in PromptLayerChatOpenAI._generate(self, messages, stop, run_manager)
     47 from promptlayer.utils import get_api_key, promptlayer_api_request
     49 request_start_time = datetime.datetime.now().timestamp()
---> 50 generated_responses = super()._generate(messages, stop, run_manager)
     51 request_end_time = datetime.datetime.now().timestamp()
     52 message_dicts, params = super()._create_message_dicts(messages, stop)

File ~/anaconda3/envs/magneto/lib/python3.9/site-packages/langchain/chat_models/openai.py:323, in ChatOpenAI._generate(self, messages, stop, run_manager)
    319     message = _convert_dict_to_message(
    320         {"content": inner_completion, "role": role}
    321     )
    322     return ChatResult(generations=[ChatGeneration(message=message)])
--> 323 response = self.completion_with_retry(messages=message_dicts, **params)
    324 return self._create_chat_result(response)

File ~/anaconda3/envs/magneto/lib/python3.9/site-packages/langchain/chat_models/openai.py:284, in ChatOpenAI.completion_with_retry(self, **kwargs)
    280 @retry_decorator
    281 def _completion_with_retry(**kwargs: Any) -> Any:
    282     return self.client.create(**kwargs)
--> 284 return _completion_with_retry(**kwargs)

File ~/anaconda3/envs/magneto/lib/python3.9/site-packages/tenacity/__init__.py:289, in BaseRetrying.wraps.<locals>.wrapped_f(*args, **kw)
    287 @functools.wraps(f)
    288 def wrapped_f(*args: t.Any, **kw: t.Any) -> t.Any:
--> 289     return self(f, *args, **kw)

File ~/anaconda3/envs/magneto/lib/python3.9/site-packages/tenacity/__init__.py:379, in Retrying.__call__(self, fn, *args, **kwargs)
    377 retry_state = RetryCallState(retry_object=self, fn=fn, args=args, kwargs=kwargs)
    378 while True:
--> 379     do = self.iter(retry_state=retry_state)
    380     if isinstance(do, DoAttempt):
    381         try:

File ~/anaconda3/envs/magneto/lib/python3.9/site-packages/tenacity/__init__.py:314, in BaseRetrying.iter(self, retry_state)
    312 is_explicit_retry = fut.failed and isinstance(fut.exception(), TryAgain)
    313 if not (is_explicit_retry or self.retry(retry_state)):
--> 314     return fut.result()
    316 if self.after is not None:
    317     self.after(retry_state)

File ~/anaconda3/envs/magneto/lib/python3.9/concurrent/futures/_base.py:439, in Future.result(self, timeout)
    437     raise CancelledError()
    438 elif self._state == FINISHED:
--> 439     return self.__get_result()
    441 self._condition.wait(timeout)
    443 if self._state in [CANCELLED, CANCELLED_AND_NOTIFIED]:

File ~/anaconda3/envs/magneto/lib/python3.9/concurrent/futures/_base.py:391, in Future.__get_result(self)
    389 if self._exception:
    390     try:
--> 391         raise self._exception
    392     finally:
    393         # Break a reference cycle with the exception in self._exception
    394         self = None

File ~/anaconda3/envs/magneto/lib/python3.9/site-packages/tenacity/__init__.py:382, in Retrying.__call__(self, fn, *args, **kwargs)
    380 if isinstance(do, DoAttempt):
    381     try:
--> 382         result = fn(*args, **kwargs)
    383     except BaseException:  # noqa: B902
    384         retry_state.set_exception(sys.exc_info())  # type: ignore[arg-type]

File ~/anaconda3/envs/magneto/lib/python3.9/site-packages/langchain/chat_models/openai.py:282, in ChatOpenAI.completion_with_retry.<locals>._completion_with_retry(**kwargs)
    280 @retry_decorator
    281 def _completion_with_retry(**kwargs: Any) -> Any:
--> 282     return self.client.create(**kwargs)

File ~/anaconda3/envs/magneto/lib/python3.9/site-packages/openai/api_resources/chat_completion.py:25, in ChatCompletion.create(cls, *args, **kwargs)
     23 while True:
     24     try:
---> 25         return super().create(*args, **kwargs)
     26     except TryAgain as e:
     27         if timeout is not None and time.time() > start + timeout:

File ~/anaconda3/envs/magneto/lib/python3.9/site-packages/openai/api_resources/abstract/engine_api_resource.py:153, in EngineAPIResource.create(cls, api_key, api_base, api_type, request_id, api_version, organization, **params)
    127 @classmethod
    128 def create(
    129     cls,
   (...)
    136     **params,
    137 ):
    138     (
    139         deployment_id,
    140         engine,
   (...)
    150         api_key, api_base, api_type, api_version, organization, **params
    151     )
--> 153     response, _, api_key = requestor.request(
    154         "post",
    155         url,
    156         params=params,
    157         headers=headers,
    158         stream=stream,
    159         request_id=request_id,
    160         request_timeout=request_timeout,
    161     )
    163     if stream:
    164         # must be an iterator
    165         assert not isinstance(response, OpenAIResponse)

File ~/anaconda3/envs/magneto/lib/python3.9/site-packages/openai/api_requestor.py:230, in APIRequestor.request(self, method, url, params, headers, files, stream, request_id, request_timeout)
    209 def request(
    210     self,
    211     method,
   (...)
    218     request_timeout: Optional[Union[float, Tuple[float, float]]] = None,
    219 ) -> Tuple[Union[OpenAIResponse, Iterator[OpenAIResponse]], bool, str]:
    220     result = self.request_raw(
    221         method.lower(),
    222         url,
   (...)
    228         request_timeout=request_timeout,
    229     )
--> 230     resp, got_stream = self._interpret_response(result, stream)
    231     return resp, got_stream, self.api_key

File ~/anaconda3/envs/magneto/lib/python3.9/site-packages/openai/api_requestor.py:624, in APIRequestor._interpret_response(self, result, stream)
    616     return (
    617         self._interpret_response_line(
    618             line, result.status_code, result.headers, stream=True
    619         )
    620         for line in parse_stream(result.iter_lines())
    621     ), True
    622 else:
    623     return (
--> 624         self._interpret_response_line(
    625             result.content.decode("utf-8"),
    626             result.status_code,
    627             result.headers,
    628             stream=False,
    629         ),
    630         False,
    631     )

File ~/anaconda3/envs/magneto/lib/python3.9/site-packages/openai/api_requestor.py:687, in APIRequestor._interpret_response_line(self, rbody, rcode, rheaders, stream)
    685 stream_error = stream and "error" in resp.data
    686 if stream_error or not 200 <= rcode < 300:
--> 687     raise self.handle_error_response(
    688         rbody, rcode, resp.data, rheaders, stream_error=stream_error
    689     )
    690 return resp

InvalidRequestError: Unrecognized request argument supplied: proxy
```

### Expected behavior

That it work