create_structured_output_chain does not work with with AzureChatOpenAI model?
Labels: name: auto:bug, name: area: models

### System Info

Python 3.11.4
langchain-0.0.276
currently troubleshooting on a Windows 11 workstation in a notebook in VSCode. 

### Who can help?

@hwchase17 @ag

### Information

- [ ] The official example notebooks/scripts
- [X] My own modified scripts

### Related Components

- [X] LLMs/Chat Models
- [ ] Embedding Models
- [X] Prompts / Prompt Templates / Prompt Selectors
- [ ] Output Parsers
- [ ] Document Loaders
- [ ] Vector Stores / Retrievers
- [ ] Memory
- [ ] Agents / Agent Executors
- [ ] Tools / Toolkits
- [X] Chains
- [ ] Callbacks/Tracing
- [ ] Async

### Reproduction

I'm trying to use a structured output chain with some defined Pydantic classes. The chain works when using ChatOpenAI model but not AzureChatOpenAI. I'm able to generate non-chained chat completions with AzureChatOpenAI, so I'm pretty confident the issue isn't with my configuration of the AzureChatOpenAI model. 

Representative code:
```
# ChatOpenAI using native OpenAI endpoint
openai_model = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)

# AzureChatOpenAI using private endpoint through Azure OpenAI Service
azure_model = AzureChatOpenAI(
    openai_api_base="[hiding my api base]",
    openai_api_version="2023-07-01-preview",
    deployment_name="[hiding my model deployment name]",
    model_name = "[hiding my model name]",
    openai_api_key="[hiding my API key]",
    openai_api_type="azure",
    temperature = 1
)

# define representative singleton class 
class GeneratedItem(BaseModel):
    """Information about a generated item."""

    item_nickname: str = Field(..., description="A creative nickname for an item that might be found in some room")
    item_purpose: str = Field(..., description="The purpose of the item")

# define the plural class as a Sequence of the above singletons
class GeneratedItems(BaseModel):
    """information about all items generated"""

    items: Sequence[GeneratedItem] = Field(..., description="A sequence of items")

# define messages for a prompt
prompt_msgs = [
    SystemMessage(
        content="You are a world class algorithm for generating information in structured formats."
    ),
    HumanMessage(
        content="Use the given format to generate 2 items that might be in a room described as follows"
    ),
    HumanMessagePromptTemplate.from_template("{input}"),
    HumanMessage(content="Tips: Make sure to answer in the correct format"),
]

# define the prompt using ChatPromptTemplate
prompt = ChatPromptTemplate(messages=prompt_msgs)

# define and execute structured output chain with ChatOpenAI model
chain1 = create_structured_output_chain(GeneratedItems, openai_model, prompt, verbose=False)
chain1.run("A living room with green chairs and a wooden coffee table")

# define and execute structued output chain with AzureChatOpenAI model
chain2 = create_structured_output_chain(GeneratedItems, azure_model, prompt, verbose=False)
chain2.run("A living room with green chairs and a wooden coffee table")
```

### Expected behavior

In the above code, the `chain1.run()` using ChatOpenAI executes successfully returning something like the below:
{'items': [{'item_nickname': 'green chairs', 'item_purpose': 'seating'},
  {'item_nickname': 'wooden coffee table', 'item_purpose': 'surface'}]}
  
However, when executing `chain2.run()` which uses AzureChatOpenAI, this behavior is not replicated. Instead, I receive the below errors (including full traceback to help troubleshoot)
```
KeyError                                  Traceback (most recent call last)
Cell In[23], line 55
     50 # chain1 = create_structured_output_chain(GeneratedItems, openai_model, prompt, verbose=False)
     51 # chain1.run("A living room with green chairs and a wooden coffee table")
     54 chain2 = create_structured_output_chain(GeneratedItems, azure_model, prompt, verbose=False)
---> 55 chain2.run("A living room with green chairs and a wooden coffee table")

File  ...\.venv\Lib\site-packages\langchain\chains\base.py:441, in Chain.run(self, callbacks, tags, metadata, *args, **kwargs)
    439     if len(args) != 1:
    440         raise ValueError("`run` supports only one positional argument.")
--> 441     return self(args[0], callbacks=callbacks, tags=tags, metadata=metadata)[
    442         _output_key
    443     ]
    445 if kwargs and not args:
    446     return self(kwargs, callbacks=callbacks, tags=tags, metadata=metadata)[
    447         _output_key
    448     ]

File  ...\.venv\Lib\site-packages\langchain\chains\base.py:244, in Chain.__call__(self, inputs, return_only_outputs, callbacks, tags, metadata, include_run_info)
    242 except (KeyboardInterrupt, Exception) as e:
    243     run_manager.on_chain_error(e)
--> 244     raise e
    245 run_manager.on_chain_end(outputs)
    246 final_outputs: Dict[str, Any] = self.prep_outputs(
...
--> 103     content = _dict["content"] or ""  # OpenAI returns None for tool invocations
    104     if _dict.get("function_call"):
    105         additional_kwargs = {"function_call": dict(_dict["function_call"])}

KeyError: 'content'
```

Ideally this would return structured output for AzureChatOpenAI model in exactly the same manner as it does when using a ChatOpenAI model. Maybe I missed something in the docs, but thinking this is a source-side issue with AzureChatOpenAI not containing/creating the `content` key in the `_dict` dictionary.

Please let me know if there are any workarounds or solutions I should attempt and/or some documentation I may not have found.