Skip to content

armgit / camel

Public Imported from GitHub
0

🐫 CAMEL: The first and the best multi-agent framework. Finding the Scaling Law of Agents. https://www.camel-ai.org

9.2 KB
Raw Blame
<a id="camel.models.gemini_model"></a>

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

## GeminiModel

```python
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__"></a>

### __init__

```python
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.native_client"></a>

### native_client

```python
def native_client(self):
```

**Returns:**

  genai.Client: The native Google GenAI client.

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

### create_cache

```python
def create_cache(
    self,
    contents: List[Dict[str, Any]],
    ttl: str = '300s',
    display_name: Optional[str] = None,
    system_instruction: Optional[str] = None
):
```

Create a cache for reusing content across requests.

**Parameters:**

- **contents** (List[Dict[str, Any]]): The content to cache. Should be a list of message dicts with 'role' and 'parts' keys.
- **ttl** (str, optional): Time-to-live for the cache as an integer number of seconds followed by `__INLINE_CODE_0____INLINE_CODE_1____INLINE_CODE_2____INLINE_CODE_3____INLINE_CODE_4____INLINE_CODE_5____INLINE_CODE_6____INLINE_CODE_7__"300s"`)
- **display_name** (str, optional): A human-readable name for the cache. (default: :obj:`None`)
- **system_instruction** (str, optional): System instruction to cache. (default: :obj:`None`)

**Returns:**

  str: The cache name in format "cachedContents/\{cache_id\}".

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

### list_caches

```python
def list_caches(self):
```

**Returns:**

  List[CachedContent]: A list of cached content objects.

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

### get_cache

```python
def get_cache(self, cache_name: str):
```

Get details of a specific cache.

**Parameters:**

- **cache_name** (str): The cache name in format "cachedContents/\{id\}".

**Returns:**

  CachedContent: The cached content object.

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

### update_cache

```python
def update_cache(self, cache_name: str, ttl: str):
```

Update the TTL of an existing cache.

**Parameters:**

- **cache_name** (str): The cache name in format "cachedContents/\{id\}".
- **ttl** (str): New time-to-live for the cache.

**Returns:**

  CachedContent: The updated cached content object.

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

### delete_cache

```python
def delete_cache(self, cache_name: str):
```

Delete a cache.

**Parameters:**

- **cache_name** (str): The cache name in format "cachedContents/\{id\}".

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

### cached_content

```python
def cached_content(self):
```

**Returns:**

  Optional[str]: The cache name or None if not set.

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

### cached_content

```python
def cached_content(self, value: Optional[str]):
```

Set or clear the cached content to use for requests.

**Parameters:**

- **value** (Optional[str]): The cache name (e.g., "cachedContents/xxx") or None to clear.

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

### _sanitize_tools_for_gemini

```python
def _sanitize_tools_for_gemini(tools: List[Dict[str, Any]]):
```

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

### _prepare_request_config

```python
def _prepare_request_config(self, tools: Optional[List[Dict[str, Any]]] = None):
```

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

### _is_stale_cached_content_error

```python
def _is_stale_cached_content_error(self, err: Exception):
```

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

### _handle_stale_cache_error

```python
def _handle_stale_cache_error(self, err: Exception):
```

If *err* is a stale-cached-content error, log a warning and clear
the cache so the caller can retry.  Otherwise re-raise *err*.

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

### _process_messages

```python
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"></a>

### _preserve_thought_signatures

```python
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"></a>

### _wrap_stream_with_thought_preservation

```python
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"></a>

### _wrap_async_stream_with_thought_preservation

```python
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"></a>

### _run

```python
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"></a>

### _request_chat_completion

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

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

### _request_parse

```python
def _request_parse(
    self,
    messages: List[OpenAIMessage],
    response_format: Type[BaseModel],
    tools: Optional[List[Dict[str, Any]]] = None
):
```