> ## Documentation Index
> Fetch the complete documentation index at: https://docs.camel-ai.org/llms.txt
> Use this file to discover all available pages before exploring further.

# Camel.models.gemini model

<a id="camel.models.gemini_model" />

<a id="camel.models.gemini_model.GeminiModel" />

## GeminiModel

```python theme={"system"}
class GeminiModel(OpenAICompatibleModel):
```

Gemini API in a unified OpenAICompatibleModel interface.

**Parameters:**

* **model\_type** (Union\[ModelType, str]): Model for which a backend is created, one of Gemini series.
* **model\_config\_dict** (Optional\[Dict\[str, Any]], optional): A dictionary that will be fed into:obj:`openai.ChatCompletion.create()`. If :obj:`None`, :obj:`GeminiConfig().as_dict()` will be used. (default: :obj:`None`)
* **api\_key** (Optional\[str], optional): The API key for authenticating with the Gemini service. (default: :obj:`None`)
* **url** (Optional\[str], optional): The url to the Gemini service. (default: :obj:`https://generativelanguage.googleapis.com/v1beta/ openai/`)
* **token\_counter** (Optional\[BaseTokenCounter], optional): Token counter to use for the model. If not provided, :obj:`OpenAITokenCounter( ModelType.GPT_4O_MINI)` will be used. (default: :obj:`None`)
* **timeout** (Optional\[float], optional): The timeout value in seconds for API calls. If not provided, will fall back to the MODEL\_TIMEOUT environment variable or default to 180 seconds. (default: :obj:`None`)
* **max\_retries** (int, optional): Maximum number of retries for API calls. (default: :obj:`3`) \*\*kwargs (Any): Additional arguments to pass to the client initialization.

<a id="camel.models.gemini_model.GeminiModel.__init__" />

### **init**

```python theme={"system"}
def __init__(
    self,
    model_type: Union[ModelType, str],
    model_config_dict: Optional[Dict[str, Any]] = None,
    api_key: Optional[str] = None,
    url: Optional[str] = None,
    token_counter: Optional[BaseTokenCounter] = None,
    timeout: Optional[float] = None,
    max_retries: int = 3,
    **kwargs: Any
):
```

<a id="camel.models.gemini_model.GeminiModel._process_messages" />

### \_process\_messages

```python theme={"system"}
def _process_messages(self, messages):
```

Process the messages for Gemini API to ensure no empty content,
which is not accepted by Gemini. Also preserves thought signatures
required for Gemini 3 Pro function calling.

This method also merges consecutive assistant messages with single
tool calls into a single assistant message with multiple tool calls,
as required by Gemini's OpenAI-compatible API for parallel function
calling.

<a id="camel.models.gemini_model.GeminiModel._preserve_thought_signatures" />

### \_preserve\_thought\_signatures

```python theme={"system"}
def _preserve_thought_signatures(
    self,
    response: Union[ChatCompletion, Stream[ChatCompletionChunk], AsyncStream[ChatCompletionChunk]]
):
```

Preserve thought signatures from Gemini responses for future
requests.

According to the Gemini documentation, when a response contains tool
calls with thought signatures, these signatures must be preserved
exactly as received when the response is added to conversation history
for subsequent requests.

**Parameters:**

* **response**: The response from Gemini API

**Returns:**

The response with thought signatures properly preserved.
For streaming responses, returns generators that preserve
signatures.

<a id="camel.models.gemini_model.GeminiModel._wrap_stream_with_thought_preservation" />

### \_wrap\_stream\_with\_thought\_preservation

```python theme={"system"}
def _wrap_stream_with_thought_preservation(self, stream: Stream[ChatCompletionChunk]):
```

Wrap a streaming response to preserve thought signatures in tool
calls.

This method ensures that when Gemini streaming responses contain tool
calls with thought signatures, these are properly preserved in the
extra\_content field for future conversation context.

**Parameters:**

* **stream**: The original streaming response from Gemini

**Returns:**

A wrapped stream that preserves thought signatures

<a id="camel.models.gemini_model.GeminiModel._wrap_async_stream_with_thought_preservation" />

### \_wrap\_async\_stream\_with\_thought\_preservation

```python theme={"system"}
def _wrap_async_stream_with_thought_preservation(self, stream: AsyncStream[ChatCompletionChunk]):
```

Wrap an async streaming response to preserve thought signatures in
tool calls.

This method ensures that when Gemini async streaming responses contain
tool calls with thought signatures, these are properly preserved in
the extra\_content field for future conversation context.

**Parameters:**

* **stream**: The original async streaming response from Gemini

**Returns:**

A wrapped async stream that preserves thought signatures

<a id="camel.models.gemini_model.GeminiModel._run" />

### \_run

```python theme={"system"}
def _run(
    self,
    messages: List[OpenAIMessage],
    response_format: Optional[Type[BaseModel]] = None,
    tools: Optional[List[Dict[str, Any]]] = None
):
```

Runs inference of Gemini chat completion.

**Parameters:**

* **messages** (List\[OpenAIMessage]): Message list with the chat history in OpenAI API format.
* **response\_format** (Optional\[Type\[BaseModel]]): The format of the response.
* **tools** (Optional\[List\[Dict\[str, Any]]]): The schema of the tools to use for the request.

**Returns:**

Union\[ChatCompletion, Stream\[ChatCompletionChunk]]:
`ChatCompletion` in the non-stream mode, or
`Stream[ChatCompletionChunk]` in the stream mode.

<a id="camel.models.gemini_model.GeminiModel._request_chat_completion" />

### \_request\_chat\_completion

```python theme={"system"}
def _request_chat_completion(
    self,
    messages: List[OpenAIMessage],
    tools: Optional[List[Dict[str, Any]]] = None
):
```