Nested Pydantic Model for `args_schema` in Tool Registration is not Recognized
Labels: name: area: agent, name: auto:bug

### System Info

### Description:
I am using the `StructuredTool` function to register a custom tool, and I've encountered a problem with nested Pydantic Models in the `args_schema` parameter.

### Problem:
When registering a function with a nested Pydantic Model in the `args_schema`, only the first outer layer of the model scheme seems to be consumed. This issue appears to lead to a failure in the llm processing.

### Example:
I'm trying to create a weather forecasting function using nested Pydantic Models:

```python
from __future__ import annotations

from typing import Any, Dict, Optional

from pydantic import BaseModel, Field


class Data(BaseModel):
    key: str = Field(..., description='API key')
    q: str = Field(..., description='Location')
    days: int = Field(..., description='Number of days to forecast')


class Model(BaseModel):
    data: Data
    json_: Optional[Dict[str, Any]] = Field(None, alias='json')
```

I registered the tool with:

```python
tool = StructuredTool.from_function(name=function_name, func=test_func, 
                 description=function_description, args_schema=Model)
```

However, when running the tool with `agent.run("how is the weather in Taipei today?")`, llm seems cannot recognize the Field inside the Data object, which then lead to the failure of the function_call.

```python
"generations": [
    [
      {
        "text": "",
        "generation_info": {
          "finish_reason": "function_call"
        },
        "message": {
          "lc": 1,
          "type": "constructor",
          "id": [
            "langchain",
            "schema",
            "messages",
            "AIMessage"
          ],
          "kwargs": {
            "content": "",
            "additional_kwargs": {
              "function_call": {
                "name": "weather_forecast",
                "arguments": "{\n  \"data\": {\n    \"location\": \"Taipei\"\n  }\n}"
              }
            }
          }
        }
      }
    ]
  ],
```

Moreover, I've tried to transform the tool into OpenAI function with `format_tool_to_openai_function(tool)`, the nested `Data` class seems to be discarded, as shown in the generated scheme

```
{'name': 'weather_forecast',
 'description': 'weather_forecast(**kwargs) - Get the weather forecast for a location.',
 'parameters': {'type': 'object',
  'properties': {'data': {'$ref': '#/definitions/Data'},
   'json': {'title': 'Json', 'type': 'object'}},
  'required': ['data', 'json']}}
```

### Expected Behavior:
The nested Pydantic Model should be recognized, and the tool should be able to process the nested `args_schema` correctly.
Besides, the 

### Additional Context:
- Documentation Reference: [StructuredTool](https://python.langchain.com/docs/modules/agents/tools/custom_tools)

#### Questions:
- Is there a way to support nested Pydantic Models in the `args_schema` parameter?
- Is this behavior intentional, or is it a bug?

### Who can help?

@hwchase17 

### Information

- [ ] The official example notebooks/scripts
- [X] My own modified scripts

### Related Components

- [ ] LLMs/Chat Models
- [ ] Embedding Models
- [ ] Prompts / Prompt Templates / Prompt Selectors
- [ ] Output Parsers
- [ ] Document Loaders
- [ ] Vector Stores / Retrievers
- [ ] Memory
- [X] Agents / Agent Executors
- [X] Tools / Toolkits
- [ ] Chains
- [ ] Callbacks/Tracing
- [ ] Async

### Reproduction

### Init Model
```python
model_str = """
from __future__ import annotations

from typing import Any, Dict, Optional

from pydantic import BaseModel, Field


class Data(BaseModel):
    key: str = Field(..., description='API key')
    q: str = Field(..., description='Location')
    days: int = Field(..., description='Number of days to forecast')


class Model(BaseModel):
    data: Data
    json_: Optional[Dict[str, Any]] = Field(None, alias='json')
"""
exec(model_str)
```

### Define function

```python
import requests
def convert_to_test_function(endpoint):

    def api_function(**kwargs):
        # Construct the URL with query parameters from the description and provided arguments
        url = endpoint
        data = kwargs.get("data")
        data = {key: kwargs["data"][key] for key in kwargs.get("data") if key in kwargs["data"]}
        json_payload = kwargs.get("json")

        print("Data:", data)
        print("JSON:", json_payload)
        return requests.post(url, data=data, json=json_payload).json()

    return api_function

weather_func_test = convert_to_test_function("https://api.weatherapi.com/v1/forecast.json")

# Test the function
weather_func_test(data={"key": KEYS_FOR_WEATHER_API, "q": "London", "days": 1})

```

### Test with tools

```python
from langchain.chat_models import ChatOpenAI
from langchain.agents import initialize_agent, AgentType
from langchain.tools import StructuredTool
llm = ChatOpenAI(temperature=0, model="gpt-3.5-turbo-16k")
weather_tool = StructuredTool.from_function(name="weather_forecast", func=weather_func_test, description="useful for weather forcasting", args_schema=Model)
agent = initialize_agent([weather_tool], llm, agent=AgentType.OPENAI_FUNCTIONS, verbose=True)
agent.run("How is the weather in Taipei for this two days? I have the key for api calling: " + KEYS_FOR_WEATHER_API)
```

#### Result

```python
> Entering new AgentExecutor chain...

Invoking: `weather_forecast` with `{'data': {'city': 'Taipei', 'days': 2, 'apiKey': KEYS_FOR_WEATHER_API}}`
```


### Expected behavior

### Expected Result 
Following the Pydantic Model, we would expect the result from llm execution could be

```
Invoking: `weather_forecast` with `{'data': {'q': 'Taipei', 'days': 2, 'key': KEYS_FOR_WEATHER_API}}`
```
, which means we could generate the request as

```
{
  "data":
  {
    "key": KEYS_FOR_WEATHER_API, 
    "q": "London",
    "days": 1
  }
}
```