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

Support for Streaming Responses in ChatAgent (#2559)

Tao Sun6e628a2f423b
diff --git a/.github/ISSUE_TEMPLATE/bug_report.yml b/.github/ISSUE_TEMPLATE/bug_report.yml
index d83233523..15d6fa876 100644
--- a/.github/ISSUE_TEMPLATE/bug_report.yml
+++ b/.github/ISSUE_TEMPLATE/bug_report.yml
@@ -26,7 +26,7 @@ body:
attributes:
label: What version of camel are you using?
description: Run command `python3 -c 'print(__import__("camel").__version__)'` in your shell and paste the output here.
- placeholder: E.g., 0.2.71a4
+ placeholder: E.g., 0.2.71a5
validations:
required: true
diff --git a/camel/__init__.py b/camel/__init__.py
index 70432d265..5cf2a765e 100644
--- a/camel/__init__.py
+++ b/camel/__init__.py
@@ -14,7 +14,7 @@
from camel.logger import disable_logging, enable_logging, set_log_level
-__version__ = '0.2.71a4'
+__version__ = '0.2.71a5'
__all__ = [
'__version__',
diff --git a/camel/agents/chat_agent.py b/camel/agents/chat_agent.py
index 9d879ae56..171b1f7c3 100644
--- a/camel/agents/chat_agent.py
+++ b/camel/agents/chat_agent.py
@@ -16,23 +16,26 @@ from __future__ import annotations
import asyncio
import json
import logging
+import queue
import textwrap
import threading
import time
import uuid
-from collections import defaultdict
from pathlib import Path
from typing import (
TYPE_CHECKING,
Any,
+ AsyncGenerator,
Callable,
Dict,
+ Generator,
List,
Optional,
Set,
Tuple,
Type,
Union,
+ cast,
)
from openai import (
@@ -130,6 +133,189 @@ SIMPLE_FORMAT_PROMPT = TextPrompt(
)
+class StreamContentAccumulator:
+ r"""Manages content accumulation across streaming responses to ensure
+ all responses contain complete cumulative content."""
+
+ def __init__(self):
+ self.base_content = "" # Content before tool calls
+ self.current_content = "" # Current streaming content
+ self.tool_status_messages = [] # Accumulated tool status messages
+
+ def set_base_content(self, content: str):
+ r"""Set the base content (usually empty or pre-tool content)."""
+ self.base_content = content
+
+ def add_streaming_content(self, new_content: str):
+ r"""Add new streaming content."""
+ self.current_content += new_content
+
+ def add_tool_status(self, status_message: str):
+ r"""Add a tool status message."""
+ self.tool_status_messages.append(status_message)
+
+ def get_full_content(self) -> str:
+ r"""Get the complete accumulated content."""
+ tool_messages = "".join(self.tool_status_messages)
+ return self.base_content + tool_messages + self.current_content
+
+ def get_content_with_new_status(self, status_message: str) -> str:
+ r"""Get content with a new status message appended."""
+ tool_messages = "".join([*self.tool_status_messages, status_message])
+ return self.base_content + tool_messages + self.current_content
+
+ def reset_streaming_content(self):
+ r"""Reset only the streaming content, keep base and tool status."""
+ self.current_content = ""
+
+
+class StreamingChatAgentResponse:
+ r"""A wrapper that makes streaming responses compatible with
+ non-streaming code.
+
+ This class wraps a Generator[ChatAgentResponse, None, None] and provides
+ the same interface as ChatAgentResponse, so existing code doesn't need to
+ change.
+ """
+
+ def __init__(self, generator: Generator[ChatAgentResponse, None, None]):
+ self._generator = generator
+ self._current_response: Optional[ChatAgentResponse] = None
+ self._responses: List[ChatAgentResponse] = []
+ self._consumed = False
+
+ def _ensure_latest_response(self):
+ r"""Ensure we have the latest response by consuming the generator."""
+ if not self._consumed:
+ try:
+ for response in self._generator:
+ self._responses.append(response)
+ self._current_response = response
+ self._consumed = True
+ except StopIteration:
+ self._consumed = True
+
+ @property
+ def msgs(self) -> List[BaseMessage]:
+ r"""Get messages from the latest response."""
+ self._ensure_latest_response()
+ if self._current_response:
+ return self._current_response.msgs
+ return []
+
+ @property
+ def terminated(self) -> bool:
+ r"""Get terminated status from the latest response."""
+ self._ensure_latest_response()
+ if self._current_response:
+ return self._current_response.terminated
+ return False
+
+ @property
+ def info(self) -> Dict[str, Any]:
+ r"""Get info from the latest response."""
+ self._ensure_latest_response()
+ if self._current_response:
+ return self._current_response.info
+ return {}
+
+ @property
+ def msg(self):
+ r"""Get the single message if there's exactly one message."""
+ self._ensure_latest_response()
+ if self._current_response:
+ return self._current_response.msg
+ return None
+
+ def __iter__(self):
+ r"""Make this object iterable."""
+ if self._consumed:
+ # If already consumed, iterate over stored responses
+ return iter(self._responses)
+ else:
+ # If not consumed, consume and yield
+ try:
+ for response in self._generator:
+ self._responses.append(response)
+ self._current_response = response
+ yield response
+ self._consumed = True
+ except StopIteration:
+ self._consumed = True
+
+ def __getattr__(self, name):
+ r"""Forward any other attribute access to the latest response."""
+ self._ensure_latest_response()
+ if self._current_response and hasattr(self._current_response, name):
+ return getattr(self._current_response, name)
+ raise AttributeError(
+ f"'StreamingChatAgentResponse' object has no attribute '{name}'"
+ )
+
+
+class AsyncStreamingChatAgentResponse:
+ r"""A wrapper that makes async streaming responses awaitable and
+ compatible with non-streaming code.
+
+ This class wraps an AsyncGenerator[ChatAgentResponse, None] and provides
+ both awaitable and async iterable interfaces.
+ """
+
+ def __init__(
+ self, async_generator: AsyncGenerator[ChatAgentResponse, None]
+ ):
+ self._async_generator = async_generator
+ self._current_response: Optional[ChatAgentResponse] = None
+ self._responses: List[ChatAgentResponse] = []
+ self._consumed = False
+
+ async def _ensure_latest_response(self):
+ r"""Ensure the latest response by consuming the async generator."""
+ if not self._consumed:
+ try:
+ async for response in self._async_generator:
+ self._responses.append(response)
+ self._current_response = response
+ self._consumed = True
+ except StopAsyncIteration:
+ self._consumed = True
+
+ async def _get_final_response(self) -> ChatAgentResponse:
+ r"""Get the final response after consuming the entire stream."""
+ await self._ensure_latest_response()
+ if self._current_response:
+ return self._current_response
+ # Return a default response if nothing was consumed
+ return ChatAgentResponse(msgs=[], terminated=False, info={})
+
+ def __await__(self):
+ r"""Make this object awaitable - returns the final response."""
+ return self._get_final_response().__await__()
+
+ def __aiter__(self):
+ r"""Make this object async iterable."""
+ if self._consumed:
+ # If already consumed, create async iterator from stored responses
+ async def _async_iter():
+ for response in self._responses:
+ yield response
+
+ return _async_iter()
+ else:
+ # If not consumed, consume and yield
+ async def _consume_and_yield():
+ try:
+ async for response in self._async_generator:
+ self._responses.append(response)
+ self._current_response = response
+ yield response
+ self._consumed = True
+ except StopAsyncIteration:
+ self._consumed = True
+
+ return _consume_and_yield()
+
+
@track_agent(name="ChatAgent")
class ChatAgent(BaseAgent):
r"""Class for managing conversations of CAMEL Chat Agents.
@@ -182,6 +368,8 @@ class ChatAgent(BaseAgent):
stop_event (Optional[threading.Event], optional): Event to signal
termination of the agent's operation. When set, the agent will
terminate its execution. (default: :obj:`None`)
+ tool_execution_timeout (Optional[float], optional): Timeout
+ for individual tool execution. If None, wait indefinitely.
mask_tool_output (Optional[bool]): Whether to return a sanitized
placeholder instead of the raw tool output. (default: :obj:`False`)
pause_event (Optional[asyncio.Event]): Event to signal pause of the
@@ -220,6 +408,7 @@ class ChatAgent(BaseAgent):
max_iteration: Optional[int] = None,
agent_id: Optional[str] = None,
stop_event: Optional[threading.Event] = None,
+ tool_execution_timeout: Optional[float] = None,
mask_tool_output: bool = False,
pause_event: Optional[asyncio.Event] = None,
) -> None:
@@ -296,6 +485,7 @@ class ChatAgent(BaseAgent):
self.response_terminators = response_terminators or []
self.max_iteration = max_iteration
self.stop_event = stop_event
+ self.tool_execution_timeout = tool_execution_timeout
self.mask_tool_output = mask_tool_output
self._secure_result_store: Dict[str, Any] = {}
self._pending_images: List[str] = []
@@ -1112,7 +1302,7 @@ class ChatAgent(BaseAgent):
self,
input_message: Union[BaseMessage, str],
response_format: Optional[Type[BaseModel]] = None,
- ) -> ChatAgentResponse:
+ ) -> Union[ChatAgentResponse, StreamingChatAgentResponse]:
r"""Executes a single step in the chat session, generating a response
to the input message.
@@ -1126,10 +1316,20 @@ class ChatAgent(BaseAgent):
:obj:`None`)
Returns:
- ChatAgentResponse: Contains output messages, a termination status
- flag, and session information.
+ Union[ChatAgentResponse, StreamingChatAgentResponse]: If stream is
+ False, returns a ChatAgentResponse. If stream is True, returns
+ a StreamingChatAgentResponse that behaves like
+ ChatAgentResponse but can also be iterated for
+ streaming updates.
"""
+ stream = self.model_backend.model_config_dict.get("stream", False)
+
+ if stream:
+ # Return wrapped generator that has ChatAgentResponse interface
+ generator = self._stream(input_message, response_format)
+ return StreamingChatAgentResponse(generator)
+
# Set Langfuse session_id using agent_id for trace grouping
try:
from camel.utils.langfuse import set_current_agent_session_id
@@ -1276,7 +1476,7 @@ class ChatAgent(BaseAgent):
self,
input_message: Union[BaseMessage, str],
response_format: Optional[Type[BaseModel]] = None,
- ) -> ChatAgentResponse:
+ ) -> Union[ChatAgentResponse, AsyncStreamingChatAgentResponse]:
r"""Performs a single step in the chat session by generating a response
to the input message. This agent step can call async function calls.
@@ -1292,12 +1492,38 @@ class ChatAgent(BaseAgent):
used to generate a structured response by LLM. This schema
helps in defining the expected output format. (default:
:obj:`None`)
-
Returns:
- ChatAgentResponse: A struct containing the output messages,
- a boolean indicating whether the chat session has terminated,
- and information about the chat session.
+ Union[ChatAgentResponse, AsyncStreamingChatAgentResponse]:
+ If stream is False, returns a ChatAgentResponse. If stream is
+ True, returns an AsyncStreamingChatAgentResponse that can be
+ awaited for the final result or async iterated for streaming
+ updates.
"""
+
+ try:
+ from camel.utils.langfuse import set_current_agent_session_id
+
+ set_current_agent_session_id(self.agent_id)
+ except ImportError:
+ pass # Langfuse not available
+
+ stream = self.model_backend.model_config_dict.get("stream", False)
+ if stream:
+ # Return wrapped async generator that is awaitable
+ async_generator = self._astream(input_message, response_format)
+ return AsyncStreamingChatAgentResponse(async_generator)
+ else:
+ return await self._astep_non_streaming_task(
+ input_message, response_format
+ )
+
+ async def _astep_non_streaming_task(
+ self,
+ input_message: Union[BaseMessage, str],
+ response_format: Optional[Type[BaseModel]] = None,
+ ) -> ChatAgentResponse:
+ r"""Internal async method for non-streaming astep logic."""
+
try:
from camel.utils.langfuse import set_current_agent_session_id
@@ -1736,11 +1962,12 @@ class ChatAgent(BaseAgent):
f"index {self.model_backend.current_model_index}, "
f"processed these messages: {sanitized_messages}"
)
-
- if isinstance(response, ChatCompletion):
- return self._handle_batch_response(response)
- else:
- return self._handle_stream_response(response, num_tokens)
+ if not isinstance(response, ChatCompletion):
+ raise TypeError(
+ f"Expected response to be a `ChatCompletion` object, but "
+ f"got {type(response).__name__} instead."
+ )
+ return self._handle_batch_response(response)
async def _aget_model_response(
self,
@@ -1804,11 +2031,12 @@ class ChatAgent(BaseAgent):
f"index {self.model_backend.current_model_index}, "
f"processed these messages: {sanitized_messages}"
)
-
- if isinstance(response, ChatCompletion):
- return self._handle_batch_response(response)
- else:
- return await self._ahandle_stream_response(response, num_tokens)
+ if not isinstance(response, ChatCompletion):
+ raise TypeError(
+ f"Expected response to be a `ChatCompletion` object, but "
+ f"got {type(response).__name__} instead."
+ )
+ return self._handle_batch_response(response)
def _sanitize_messages_for_logging(self, messages):
r"""Sanitize OpenAI messages for logging by replacing base64 image
@@ -2070,116 +2298,6 @@ class ChatAgent(BaseAgent):
response_id=response.id or "",
)
- def _handle_stream_response(
- self,
- response: Stream[ChatCompletionChunk],
- prompt_tokens: int,
- ) -> ModelResponse:
- r"""Process a stream response from the model and extract the necessary
- information.
-
- Args:
- response (dict): Model response.
- prompt_tokens (int): Number of input prompt tokens.
-
- Returns:
- _ModelResponse: a parsed model response.
- """
- content_dict: defaultdict = defaultdict(lambda: "")
- finish_reasons_dict: defaultdict = defaultdict(lambda: "")
- output_messages: List[BaseMessage] = []
- response_id: str = ""
- # All choices in one response share one role
- for chunk in response:
- # Some model platforms like siliconflow may return None for the
- # chunk.id
- response_id = chunk.id if chunk.id else str(uuid.uuid4())
- self._handle_chunk(
- chunk, content_dict, finish_reasons_dict, output_messages
- )
- finish_reasons = [
- finish_reasons_dict[i] for i in range(len(finish_reasons_dict))
- ]
- usage_dict = self.get_usage_dict(output_messages, prompt_tokens)
-
- # TODO: Handle tool calls
- return ModelResponse(
- response=response,
- tool_call_requests=None,
- output_messages=output_messages,
- finish_reasons=finish_reasons,
- usage_dict=usage_dict,
- response_id=response_id,
- )
-
- async def _ahandle_stream_response(
- self,
- response: AsyncStream[ChatCompletionChunk],
- prompt_tokens: int,
- ) -> ModelResponse:
- r"""Process a stream response from the model and extract the necessary
- information.
-
- Args:
- response (dict): Model response.
- prompt_tokens (int): Number of input prompt tokens.
-
- Returns:
- _ModelResponse: a parsed model response.
- """
- content_dict: defaultdict = defaultdict(lambda: "")
- finish_reasons_dict: defaultdict = defaultdict(lambda: "")
- output_messages: List[BaseMessage] = []
- response_id: str = ""
- # All choices in one response share one role
- async for chunk in response:
- # Some model platforms like siliconflow may return None for the
- # chunk.id
- response_id = chunk.id if chunk.id else str(uuid.uuid4())
- self._handle_chunk(
- chunk, content_dict, finish_reasons_dict, output_messages
- )
- finish_reasons = [
- finish_reasons_dict[i] for i in range(len(finish_reasons_dict))
- ]
- usage_dict = self.get_usage_dict(output_messages, prompt_tokens)
-
- # TODO: Handle tool calls
- return ModelResponse(
- response=response,
- tool_call_requests=None,
- output_messages=output_messages,
- finish_reasons=finish_reasons,
- usage_dict=usage_dict,
- response_id=response_id,
- )
-
- def _handle_chunk(
- self,
- chunk: ChatCompletionChunk,
- content_dict: defaultdict,
- finish_reasons_dict: defaultdict,
- output_messages: List[BaseMessage],
- ) -> None:
- r"""Handle a chunk of the model response."""
- for choice in chunk.choices:
- index = choice.index
- delta = choice.delta
- if delta.content is not None:
- content_dict[index] += delta.content
-
- if not choice.finish_reason:
- continue
-
- finish_reasons_dict[index] = choice.finish_reason
- chat_message = BaseMessage(
- role_name=self.role_name,
- role_type=self.role_type,
- meta_dict=dict(),
- content=content_dict[index],
- )
- output_messages.append(chat_message)
-
def _step_terminate(
self,
num_tokens: int,
@@ -2314,7 +2432,7 @@ class ChatAgent(BaseAgent):
except Exception as e:
# Capture the error message to prevent framework crash
error_msg = f"Error executing async tool '{func_name}': {e!s}"
- result = {"error": error_msg}
+ result = f"Tool execution failed: {error_msg}"
logging.warning(error_msg)
# Check if result is a ToolResult with images
@@ -2411,6 +2529,1230 @@ class ChatAgent(BaseAgent):
return tool_record
+ def _stream(
+ self,
+ input_message: Union[BaseMessage, str],
+ response_format: Optional[Type[BaseModel]] = None,
+ ) -> Generator[ChatAgentResponse, None, None]:
+ r"""Executes a streaming step in the chat session, yielding
+ intermediate responses as they are generated.
+
+ Args:
+ input_message (Union[BaseMessage, str]): The input message for the
+ agent.
+ response_format (Optional[Type[BaseModel]], optional): A Pydantic
+ model defining the expected structure of the response.
+
+ Yields:
+ ChatAgentResponse: Intermediate responses containing partial
+ content, tool calls, and other information as they become
+ available.
+ """
+ # Convert input message to BaseMessage if necessary
+ if isinstance(input_message, str):
+ input_message = BaseMessage.make_user_message(
+ role_name="User", content=input_message
+ )
+
+ # Add user input to memory
+ self.update_memory(input_message, OpenAIBackendRole.USER)
+
+ # Get context for streaming
+ try:
+ openai_messages, num_tokens = self.memory.get_context()
+ except RuntimeError as e:
+ yield self._step_terminate(e.args[1], [], "max_tokens_exceeded")
+ return
+
+ # Start streaming response
+ yield from self._stream_response(
+ openai_messages, num_tokens, response_format
+ )
+
+ def _get_token_count(self, content: str) -> int:
+ r"""Get token count for content with fallback."""
+ if hasattr(self.model_backend, 'token_counter'):
+ return len(self.model_backend.token_counter.encode(content))
+ else:
+ return len(content.split())
+
+ def _stream_response(
+ self,
+ openai_messages: List[OpenAIMessage],
+ num_tokens: int,
+ response_format: Optional[Type[BaseModel]] = None,
+ ) -> Generator[ChatAgentResponse, None, None]:
+ r"""Internal method to handle streaming responses with tool calls."""
+
+ tool_call_records: List[ToolCallingRecord] = []
+ accumulated_tool_calls: Dict[str, Any] = {}
+ step_token_usage = self._create_token_usage_tracker()
+
+ # Create content accumulator for proper content management
+ content_accumulator = StreamContentAccumulator()
+ iteration_count = 0
+ while True:
+ # Check termination condition
+ if self.stop_event and self.stop_event.is_set():
+ yield self._step_terminate(
+ num_tokens, tool_call_records, "termination_triggered"
+ )
+ return
+
+ # Get streaming response from model
+ try:
+ response = self.model_backend.run(
+ openai_messages,
+ response_format,
+ self._get_full_tool_schemas() or None,
+ )
+ iteration_count += 1
+ except Exception as exc:
+ logger.error(
+ f"Error in streaming model response: {exc}", exc_info=exc
+ )
+ yield self._create_error_response(str(exc), tool_call_records)
+ return
+
+ # Handle streaming response
+ if isinstance(response, Stream):
+ (
+ stream_completed,
+ tool_calls_complete,
+ ) = yield from self._process_stream_chunks_with_accumulator(
+ response,
+ content_accumulator,
+ accumulated_tool_calls,
+ tool_call_records,
+ step_token_usage,
+ response_format,
+ )
+
+ if tool_calls_complete:
+ # Clear completed tool calls
+ accumulated_tool_calls.clear()
+
+ # If we executed tools and not in
+ # single iteration mode, continue
+ if tool_call_records and (
+ self.max_iteration is None
+ or iteration_count < self.max_iteration
+ ):
+ # Update messages with tool results for next iteration
+ try:
+ openai_messages, num_tokens = (
+ self.memory.get_context()
+ )
+ except RuntimeError as e:
+ yield self._step_terminate(
+ e.args[1],
+ tool_call_records,
+ "max_tokens_exceeded",
+ )
+ return
+ # Reset streaming content for next iteration
+ content_accumulator.reset_streaming_content()
+ continue
+ else:
+ break
+ else:
+ # Stream completed without tool calls
+ accumulated_tool_calls.clear()
+ break
+ elif hasattr(response, '__enter__') and hasattr(
+ response, '__exit__'
+ ):
+ # Handle structured output stream (ChatCompletionStreamManager)
+ with response as stream:
+ parsed_object = None
+
+ for event in stream:
+ if event.type == "content.delta":
+ if getattr(event, "delta", None):
+ # Use accumulator for proper content management
+ partial_response = self._create_streaming_response_with_accumulator( # noqa: E501
+ content_accumulator,
+ getattr(event, "delta", ""),
+ step_token_usage,
+ tool_call_records=tool_call_records.copy(),
+ )
+ yield partial_response
+
+ elif event.type == "content.done":
+ parsed_object = getattr(event, "parsed", None)
+ break
+ elif event.type == "error":
+ logger.error(
+ f"Error in structured stream: "
+ f"{getattr(event, 'error', '')}"
+ )
+ yield self._create_error_response(
+ str(getattr(event, 'error', '')),
+ tool_call_records,
+ )
+ return
+
+ # Get final completion and record final message
+ try:
+ final_completion = stream.get_final_completion()
+ final_content = (
+ final_completion.choices[0].message.content or ""
+ )
+
+ final_message = BaseMessage(
+ role_name=self.role_name,
+ role_type=self.role_type,
+ meta_dict={},
+ content=final_content,
+ parsed=cast(
+ "BaseModel | dict[str, Any] | None",
+ parsed_object,
+ ), # type: ignore[arg-type]
+ )
+
+ self.record_message(final_message)
+
+ # Create final response
+ final_response = ChatAgentResponse(
+ msgs=[final_message],
+ terminated=False,
+ info={
+ "id": final_completion.id or "",
+ "usage": safe_model_dump(
+ final_completion.usage
+ )
+ if final_completion.usage
+ else {},
+ "finish_reasons": [
+ choice.finish_reason or "stop"
+ for choice in final_completion.choices
+ ],
+ "num_tokens": self._get_token_count(
+ final_content
+ ),
+ "tool_calls": tool_call_records,
+ "external_tool_requests": None,
+ "streaming": False,
+ "partial": False,
+ },
+ )
+ yield final_response
+ break
+
+ except Exception as e:
+ logger.error(f"Error getting final completion: {e}")
+ yield self._create_error_response(
+ str(e), tool_call_records
+ )
+ return
+ else:
+ # Handle non-streaming response (fallback)
+ model_response = self._handle_batch_response(response)
+ yield self._convert_to_chatagent_response(
+ model_response,
+ tool_call_records,
+ num_tokens,
+ None,
+ model_response.usage_dict.get("prompt_tokens", 0),
+ model_response.usage_dict.get("completion_tokens", 0),
+ model_response.usage_dict.get("total_tokens", 0),
+ )
+ accumulated_tool_calls.clear()
+ break
+
+ def _process_stream_chunks_with_accumulator(
+ self,
+ stream: Stream[ChatCompletionChunk],
+ content_accumulator: StreamContentAccumulator,
+ accumulated_tool_calls: Dict[str, Any],
+ tool_call_records: List[ToolCallingRecord],
+ step_token_usage: Dict[str, int],
+ response_format: Optional[Type[BaseModel]] = None,
+ ) -> Generator[ChatAgentResponse, None, Tuple[bool, bool]]:
+ r"""Process streaming chunks with content accumulator."""
+
+ tool_calls_complete = False
+ stream_completed = False
+
+ for chunk in stream:
+ # Update token usage if available
+ if chunk.usage:
+ self._update_token_usage_tracker(
+ step_token_usage, safe_model_dump(chunk.usage)
+ )
+
+ # Process chunk delta
+ if chunk.choices and len(chunk.choices) > 0:
+ choice = chunk.choices[0]
+ delta = choice.delta
+
+ # Handle content streaming
+ if delta.content:
+ # Use accumulator for proper content management
+ partial_response = (
+ self._create_streaming_response_with_accumulator(
+ content_accumulator,
+ delta.content,
+ step_token_usage,
+ getattr(chunk, 'id', ''),
+ tool_call_records.copy(),
+ )
+ )
+ yield partial_response
+
+ # Handle tool calls streaming
+ if delta.tool_calls:
+ tool_calls_complete = self._accumulate_tool_calls(
+ delta.tool_calls, accumulated_tool_calls
+ )
+
+ # Check if stream is complete
+ if choice.finish_reason:
+ stream_completed = True
+
+ # If we have complete tool calls, execute them with
+ # sync status updates
+ if accumulated_tool_calls:
+ # Record assistant message with tool calls first
+ self._record_assistant_tool_calls_message(
+ accumulated_tool_calls,
+ content_accumulator.get_full_content(),
+ )
+
+ # Execute tools synchronously with
+ # optimized status updates
+ for (
+ status_response
+ ) in self._execute_tools_sync_with_status_accumulator(
+ accumulated_tool_calls,
+ content_accumulator,
+ step_token_usage,
+ tool_call_records,
+ ):
+ yield status_response
+
+ # Yield "Sending back result to model" status
+ if tool_call_records:
+ sending_status = self._create_tool_status_response_with_accumulator( # noqa: E501
+ content_accumulator,
+ "\n------\n\nSending back result to model\n\n",
+ "tool_sending",
+ step_token_usage,
+ )
+ yield sending_status
+
+ # Record final message only if we have content AND no tool
+ # calls. If there are tool calls, _record_tool_calling
+ # will handle message recording.
+ final_content = content_accumulator.get_full_content()
+ if final_content.strip() and not accumulated_tool_calls:
+ final_message = BaseMessage(
+ role_name=self.role_name,
+ role_type=self.role_type,
+ meta_dict={},
+ content=final_content,
+ )
+
+ if response_format:
+ self._try_format_message(
+ final_message, response_format
+ )
+
+ self.record_message(final_message)
+ break
+
+ return stream_completed, tool_calls_complete
+
+ def _accumulate_tool_calls(
+ self,
+ tool_call_deltas: List[Any],
+ accumulated_tool_calls: Dict[str, Any],
+ ) -> bool:
+ r"""Accumulate tool call chunks and return True when
+ any tool call is complete.
+
+ Args:
+ tool_call_deltas (List[Any]): List of tool call deltas.
+ accumulated_tool_calls (Dict[str, Any]): Dictionary of accumulated
+ tool calls.
+
+ Returns:
+ bool: True if any tool call is complete, False otherwise.
+ """
+
+ for delta_tool_call in tool_call_deltas:
+ index = delta_tool_call.index
+ tool_call_id = getattr(delta_tool_call, 'id', None)
+
+ # Initialize tool call entry if not exists
+ if index not in accumulated_tool_calls:
+ accumulated_tool_calls[index] = {
+ 'id': '',
+ 'type': 'function',
+ 'function': {'name': '', 'arguments': ''},
+ 'complete': False,
+ }
+
+ tool_call_entry = accumulated_tool_calls[index]
+
+ # Accumulate tool call data
+ if tool_call_id:
+ tool_call_entry['id'] = (
+ tool_call_id # Set full ID, don't append
+ )
+
+ if (
+ hasattr(delta_tool_call, 'function')
+ and delta_tool_call.function
+ ):
+ if delta_tool_call.function.name:
+ tool_call_entry['function']['name'] += (
+ delta_tool_call.function.name
+ ) # Append incremental name
+ if delta_tool_call.function.arguments:
+ tool_call_entry['function']['arguments'] += (
+ delta_tool_call.function.arguments
+ )
+
+ # Check if any tool calls are complete
+ any_complete = False
+ for _index, tool_call_entry in accumulated_tool_calls.items():
+ if (
+ tool_call_entry['id']
+ and tool_call_entry['function']['name']
+ and tool_call_entry['function']['arguments']
+ and tool_call_entry['function']['name'] in self._internal_tools
+ ):
+ try:
+ # Try to parse arguments to check completeness
+ json.loads(tool_call_entry['function']['arguments'])
+ tool_call_entry['complete'] = True
+ any_complete = True
+ except json.JSONDecodeError:
+ # Arguments not complete yet
+ tool_call_entry['complete'] = False
+
+ return any_complete
+
+ def _execute_tools_sync_with_status_accumulator(
+ self,
+ accumulated_tool_calls: Dict[str, Any],
+ content_accumulator: StreamContentAccumulator,
+ step_token_usage: Dict[str, int],
+ tool_call_records: List[ToolCallingRecord],
+ ) -> Generator[ChatAgentResponse, None, None]:
+ r"""Execute multiple tools synchronously with
+ proper content accumulation, using threads+queue for
+ non-blocking status streaming."""
+
+ def tool_worker(tool_func, args, result_queue, tool_call_data):
+ try:
+ tool_call_record = self._execute_tool_from_stream_data(
+ tool_call_data
+ )
+ result_queue.put(tool_call_record)
+ except Exception as e:
+ logger.error(f"Error in threaded tool execution: {e}")
+ result_queue.put(None)
+
+ tool_calls_to_execute = []
+ for _tool_call_index, tool_call_data in accumulated_tool_calls.items():
+ if tool_call_data.get('complete', False):
+ tool_calls_to_execute.append(tool_call_data)
+
+ # Phase 2: Execute tools in threads and yield status while waiting
+ for tool_call_data in tool_calls_to_execute:
+ function_name = tool_call_data['function']['name']
+ try:
+ args = json.loads(tool_call_data['function']['arguments'])
+ except json.JSONDecodeError:
+ args = tool_call_data['function']['arguments']
+ result_queue: queue.Queue[Optional[ToolCallingRecord]] = (
+ queue.Queue()
+ )
+ thread = threading.Thread(
+ target=tool_worker,
+ args=(
+ self._internal_tools[function_name],
+ args,
+ result_queue,
+ tool_call_data,
+ ),
+ )
+ thread.start()
+
+ status_message = (
+ f"\nCalling function: {function_name} "
+ f"with arguments:\n{args}\n"
+ )
+ status_status = self._create_tool_status_response_with_accumulator(
+ content_accumulator,
+ status_message,
+ "tool_calling",
+ step_token_usage,
+ )
+ yield status_status
+ # wait for tool thread to finish with optional timeout
+ thread.join(self.tool_execution_timeout)
+
+ # If timeout occurred, mark as error and continue
+ if thread.is_alive():
+ timeout_msg = (
+ f"\nFunction '{function_name}' timed out after "
+ f"{self.tool_execution_timeout} seconds.\n---------\n"
+ )
+ timeout_status = (
+ self._create_tool_status_response_with_accumulator(
+ content_accumulator,
+ timeout_msg,
+ "tool_timeout",
+ step_token_usage,
+ )
+ )
+ yield timeout_status
+ logger.error(timeout_msg.strip())
+ # Detach thread (it may still finish later). Skip recording.
+ continue
+
+ # Tool finished, get result
+ tool_call_record = result_queue.get()
+ if tool_call_record:
+ tool_call_records.append(tool_call_record)
+ raw_result = tool_call_record.result
+ result_str = str(raw_result)
+ status_message = (
+ f"\nFunction output: {result_str}\n---------\n"
+ )
+ output_status = (
+ self._create_tool_status_response_with_accumulator(
+ content_accumulator,
+ status_message,
+ "tool_output",
+ step_token_usage,
+ [tool_call_record],
+ )
+ )
+ yield output_status
+ else:
+ # Error already logged
+ continue
+
+ def _execute_tool_from_stream_data(
+ self, tool_call_data: Dict[str, Any]
+ ) -> Optional[ToolCallingRecord]:
+ r"""Execute a tool from accumulated stream data."""
+
+ try:
+ function_name = tool_call_data['function']['name']
+ args = json.loads(tool_call_data['function']['arguments'])
+ tool_call_id = tool_call_data['id']
+
+ if function_name in self._internal_tools:
+ tool = self._internal_tools[function_name]
+ try:
+ result = tool(**args)
+
+ # Only record the tool response message, not the assistant
+ # message assistant message with tool_calls was already
+ # recorded in _record_assistant_tool_calls_message
+ func_msg = FunctionCallingMessage(
+ role_name=self.role_name,
+ role_type=self.role_type,
+ meta_dict=None,
+ content="",
+ func_name=function_name,
+ result=result,
+ tool_call_id=tool_call_id,
+ )
+
+ self.update_memory(func_msg, OpenAIBackendRole.FUNCTION)
+
+ return ToolCallingRecord(
+ tool_name=function_name,
+ args=args,
+ result=result,
+ tool_call_id=tool_call_id,
+ )
+
+ except Exception as e:
+ error_msg = (
+ f"Error executing tool '{function_name}': {e!s}"
+ )
+ result = {"error": error_msg}
+ logging.warning(error_msg)
+
+ # Record error response
+ func_msg = FunctionCallingMessage(
+ role_name=self.role_name,
+ role_type=self.role_type,
+ meta_dict=None,
+ content="",
+ func_name=function_name,
+ result=result,
+ tool_call_id=tool_call_id,
+ )
+
+ self.update_memory(func_msg, OpenAIBackendRole.FUNCTION)
+
+ return ToolCallingRecord(
+ tool_name=function_name,
+ args=args,
+ result=result,
+ tool_call_id=tool_call_id,
+ )
+ else:
+ logger.warning(
+ f"Tool '{function_name}' not found in internal tools"
+ )
+ return None
+
+ except Exception as e:
+ logger.error(f"Error processing tool call: {e}")
+ return None
+
+ async def _aexecute_tool_from_stream_data(
+ self, tool_call_data: Dict[str, Any]
+ ) -> Optional[ToolCallingRecord]:
+ r"""Async execute a tool from accumulated stream data."""
+
+ try:
+ function_name = tool_call_data['function']['name']
+ args = json.loads(tool_call_data['function']['arguments'])
+ tool_call_id = tool_call_data['id']
+
+ if function_name in self._internal_tools:
+ tool = self._internal_tools[function_name]
+ try:
+ result = await tool.async_call(**args)
+
+ # Only record the tool response message, not the assistant
+ # message assistant message with tool_calls was already
+ # recorded in _record_assistant_tool_calls_message
+ func_msg = FunctionCallingMessage(
+ role_name=self.role_name,
+ role_type=self.role_type,
+ meta_dict=None,
+ content="",
+ func_name=function_name,
+ result=result,
+ tool_call_id=tool_call_id,
+ )
+
+ self.update_memory(func_msg, OpenAIBackendRole.FUNCTION)
+
+ return ToolCallingRecord(
+ tool_name=function_name,
+ args=args,
+ result=result,
+ tool_call_id=tool_call_id,
+ )
+
+ except Exception as e:
+ error_msg = (
+ f"Error executing async tool '{function_name}': {e!s}"
+ )
+ result = {"error": error_msg}
+ logging.warning(error_msg)
+
+ # Record error response
+ func_msg = FunctionCallingMessage(
+ role_name=self.role_name,
+ role_type=self.role_type,
+ meta_dict=None,
+ content="",
+ func_name=function_name,
+ result=result,
+ tool_call_id=tool_call_id,
+ )
+
+ self.update_memory(func_msg, OpenAIBackendRole.FUNCTION)
+
+ return ToolCallingRecord(
+ tool_name=function_name,
+ args=args,
+ result=result,
+ tool_call_id=tool_call_id,
+ )
+ else:
+ logger.warning(
+ f"Tool '{function_name}' not found in internal tools"
+ )
+ return None
+
+ except Exception as e:
+ logger.error(f"Error processing async tool call: {e}")
+ return None
+
+ def _create_error_response(
+ self, error_message: str, tool_call_records: List[ToolCallingRecord]
+ ) -> ChatAgentResponse:
+ r"""Create an error response for streaming."""
+
+ error_msg = BaseMessage(
+ role_name=self.role_name,
+ role_type=self.role_type,
+ meta_dict={},
+ content=f"Error: {error_message}",
+ )
+
+ return ChatAgentResponse(
+ msgs=[error_msg],
+ terminated=True,
+ info={
+ "error": error_message,
+ "tool_calls": tool_call_records,
+ "streaming": True,
+ },
+ )
+
+ async def _astream(
+ self,
+ input_message: Union[BaseMessage, str],
+ response_format: Optional[Type[BaseModel]] = None,
+ ) -> AsyncGenerator[ChatAgentResponse, None]:
+ r"""Asynchronous version of stream method."""
+
+ # Convert input message to BaseMessage if necessary
+ if isinstance(input_message, str):
+ input_message = BaseMessage.make_user_message(
+ role_name="User", content=input_message
+ )
+
+ # Add user input to memory
+ self.update_memory(input_message, OpenAIBackendRole.USER)
+
+ # Get context for streaming
+ try:
+ openai_messages, num_tokens = self.memory.get_context()
+ except RuntimeError as e:
+ yield self._step_terminate(e.args[1], [], "max_tokens_exceeded")
+ return
+
+ # Start async streaming response
+ async for response in self._astream_response(
+ openai_messages, num_tokens, response_format
+ ):
+ yield response
+
+ async def _astream_response(
+ self,
+ openai_messages: List[OpenAIMessage],
+ num_tokens: int,
+ response_format: Optional[Type[BaseModel]] = None,
+ ) -> AsyncGenerator[ChatAgentResponse, None]:
+ r"""Async method to handle streaming responses with tool calls."""
+
+ tool_call_records: List[ToolCallingRecord] = []
+ accumulated_tool_calls: Dict[str, Any] = {}
+ step_token_usage = self._create_token_usage_tracker()
+
+ # Create content accumulator for proper content management
+ content_accumulator = StreamContentAccumulator()
+ iteration_count = 0
+ while True:
+ # Check termination condition
+ if self.stop_event and self.stop_event.is_set():
+ yield self._step_terminate(
+ num_tokens, tool_call_records, "termination_triggered"
+ )
+ return
+
+ # Get async streaming response from model
+ try:
+ response = await self.model_backend.arun(
+ openai_messages,
+ response_format,
+ self._get_full_tool_schemas() or None,
+ )
+ iteration_count += 1
+ except Exception as exc:
+ logger.error(
+ f"Error in async streaming model response: {exc}",
+ exc_info=exc,
+ )
+ yield self._create_error_response(str(exc), tool_call_records)
+ return
+
+ # Handle streaming response
+ if isinstance(response, AsyncStream):
+ stream_completed = False
+ tool_calls_complete = False
+
+ # Process chunks and forward them
+ async for (
+ item
+ ) in self._aprocess_stream_chunks_with_accumulator(
+ response,
+ content_accumulator,
+ accumulated_tool_calls,
+ tool_call_records,
+ step_token_usage,
+ response_format,
+ ):
+ if isinstance(item, tuple):
+ # This is the final return value (stream_completed,
+ # tool_calls_complete)
+ stream_completed, tool_calls_complete = item
+ break
+ else:
+ # This is a ChatAgentResponse to be yielded
+ yield item
+
+ if tool_calls_complete:
+ # Clear completed tool calls
+ accumulated_tool_calls.clear()
+
+ # If we executed tools and not in
+ # single iteration mode, continue
+ if tool_call_records and (
+ self.max_iteration is None
+ or iteration_count < self.max_iteration
+ ):
+ # Update messages with tool results for next iteration
+ try:
+ openai_messages, num_tokens = (
+ self.memory.get_context()
+ )
+ except RuntimeError as e:
+ yield self._step_terminate(
+ e.args[1],
+ tool_call_records,
+ "max_tokens_exceeded",
+ )
+ return
+ # Reset streaming content for next iteration
+ content_accumulator.reset_streaming_content()
+ continue
+ else:
+ break
+ else:
+ # Stream completed without tool calls
+ accumulated_tool_calls.clear()
+ break
+ elif hasattr(response, '__aenter__') and hasattr(
+ response, '__aexit__'
+ ):
+ # Handle structured output stream
+ # (AsyncChatCompletionStreamManager)
+ async with response as stream:
+ parsed_object = None
+
+ async for event in stream:
+ if event.type == "content.delta":
+ if getattr(event, "delta", None):
+ # Use accumulator for proper content management
+ partial_response = self._create_streaming_response_with_accumulator( # noqa: E501
+ content_accumulator,
+ getattr(event, "delta", ""),
+ step_token_usage,
+ tool_call_records=tool_call_records.copy(),
+ )
+ yield partial_response
+
+ elif event.type == "content.done":
+ parsed_object = getattr(event, "parsed", None)
+ break
+ elif event.type == "error":
+ logger.error(
+ f"Error in async structured stream: "
+ f"{getattr(event, 'error', '')}"
+ )
+ yield self._create_error_response(
+ str(getattr(event, 'error', '')),
+ tool_call_records,
+ )
+ return
+
+ # Get final completion and record final message
+ try:
+ final_completion = await stream.get_final_completion()
+ final_content = (
+ final_completion.choices[0].message.content or ""
+ )
+
+ final_message = BaseMessage(
+ role_name=self.role_name,
+ role_type=self.role_type,
+ meta_dict={},
+ content=final_content,
+ parsed=cast(
+ "BaseModel | dict[str, Any] | None",
+ parsed_object,
+ ), # type: ignore[arg-type]
+ )
+
+ self.record_message(final_message)
+
+ # Create final response
+ final_response = ChatAgentResponse(
+ msgs=[final_message],
+ terminated=False,
+ info={
+ "id": final_completion.id or "",
+ "usage": safe_model_dump(
+ final_completion.usage
+ )
+ if final_completion.usage
+ else {},
+ "finish_reasons": [
+ choice.finish_reason or "stop"
+ for choice in final_completion.choices
+ ],
+ "num_tokens": self._get_token_count(
+ final_content
+ ),
+ "tool_calls": tool_call_records,
+ "external_tool_requests": None,
+ "streaming": False,
+ "partial": False,
+ },
+ )
+ yield final_response
+ break
+
+ except Exception as e:
+ logger.error(
+ f"Error getting async final completion: {e}"
+ )
+ yield self._create_error_response(
+ str(e), tool_call_records
+ )
+ return
+ else:
+ # Handle non-streaming response (fallback)
+ model_response = self._handle_batch_response(response)
+ yield self._convert_to_chatagent_response(
+ model_response,
+ tool_call_records,
+ num_tokens,
+ None,
+ model_response.usage_dict.get("prompt_tokens", 0),
+ model_response.usage_dict.get("completion_tokens", 0),
+ model_response.usage_dict.get("total_tokens", 0),
+ )
+ accumulated_tool_calls.clear()
+ break
+
+ def _record_assistant_tool_calls_message(
+ self, accumulated_tool_calls: Dict[str, Any], content: str = ""
+ ) -> None:
+ r"""Record the assistant message that contains tool calls.
+
+ This method creates and records an assistant message that includes
+ the tool calls information, which is required by OpenAI's API format.
+ """
+ # Create a BaseMessage with tool_calls information in meta_dict
+ # This will be converted to the proper OpenAI format when needed
+ tool_calls_list = []
+ for tool_call_data in accumulated_tool_calls.values():
+ if tool_call_data.get('complete', False):
+ tool_call_dict = {
+ "id": tool_call_data["id"],
+ "type": "function",
+ "function": {
+ "name": tool_call_data["function"]["name"],
+ "arguments": tool_call_data["function"]["arguments"],
+ },
+ }
+ tool_calls_list.append(tool_call_dict)
+
+ # Create an assistant message with tool calls
+ assist_msg = BaseMessage(
+ role_name=self.role_name,
+ role_type=self.role_type,
+ meta_dict={"tool_calls": tool_calls_list},
+ content=content or "",
+ )
+
+ # Record this assistant message
+ self.update_memory(assist_msg, OpenAIBackendRole.ASSISTANT)
+
+ async def _aprocess_stream_chunks_with_accumulator(
+ self,
+ stream: AsyncStream[ChatCompletionChunk],
+ content_accumulator: StreamContentAccumulator,
+ accumulated_tool_calls: Dict[str, Any],
+ tool_call_records: List[ToolCallingRecord],
+ step_token_usage: Dict[str, int],
+ response_format: Optional[Type[BaseModel]] = None,
+ ) -> AsyncGenerator[Union[ChatAgentResponse, Tuple[bool, bool]], None]:
+ r"""Async version of process streaming chunks with
+ content accumulator."""
+
+ tool_calls_complete = False
+ stream_completed = False
+
+ async for chunk in stream:
+ # Update token usage if available
+ if chunk.usage:
+ self._update_token_usage_tracker(
+ step_token_usage, safe_model_dump(chunk.usage)
+ )
+
+ # Process chunk delta
+ if chunk.choices and len(chunk.choices) > 0:
+ choice = chunk.choices[0]
+ delta = choice.delta
+
+ # Handle content streaming
+ if delta.content:
+ # Use accumulator for proper content management
+ partial_response = (
+ self._create_streaming_response_with_accumulator(
+ content_accumulator,
+ delta.content,
+ step_token_usage,
+ getattr(chunk, 'id', ''),
+ tool_call_records.copy(),
+ )
+ )
+ yield partial_response
+
+ # Handle tool calls streaming
+ if delta.tool_calls:
+ tool_calls_complete = self._accumulate_tool_calls(
+ delta.tool_calls, accumulated_tool_calls
+ )
+
+ # Check if stream is complete
+ if choice.finish_reason:
+ stream_completed = True
+
+ # If we have complete tool calls, execute them with
+ # async status updates
+ if accumulated_tool_calls:
+ # Record assistant message with
+ # tool calls first
+ self._record_assistant_tool_calls_message(
+ accumulated_tool_calls,
+ content_accumulator.get_full_content(),
+ )
+
+ # Execute tools asynchronously with real-time
+ # status updates
+ async for (
+ status_response
+ ) in self._execute_tools_async_with_status_accumulator(
+ accumulated_tool_calls,
+ content_accumulator,
+ step_token_usage,
+ tool_call_records,
+ ):
+ yield status_response
+
+ # Yield "Sending back result to model" status
+ if tool_call_records:
+ sending_status = self._create_tool_status_response_with_accumulator( # noqa: E501
+ content_accumulator,
+ "\n------\n\nSending back result to model\n\n",
+ "tool_sending",
+ step_token_usage,
+ )
+ yield sending_status
+
+ # Record final message only if we have content AND no tool
+ # calls. If there are tool calls, _record_tool_calling
+ # will handle message recording.
+ final_content = content_accumulator.get_full_content()
+ if final_content.strip() and not accumulated_tool_calls:
+ final_message = BaseMessage(
+ role_name=self.role_name,
+ role_type=self.role_type,
+ meta_dict={},
+ content=final_content,
+ )
+
+ if response_format:
+ self._try_format_message(
+ final_message, response_format
+ )
+
+ self.record_message(final_message)
+ break
+
+ # Yield the final status as a tuple
+ yield (stream_completed, tool_calls_complete)
+
+ async def _execute_tools_async_with_status_accumulator(
+ self,
+ accumulated_tool_calls: Dict[str, Any],
+ content_accumulator: StreamContentAccumulator,
+ step_token_usage: Dict[str, int],
+ tool_call_records: List[ToolCallingRecord],
+ ) -> AsyncGenerator[ChatAgentResponse, None]:
+ r"""Execute multiple tools asynchronously with
+ proper content accumulation."""
+ import asyncio
+
+ # Phase 1: Start all tools and yield "Calling function"
+ # statuses immediately
+ tool_tasks = []
+ for _tool_call_index, tool_call_data in accumulated_tool_calls.items():
+ if tool_call_data.get('complete', False):
+ function_name = tool_call_data['function']['name']
+ try:
+ args = json.loads(tool_call_data['function']['arguments'])
+ except json.JSONDecodeError:
+ args = tool_call_data['function']['arguments']
+
+ status_message = (
+ f"\nCalling function: {function_name} "
+ f"with arguments:\n{args}\n"
+ )
+
+ # Immediately yield "Calling function" status
+ calling_status = (
+ self._create_tool_status_response_with_accumulator(
+ content_accumulator,
+ status_message,
+ "tool_calling",
+ step_token_usage,
+ )
+ )
+ yield calling_status
+
+ # Start tool execution asynchronously (non-blocking)
+ if self.tool_execution_timeout is not None:
+ task = asyncio.create_task(
+ asyncio.wait_for(
+ self._aexecute_tool_from_stream_data(
+ tool_call_data
+ ),
+ timeout=self.tool_execution_timeout,
+ )
+ )
+ else:
+ task = asyncio.create_task(
+ self._aexecute_tool_from_stream_data(tool_call_data)
+ )
+ tool_tasks.append((task, tool_call_data))
+
+ # Phase 2: Wait for tools to complete and yield results as they finish
+ if tool_tasks:
+ # Use asyncio.as_completed for true async processing
+ for completed_task in asyncio.as_completed(
+ [task for task, _ in tool_tasks]
+ ):
+ try:
+ tool_call_record = await completed_task
+ if tool_call_record:
+ # Add to the shared tool_call_records list
+ tool_call_records.append(tool_call_record)
+
+ # Create output status message
+ raw_result = tool_call_record.result
+ result_str = str(raw_result)
+ status_message = (
+ f"\nFunction output: {result_str}\n---------\n"
+ )
+
+ # Yield "Function output" status as soon as this
+ # tool completes
+ output_status = (
+ self._create_tool_status_response_with_accumulator(
+ content_accumulator,
+ status_message,
+ "tool_output",
+ step_token_usage,
+ [tool_call_record],
+ )
+ )
+ yield output_status
+
+ except Exception as e:
+ if isinstance(e, asyncio.TimeoutError):
+ timeout_msg = (
+ f"\nFunction timed out after "
+ f"{self.tool_execution_timeout} seconds.\n"
+ f"---------\n"
+ )
+ timeout_status = (
+ self._create_tool_status_response_with_accumulator(
+ content_accumulator,
+ timeout_msg,
+ "tool_timeout",
+ step_token_usage,
+ )
+ )
+ yield timeout_status
+ logger.error("Async tool execution timeout")
+ else:
+ logger.error(f"Error in async tool execution: {e}")
+ continue
+
+ def _create_tool_status_response_with_accumulator(
+ self,
+ accumulator: StreamContentAccumulator,
+ status_message: str,
+ status_type: str,
+ step_token_usage: Dict[str, int],
+ tool_calls: Optional[List[ToolCallingRecord]] = None,
+ ) -> ChatAgentResponse:
+ r"""Create a tool status response using content accumulator."""
+
+ # Add this status message to accumulator and get full content
+ accumulator.add_tool_status(status_message)
+ full_content = accumulator.get_full_content()
+
+ message = BaseMessage(
+ role_name=self.role_name,
+ role_type=self.role_type,
+ meta_dict={},
+ content=full_content,
+ )
+
+ return ChatAgentResponse(
+ msgs=[message],
+ terminated=False,
+ info={
+ "id": "",
+ "usage": step_token_usage.copy(),
+ "finish_reasons": [status_type],
+ "num_tokens": self._get_token_count(full_content),
+ "tool_calls": tool_calls or [],
+ "external_tool_requests": None,
+ "streaming": True,
+ "tool_status": status_type,
+ "partial": True,
+ },
+ )
+
+ def _create_streaming_response_with_accumulator(
+ self,
+ accumulator: StreamContentAccumulator,
+ new_content: str,
+ step_token_usage: Dict[str, int],
+ response_id: str = "",
+ tool_call_records: Optional[List[ToolCallingRecord]] = None,
+ ) -> ChatAgentResponse:
+ r"""Create a streaming response using content accumulator."""
+
+ # Add new content to accumulator and get full content
+ accumulator.add_streaming_content(new_content)
+ full_content = accumulator.get_full_content()
+
+ message = BaseMessage(
+ role_name=self.role_name,
+ role_type=self.role_type,
+ meta_dict={},
+ content=full_content,
+ )
+
+ return ChatAgentResponse(
+ msgs=[message],
+ terminated=False,
+ info={
+ "id": response_id,
+ "usage": step_token_usage.copy(),
+ "finish_reasons": ["streaming"],
+ "num_tokens": self._get_token_count(full_content),
+ "tool_calls": tool_call_records or [],
+ "external_tool_requests": None,
+ "streaming": True,
+ "partial": True,
+ },
+ )
+
def get_usage_dict(
self, output_messages: List[BaseMessage], prompt_tokens: int
) -> Dict[str, int]:
@@ -2483,6 +3825,7 @@ class ChatAgent(BaseAgent):
),
max_iteration=self.max_iteration,
stop_event=self.stop_event,
+ tool_execution_timeout=self.tool_execution_timeout,
pause_event=self.pause_event,
)
diff --git a/camel/agents/repo_agent.py b/camel/agents/repo_agent.py
index c21a7ab3a..986c7b05d 100644
--- a/camel/agents/repo_agent.py
+++ b/camel/agents/repo_agent.py
@@ -21,6 +21,7 @@ if TYPE_CHECKING:
from pydantic import BaseModel
from camel.agents import ChatAgent
+from camel.agents.chat_agent import StreamingChatAgentResponse
from camel.logger import get_logger
from camel.messages import BaseMessage
from camel.models import BaseModelBackend, ModelFactory
@@ -442,7 +443,7 @@ class RepoAgent(ChatAgent):
def step(
self, input_message: Union[BaseMessage, str], *args, **kwargs
- ) -> ChatAgentResponse:
+ ) -> Union[ChatAgentResponse, StreamingChatAgentResponse]:
r"""Overrides `ChatAgent.step()` to first retrieve relevant context
from the vector store before passing the input to the language model.
"""
diff --git a/camel/benchmarks/browsecomp.py b/camel/benchmarks/browsecomp.py
index 7d451be31..3f269388e 100644
--- a/camel/benchmarks/browsecomp.py
+++ b/camel/benchmarks/browsecomp.py
@@ -619,20 +619,20 @@ class BrowseCompBenchmark(BaseBenchmark):
assistant_response, user_response = pipeline.step(
input_msg
)
- if assistant_response.terminated: # type: ignore[attr-defined]
+ if assistant_response.terminated: # type: ignore[union-attr]
break
- if user_response.terminated: # type: ignore[attr-defined]
+ if user_response.terminated: # type: ignore[union-attr]
break
- if "CAMEL_TASK_DONE" in user_response.msg.content: # type: ignore[attr-defined]
+ if "CAMEL_TASK_DONE" in user_response.msg.content: # type: ignore[union-attr]
break
chat_history.append(
- f"AI User: {user_response.msg.content}" # type: ignore[attr-defined]
+ f"AI User: {user_response.msg.content}" # type: ignore[union-attr]
)
chat_history.append(
- f"AI Assistant: {assistant_response.msg.content}" # type: ignore[attr-defined]
+ f"AI Assistant: {assistant_response.msg.content}" # type: ignore[union-attr]
)
- input_msg = assistant_response.msg # type: ignore[attr-defined]
+ input_msg = assistant_response.msg # type: ignore[union-attr]
chat_history_str = "\n".join(chat_history)
if roleplaying_summarizer:
diff --git a/camel/messages/base.py b/camel/messages/base.py
index 3c78efde8..454813ca9 100644
--- a/camel/messages/base.py
+++ b/camel/messages/base.py
@@ -533,7 +533,18 @@ class BaseMessage:
OpenAIAssistantMessage: The converted :obj:`OpenAIAssistantMessage`
object.
"""
- return {"role": "assistant", "content": self.content}
+ message_dict: Dict[str, Any] = {
+ "role": "assistant",
+ "content": self.content,
+ }
+
+ # Check if meta_dict contains tool_calls
+ if self.meta_dict and "tool_calls" in self.meta_dict:
+ tool_calls = self.meta_dict["tool_calls"]
+ if tool_calls:
+ message_dict["tool_calls"] = tool_calls
+
+ return message_dict # type: ignore[return-value]
def to_dict(self) -> Dict:
r"""Converts the message to a dictionary.
diff --git a/camel/models/azure_openai_model.py b/camel/models/azure_openai_model.py
index f661d98f5..f122581a4 100644
--- a/camel/models/azure_openai_model.py
+++ b/camel/models/azure_openai_model.py
@@ -11,10 +11,15 @@
# See the License for the specific language governing permissions and
# limitations under the License.
# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+import copy
import os
from typing import Any, Callable, Dict, List, Optional, Type, Union
from openai import AsyncAzureOpenAI, AsyncStream, AzureOpenAI, Stream
+from openai.lib.streaming.chat import (
+ AsyncChatCompletionStreamManager,
+ ChatCompletionStreamManager,
+)
from pydantic import BaseModel
from camel.configs import OPENAI_API_PARAMS, ChatGPTConfig
@@ -202,7 +207,11 @@ class AzureOpenAIModel(BaseModelBackend):
messages: List[OpenAIMessage],
response_format: Optional[Type[BaseModel]] = None,
tools: Optional[List[Dict[str, Any]]] = None,
- ) -> Union[ChatCompletion, Stream[ChatCompletionChunk]]:
+ ) -> Union[
+ ChatCompletion,
+ Stream[ChatCompletionChunk],
+ ChatCompletionStreamManager[BaseModel],
+ ]:
r"""Runs inference of Azure OpenAI chat completion.
Args:
@@ -217,6 +226,8 @@ class AzureOpenAIModel(BaseModelBackend):
Union[ChatCompletion, Stream[ChatCompletionChunk]]:
`ChatCompletion` in the non-stream mode, or
`Stream[ChatCompletionChunk]` in the stream mode.
+ `ChatCompletionStreamManager[BaseModel]` for
+ structured output streaming.
"""
# Update Langfuse trace with current agent session and metadata
@@ -234,10 +245,17 @@ class AzureOpenAIModel(BaseModelBackend):
response_format = response_format or self.model_config_dict.get(
"response_format", None
)
+ is_streaming = self.model_config_dict.get("stream", False)
if response_format:
result: Union[ChatCompletion, Stream[ChatCompletionChunk]] = (
self._request_parse(messages, response_format, tools)
)
+ if is_streaming:
+ return self._request_stream_parse(
+ messages, response_format, tools
+ )
+ else:
+ return self._request_parse(messages, response_format, tools)
else:
result = self._request_chat_completion(messages, tools)
@@ -249,7 +267,11 @@ class AzureOpenAIModel(BaseModelBackend):
messages: List[OpenAIMessage],
response_format: Optional[Type[BaseModel]] = None,
tools: Optional[List[Dict[str, Any]]] = None,
- ) -> Union[ChatCompletion, AsyncStream[ChatCompletionChunk]]:
+ ) -> Union[
+ ChatCompletion,
+ AsyncStream[ChatCompletionChunk],
+ AsyncChatCompletionStreamManager[BaseModel],
+ ]:
r"""Runs inference of Azure OpenAI chat completion.
Args:
@@ -261,9 +283,12 @@ class AzureOpenAIModel(BaseModelBackend):
use for the request.
Returns:
- Union[ChatCompletion, AsyncStream[ChatCompletionChunk]]:
+ Union[ChatCompletion, AsyncStream[ChatCompletionChunk],
+ AsyncChatCompletionStreamManager[BaseModel]]:
`ChatCompletion` in the non-stream mode, or
`AsyncStream[ChatCompletionChunk]` in the stream mode.
+ `AsyncChatCompletionStreamManager[BaseModel]` for
+ structured output streaming.
"""
# Update Langfuse trace with current agent session and metadata
@@ -281,10 +306,19 @@ class AzureOpenAIModel(BaseModelBackend):
response_format = response_format or self.model_config_dict.get(
"response_format", None
)
+ is_streaming = self.model_config_dict.get("stream", False)
if response_format:
result: Union[
ChatCompletion, AsyncStream[ChatCompletionChunk]
] = await self._arequest_parse(messages, response_format, tools)
+ if is_streaming:
+ return await self._arequest_stream_parse(
+ messages, response_format, tools
+ )
+ else:
+ return await self._arequest_parse(
+ messages, response_format, tools
+ )
else:
result = await self._arequest_chat_completion(messages, tools)
@@ -328,8 +362,6 @@ class AzureOpenAIModel(BaseModelBackend):
response_format: Type[BaseModel],
tools: Optional[List[Dict[str, Any]]] = None,
) -> ChatCompletion:
- import copy
-
request_config = copy.deepcopy(self.model_config_dict)
request_config["response_format"] = response_format
@@ -351,8 +383,6 @@ class AzureOpenAIModel(BaseModelBackend):
response_format: Type[BaseModel],
tools: Optional[List[Dict[str, Any]]] = None,
) -> ChatCompletion:
- import copy
-
request_config = copy.deepcopy(self.model_config_dict)
request_config["response_format"] = response_format
@@ -368,6 +398,60 @@ class AzureOpenAIModel(BaseModelBackend):
**request_config,
)
+ def _request_stream_parse(
+ self,
+ messages: List[OpenAIMessage],
+ response_format: Type[BaseModel],
+ tools: Optional[List[Dict[str, Any]]] = None,
+ ) -> ChatCompletionStreamManager[BaseModel]:
+ r"""Request streaming structured output parsing.
+
+ Note: This uses OpenAI's beta streaming API for structured outputs.
+ """
+
+ request_config = copy.deepcopy(self.model_config_dict)
+
+ # Remove stream from config as it's handled by the stream method
+ request_config.pop("stream", None)
+
+ if tools is not None:
+ request_config["tools"] = tools
+
+ # Use the beta streaming API for structured outputs
+ return self._client.beta.chat.completions.stream(
+ messages=messages,
+ model=self.model_type,
+ response_format=response_format,
+ **request_config,
+ )
+
+ async def _arequest_stream_parse(
+ self,
+ messages: List[OpenAIMessage],
+ response_format: Type[BaseModel],
+ tools: Optional[List[Dict[str, Any]]] = None,
+ ) -> AsyncChatCompletionStreamManager[BaseModel]:
+ r"""Request async streaming structured output parsing.
+
+ Note: This uses OpenAI's beta streaming API for structured outputs.
+ """
+
+ request_config = copy.deepcopy(self.model_config_dict)
+
+ # Remove stream from config as it's handled by the stream method
+ request_config.pop("stream", None)
+
+ if tools is not None:
+ request_config["tools"] = tools
+
+ # Use the beta streaming API for structured outputs
+ return self._async_client.beta.chat.completions.stream(
+ messages=messages,
+ model=self.model_type,
+ response_format=response_format,
+ **request_config,
+ )
+
def check_model_config(self):
r"""Check whether the model configuration contains any
unexpected arguments to Azure OpenAI API.
diff --git a/camel/models/base_model.py b/camel/models/base_model.py
index 3baae3017..d64fc6b4f 100644
--- a/camel/models/base_model.py
+++ b/camel/models/base_model.py
@@ -18,6 +18,10 @@ from abc import ABC, abstractmethod
from typing import Any, Dict, List, Optional, Type, Union
from openai import AsyncStream, Stream
+from openai.lib.streaming.chat import (
+ AsyncChatCompletionStreamManager,
+ ChatCompletionStreamManager,
+)
from pydantic import BaseModel
from camel.messages import OpenAIMessage
@@ -307,7 +311,28 @@ class BaseModelBackend(ABC, metaclass=ModelBackendMeta):
messages: List[OpenAIMessage],
response_format: Optional[Type[BaseModel]] = None,
tools: Optional[List[Dict[str, Any]]] = None,
- ) -> Union[ChatCompletion, Stream[ChatCompletionChunk]]:
+ ) -> Union[
+ ChatCompletion,
+ Stream[ChatCompletionChunk],
+ ChatCompletionStreamManager[BaseModel],
+ ]:
+ r"""Runs the query to the backend model in a non-stream mode.
+
+ Args:
+ 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], Any]:
+ `ChatCompletion` in the non-stream mode, or
+ `Stream[ChatCompletionChunk]` in the stream mode,
+ or `ChatCompletionStreamManager[BaseModel]` in the structured
+ stream mode.
+ """
pass
@abstractmethod
@@ -316,7 +341,28 @@ class BaseModelBackend(ABC, metaclass=ModelBackendMeta):
messages: List[OpenAIMessage],
response_format: Optional[Type[BaseModel]] = None,
tools: Optional[List[Dict[str, Any]]] = None,
- ) -> Union[ChatCompletion, AsyncStream[ChatCompletionChunk]]:
+ ) -> Union[
+ ChatCompletion,
+ AsyncStream[ChatCompletionChunk],
+ AsyncChatCompletionStreamManager[BaseModel],
+ ]:
+ r"""Runs the query to the backend model in async non-stream mode.
+
+ Args:
+ 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, AsyncStream[ChatCompletionChunk], Any]:
+ `ChatCompletion` in the non-stream mode, or
+ `AsyncStream[ChatCompletionChunk]` in the stream mode,
+ or `AsyncChatCompletionStreamManager[BaseModel]` in the
+ structured stream mode.
+ """
pass
def run(
@@ -324,7 +370,11 @@ class BaseModelBackend(ABC, metaclass=ModelBackendMeta):
messages: List[OpenAIMessage],
response_format: Optional[Type[BaseModel]] = None,
tools: Optional[List[Dict[str, Any]]] = None,
- ) -> Union[ChatCompletion, Stream[ChatCompletionChunk]]:
+ ) -> Union[
+ ChatCompletion,
+ Stream[ChatCompletionChunk],
+ ChatCompletionStreamManager[BaseModel],
+ ]:
r"""Runs the query to the backend model.
Args:
@@ -338,9 +388,11 @@ class BaseModelBackend(ABC, metaclass=ModelBackendMeta):
(default: :obj:`None`)
Returns:
- Union[ChatCompletion, Stream[ChatCompletionChunk]]:
- `ChatCompletion` in the non-stream mode, or
- `Stream[ChatCompletionChunk]` in the stream mode.
+ Union[ChatCompletion, Stream[ChatCompletionChunk], Any]:
+ `ChatCompletion` in the non-stream mode,
+ `Stream[ChatCompletionChunk]` in the stream mode, or
+ `ChatCompletionStreamManager[BaseModel]` in the structured
+ stream mode.
"""
# Log the request if logging is enabled
log_path = self._log_request(messages)
@@ -365,7 +417,11 @@ class BaseModelBackend(ABC, metaclass=ModelBackendMeta):
messages: List[OpenAIMessage],
response_format: Optional[Type[BaseModel]] = None,
tools: Optional[List[Dict[str, Any]]] = None,
- ) -> Union[ChatCompletion, AsyncStream[ChatCompletionChunk]]:
+ ) -> Union[
+ ChatCompletion,
+ AsyncStream[ChatCompletionChunk],
+ AsyncChatCompletionStreamManager[BaseModel],
+ ]:
r"""Runs the query to the backend model asynchronously.
Args:
@@ -379,9 +435,11 @@ class BaseModelBackend(ABC, metaclass=ModelBackendMeta):
(default: :obj:`None`)
Returns:
- Union[ChatCompletion, AsyncStream[ChatCompletionChunk]]:
- `ChatCompletion` in the non-stream mode, or
- `AsyncStream[ChatCompletionChunk]` in the stream mode.
+ Union[ChatCompletion, AsyncStream[ChatCompletionChunk], Any]:
+ `ChatCompletion` in the non-stream mode,
+ `AsyncStream[ChatCompletionChunk]` in the stream mode, or
+ `AsyncChatCompletionStreamManager[BaseModel]` in the structured
+ stream mode.
"""
# Log the request if logging is enabled
log_path = self._log_request(messages)
diff --git a/camel/models/model_manager.py b/camel/models/model_manager.py
index 66ef6fefc..b55623a44 100644
--- a/camel/models/model_manager.py
+++ b/camel/models/model_manager.py
@@ -27,6 +27,10 @@ from typing import (
)
from openai import AsyncStream, Stream
+from openai.lib.streaming.chat import (
+ AsyncChatCompletionStreamManager,
+ ChatCompletionStreamManager,
+)
from pydantic import BaseModel
from camel.messages import OpenAIMessage
@@ -196,7 +200,11 @@ class ModelManager:
messages: List[OpenAIMessage],
response_format: Optional[Type[BaseModel]] = None,
tools: Optional[List[Dict[str, Any]]] = None,
- ) -> Union[ChatCompletion, Stream[ChatCompletionChunk]]:
+ ) -> Union[
+ ChatCompletion,
+ Stream[ChatCompletionChunk],
+ ChatCompletionStreamManager[BaseModel],
+ ]:
r"""Process a list of messages by selecting a model based on
the scheduling strategy.
Sends the entire list of messages to the selected model,
@@ -207,9 +215,12 @@ class ModelManager:
history in OpenAI API format.
Returns:
- Union[ChatCompletion, Stream[ChatCompletionChunk]]:
+ Union[ChatCompletion, Stream[ChatCompletionChunk],
+ ChatCompletionStreamManager[BaseModel]]:
`ChatCompletion` in the non-stream mode, or
- `Stream[ChatCompletionChunk]` in the stream mode.
+ `Stream[ChatCompletionChunk]` in the stream mode, or
+ `ChatCompletionStreamManager[BaseModel]` for
+ structured-output stream.
"""
self.current_model = self.scheduling_strategy()
@@ -233,7 +244,11 @@ class ModelManager:
messages: List[OpenAIMessage],
response_format: Optional[Type[BaseModel]] = None,
tools: Optional[List[Dict[str, Any]]] = None,
- ) -> Union[ChatCompletion, AsyncStream[ChatCompletionChunk]]:
+ ) -> Union[
+ ChatCompletion,
+ AsyncStream[ChatCompletionChunk],
+ AsyncChatCompletionStreamManager[BaseModel],
+ ]:
r"""Process a list of messages by selecting a model based on
the scheduling strategy.
Sends the entire list of messages to the selected model,
@@ -244,9 +259,12 @@ class ModelManager:
history in OpenAI API format.
Returns:
- Union[ChatCompletion, AsyncStream[ChatCompletionChunk]]:
+ Union[ChatCompletion, AsyncStream[ChatCompletionChunk],
+ AsyncChatCompletionStreamManager[BaseModel]]:
`ChatCompletion` in the non-stream mode, or
- `AsyncStream[ChatCompletionChunk]` in the stream mode.
+ `AsyncStream[ChatCompletionChunk]` in the stream mode, or
+ `AsyncChatCompletionStreamManager[BaseModel]` for
+ structured-output stream.
"""
async with self.lock:
self.current_model = self.scheduling_strategy()
diff --git a/camel/models/openai_compatible_model.py b/camel/models/openai_compatible_model.py
index ed4fe7e0f..8b87ddc82 100644
--- a/camel/models/openai_compatible_model.py
+++ b/camel/models/openai_compatible_model.py
@@ -17,6 +17,10 @@ from json import JSONDecodeError
from typing import Any, Dict, List, Optional, Type, Union
from openai import AsyncOpenAI, AsyncStream, BadRequestError, OpenAI, Stream
+from openai.lib.streaming.chat import (
+ AsyncChatCompletionStreamManager,
+ ChatCompletionStreamManager,
+)
from pydantic import BaseModel, ValidationError
from camel.logger import get_logger
@@ -143,7 +147,11 @@ class OpenAICompatibleModel(BaseModelBackend):
messages: List[OpenAIMessage],
response_format: Optional[Type[BaseModel]] = None,
tools: Optional[List[Dict[str, Any]]] = None,
- ) -> Union[ChatCompletion, Stream[ChatCompletionChunk]]:
+ ) -> Union[
+ ChatCompletion,
+ Stream[ChatCompletionChunk],
+ ChatCompletionStreamManager[BaseModel],
+ ]:
r"""Runs inference of OpenAI chat completion.
Args:
@@ -158,6 +166,8 @@ class OpenAICompatibleModel(BaseModelBackend):
Union[ChatCompletion, Stream[ChatCompletionChunk]]:
`ChatCompletion` in the non-stream mode, or
`Stream[ChatCompletionChunk]` in the stream mode.
+ `ChatCompletionStreamManager[BaseModel]` for
+ structured output streaming.
"""
# Update Langfuse trace with current agent session and metadata
@@ -175,10 +185,22 @@ class OpenAICompatibleModel(BaseModelBackend):
response_format = response_format or self.model_config_dict.get(
"response_format", None
)
+
+ # Check if streaming is enabled
+ is_streaming = self.model_config_dict.get("stream", False)
+
if response_format:
result: Union[ChatCompletion, Stream[ChatCompletionChunk]] = (
self._request_parse(messages, response_format, tools)
)
+ if is_streaming:
+ # Use streaming parse for structured output
+ return self._request_stream_parse(
+ messages, response_format, tools
+ )
+ else:
+ # Use non-streaming parse for structured output
+ return self._request_parse(messages, response_format, tools)
else:
result = self._request_chat_completion(messages, tools)
@@ -190,7 +212,11 @@ class OpenAICompatibleModel(BaseModelBackend):
messages: List[OpenAIMessage],
response_format: Optional[Type[BaseModel]] = None,
tools: Optional[List[Dict[str, Any]]] = None,
- ) -> Union[ChatCompletion, AsyncStream[ChatCompletionChunk]]:
+ ) -> Union[
+ ChatCompletion,
+ AsyncStream[ChatCompletionChunk],
+ AsyncChatCompletionStreamManager[BaseModel],
+ ]:
r"""Runs inference of OpenAI chat completion in async mode.
Args:
@@ -202,9 +228,12 @@ class OpenAICompatibleModel(BaseModelBackend):
use for the request.
Returns:
- Union[ChatCompletion, AsyncStream[ChatCompletionChunk]]:
- `ChatCompletion` in the non-stream mode, or
- `AsyncStream[ChatCompletionChunk]` in the stream mode.
+ Union[ChatCompletion, AsyncStream[ChatCompletionChunk],
+ AsyncChatCompletionStreamManager[BaseModel]]:
+ `ChatCompletion` in the non-stream mode,
+ `AsyncStream[ChatCompletionChunk]` in the stream mode,
+ or `AsyncChatCompletionStreamManager[BaseModel]` for
+ structured output streaming.
"""
# Update Langfuse trace with current agent session and metadata
@@ -222,10 +251,24 @@ class OpenAICompatibleModel(BaseModelBackend):
response_format = response_format or self.model_config_dict.get(
"response_format", None
)
+
+ # Check if streaming is enabled
+ is_streaming = self.model_config_dict.get("stream", False)
+
if response_format:
result: Union[
ChatCompletion, AsyncStream[ChatCompletionChunk]
] = await self._arequest_parse(messages, response_format, tools)
+ if is_streaming:
+ # Use streaming parse for structured output
+ return await self._arequest_stream_parse(
+ messages, response_format, tools
+ )
+ else:
+ # Use non-streaming parse for structured output
+ return await self._arequest_parse(
+ messages, response_format, tools
+ )
else:
result = await self._arequest_chat_completion(messages, tools)
@@ -341,6 +384,62 @@ class OpenAICompatibleModel(BaseModelBackend):
logger.error(f"Fallback attempt also failed: {e}")
raise
+ def _request_stream_parse(
+ self,
+ messages: List[OpenAIMessage],
+ response_format: Type[BaseModel],
+ tools: Optional[List[Dict[str, Any]]] = None,
+ ) -> ChatCompletionStreamManager[BaseModel]:
+ r"""Request streaming structured output parsing.
+
+ Note: This uses OpenAI's beta streaming API for structured outputs.
+ """
+ import copy
+
+ request_config = copy.deepcopy(self.model_config_dict)
+
+ # Remove stream from config as it's handled by the stream method
+ request_config.pop("stream", None)
+
+ if tools is not None:
+ request_config["tools"] = tools
+
+ # Use the beta streaming API for structured outputs
+ return self._client.beta.chat.completions.stream(
+ messages=messages,
+ model=self.model_type,
+ response_format=response_format,
+ **request_config,
+ )
+
+ async def _arequest_stream_parse(
+ self,
+ messages: List[OpenAIMessage],
+ response_format: Type[BaseModel],
+ tools: Optional[List[Dict[str, Any]]] = None,
+ ) -> AsyncChatCompletionStreamManager[BaseModel]:
+ r"""Request async streaming structured output parsing.
+
+ Note: This uses OpenAI's beta streaming API for structured outputs.
+ """
+ import copy
+
+ request_config = copy.deepcopy(self.model_config_dict)
+
+ # Remove stream from config as it's handled by the stream method
+ request_config.pop("stream", None)
+
+ if tools is not None:
+ request_config["tools"] = tools
+
+ # Use the beta streaming API for structured outputs
+ return self._async_client.beta.chat.completions.stream(
+ messages=messages,
+ model=self.model_type,
+ response_format=response_format,
+ **request_config,
+ )
+
@property
def token_counter(self) -> BaseTokenCounter:
r"""Initialize the token counter for the model backend.
diff --git a/camel/models/openai_model.py b/camel/models/openai_model.py
index 009d591f3..ba7d1f981 100644
--- a/camel/models/openai_model.py
+++ b/camel/models/openai_model.py
@@ -16,6 +16,10 @@ import warnings
from typing import Any, Dict, List, Optional, Type, Union
from openai import AsyncOpenAI, AsyncStream, OpenAI, Stream
+from openai.lib.streaming.chat import (
+ AsyncChatCompletionStreamManager,
+ ChatCompletionStreamManager,
+)
from pydantic import BaseModel
from camel.configs import OPENAI_API_PARAMS, ChatGPTConfig
@@ -243,7 +247,11 @@ class OpenAIModel(BaseModelBackend):
messages: List[OpenAIMessage],
response_format: Optional[Type[BaseModel]] = None,
tools: Optional[List[Dict[str, Any]]] = None,
- ) -> Union[ChatCompletion, Stream[ChatCompletionChunk]]:
+ ) -> Union[
+ ChatCompletion,
+ Stream[ChatCompletionChunk],
+ ChatCompletionStreamManager[BaseModel],
+ ]:
r"""Runs inference of OpenAI chat completion.
Args:
@@ -255,9 +263,12 @@ class OpenAIModel(BaseModelBackend):
use for the request.
Returns:
- Union[ChatCompletion, Stream[ChatCompletionChunk]]:
- `ChatCompletion` in the non-stream mode, or
- `Stream[ChatCompletionChunk]` in the stream mode.
+ Union[ChatCompletion, Stream[ChatCompletionChunk],
+ ChatCompletionStreamManager[BaseModel]]:
+ `ChatCompletion` in the non-stream mode,
+ `Stream[ChatCompletionChunk]`in the stream mode,
+ or `ChatCompletionStreamManager[BaseModel]` for
+ structured output streaming.
"""
# Update Langfuse trace with current agent session and metadata
@@ -278,10 +289,22 @@ class OpenAIModel(BaseModelBackend):
response_format = response_format or self.model_config_dict.get(
"response_format", None
)
+
+ # Check if streaming is enabled
+ is_streaming = self.model_config_dict.get("stream", False)
+
if response_format:
result: Union[ChatCompletion, Stream[ChatCompletionChunk]] = (
self._request_parse(messages, response_format, tools)
)
+ if is_streaming:
+ # Use streaming parse for structured output
+ return self._request_stream_parse(
+ messages, response_format, tools
+ )
+ else:
+ # Use non-streaming parse for structured output
+ return self._request_parse(messages, response_format, tools)
else:
result = self._request_chat_completion(messages, tools)
@@ -293,7 +316,11 @@ class OpenAIModel(BaseModelBackend):
messages: List[OpenAIMessage],
response_format: Optional[Type[BaseModel]] = None,
tools: Optional[List[Dict[str, Any]]] = None,
- ) -> Union[ChatCompletion, AsyncStream[ChatCompletionChunk]]:
+ ) -> Union[
+ ChatCompletion,
+ AsyncStream[ChatCompletionChunk],
+ AsyncChatCompletionStreamManager[BaseModel],
+ ]:
r"""Runs inference of OpenAI chat completion in async mode.
Args:
@@ -305,9 +332,12 @@ class OpenAIModel(BaseModelBackend):
use for the request.
Returns:
- Union[ChatCompletion, AsyncStream[ChatCompletionChunk]]:
- `ChatCompletion` in the non-stream mode, or
- `AsyncStream[ChatCompletionChunk]` in the stream mode.
+ Union[ChatCompletion, AsyncStream[ChatCompletionChunk],
+ AsyncChatCompletionStreamManager[BaseModel]]:
+ `ChatCompletion` in the non-stream mode,
+ `AsyncStream[ChatCompletionChunk]` in the stream mode, or
+ `AsyncChatCompletionStreamManager[BaseModel]` for
+ structured output streaming.
"""
# Update Langfuse trace with current agent session and metadata
@@ -328,10 +358,24 @@ class OpenAIModel(BaseModelBackend):
response_format = response_format or self.model_config_dict.get(
"response_format", None
)
+
+ # Check if streaming is enabled
+ is_streaming = self.model_config_dict.get("stream", False)
+
if response_format:
result: Union[
ChatCompletion, AsyncStream[ChatCompletionChunk]
] = await self._arequest_parse(messages, response_format, tools)
+ if is_streaming:
+ # Use streaming parse for structured output
+ return await self._arequest_stream_parse(
+ messages, response_format, tools
+ )
+ else:
+ # Use non-streaming parse for structured output
+ return await self._arequest_parse(
+ messages, response_format, tools
+ )
else:
result = await self._arequest_chat_completion(messages, tools)
@@ -427,6 +471,66 @@ class OpenAIModel(BaseModelBackend):
**request_config,
)
+ def _request_stream_parse(
+ self,
+ messages: List[OpenAIMessage],
+ response_format: Type[BaseModel],
+ tools: Optional[List[Dict[str, Any]]] = None,
+ ) -> ChatCompletionStreamManager[BaseModel]:
+ r"""Request streaming structured output parsing.
+
+ Note: This uses OpenAI's beta streaming API for structured outputs.
+ """
+ import copy
+
+ request_config = copy.deepcopy(self.model_config_dict)
+
+ # Remove stream from config as it's handled by the stream method
+ request_config.pop("stream", None)
+
+ if tools is not None:
+ request_config["tools"] = tools
+
+ request_config = self._sanitize_config(request_config)
+
+ # Use the beta streaming API for structured outputs
+ return self._client.beta.chat.completions.stream(
+ messages=messages,
+ model=self.model_type,
+ response_format=response_format,
+ **request_config,
+ )
+
+ async def _arequest_stream_parse(
+ self,
+ messages: List[OpenAIMessage],
+ response_format: Type[BaseModel],
+ tools: Optional[List[Dict[str, Any]]] = None,
+ ) -> AsyncChatCompletionStreamManager[BaseModel]:
+ r"""Request async streaming structured output parsing.
+
+ Note: This uses OpenAI's beta streaming API for structured outputs.
+ """
+ import copy
+
+ request_config = copy.deepcopy(self.model_config_dict)
+
+ # Remove stream from config as it's handled by the stream method
+ request_config.pop("stream", None)
+
+ if tools is not None:
+ request_config["tools"] = tools
+
+ request_config = self._sanitize_config(request_config)
+
+ # Use the beta streaming API for structured outputs
+ return self._async_client.beta.chat.completions.stream(
+ messages=messages,
+ model=self.model_type,
+ response_format=response_format,
+ **request_config,
+ )
+
def check_model_config(self):
r"""Check whether the model configuration contains any
unexpected arguments to OpenAI API.
diff --git a/docs/conf.py b/docs/conf.py
index 2a2fe5940..c5c1c2ec5 100644
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -27,7 +27,7 @@ sys.path.insert(0, os.path.abspath('..'))
project = 'CAMEL'
copyright = '2024, CAMEL-AI.org'
author = 'CAMEL-AI.org'
-release = '0.2.71a4'
+release = '0.2.71a5'
html_favicon = (
'https://raw.githubusercontent.com/camel-ai/camel/master/misc/favicon.png'
diff --git a/docs/mintlify/reference/camel.agents.chat_agent.mdx b/docs/mintlify/reference/camel.agents.chat_agent.mdx
index 5727c047f..ef98894bd 100644
--- a/docs/mintlify/reference/camel.agents.chat_agent.mdx
+++ b/docs/mintlify/reference/camel.agents.chat_agent.mdx
@@ -922,3 +922,297 @@ Expose this ChatAgent as an MCP server.
**Returns:**
FastMCP: An MCP server instance that can be run.
+
+<a id="camel.agents.chat_agent.ChatAgent.stream"></a>
+
+### stream
+
+```python
+def stream(
+ self,
+ input_message: Union[BaseMessage, str],
+ response_format: Optional[Type[BaseModel]] = None
+):
+```
+
+Executes a streaming step in the chat session, yielding
+intermediate responses as they are generated.
+
+**Parameters:**
+
+- **input_message** (Union[BaseMessage, str]): The input message for the agent.
+- **response_format** (Optional[Type[BaseModel]], optional): A Pydantic model defining the expected structure of the response.
+- **Yields**:
+- **ChatAgentResponse**: Intermediate responses containing partial content, tool calls, and other information as they become available.
+
+<a id="camel.agents.chat_agent.ChatAgent._stream_response"></a>
+
+### _stream_response
+
+```python
+def _stream_response(
+ self,
+ openai_messages: List[OpenAIMessage],
+ num_tokens: int,
+ response_format: Optional[Type[BaseModel]] = None
+):
+```
+
+Internal method to handle streaming responses with tool calls.
+
+<a id="camel.agents.chat_agent.ChatAgent._process_stream_chunks_with_accumulator"></a>
+
+### _process_stream_chunks_with_accumulator
+
+```python
+def _process_stream_chunks_with_accumulator(
+ self,
+ stream: Stream[ChatCompletionChunk],
+ content_accumulator: '_StreamContentAccumulator',
+ accumulated_tool_calls: Dict[str, Any],
+ tool_call_records: List[ToolCallingRecord],
+ step_token_usage: Dict[str, int],
+ response_format: Optional[Type[BaseModel]] = None
+):
+```
+
+Process streaming chunks with content accumulator.
+
+<a id="camel.agents.chat_agent.ChatAgent._accumulate_tool_calls"></a>
+
+### _accumulate_tool_calls
+
+```python
+def _accumulate_tool_calls(
+ self,
+ tool_call_deltas: List[Any],
+ accumulated_tool_calls: Dict[str, Any]
+):
+```
+
+Accumulate tool call chunks and return True when
+any tool call is complete.
+
+**Parameters:**
+
+- **tool_call_deltas** (List[Any]): List of tool call deltas.
+- **accumulated_tool_calls** (Dict[str, Any]): Dictionary of accumulated tool calls.
+
+**Returns:**
+
+ bool: True if any tool call is complete, False otherwise.
+
+<a id="camel.agents.chat_agent.ChatAgent._execute_tools_sync_with_status_accumulator"></a>
+
+### _execute_tools_sync_with_status_accumulator
+
+```python
+def _execute_tools_sync_with_status_accumulator(
+ self,
+ accumulated_tool_calls: Dict[str, Any],
+ content_accumulator: '_StreamContentAccumulator',
+ step_token_usage: Dict[str, int],
+ tool_call_records: List[ToolCallingRecord]
+):
+```
+
+Execute multiple tools synchronously with
+proper content accumulation.
+
+<a id="camel.agents.chat_agent.ChatAgent._execute_tool_from_stream_data"></a>
+
+### _execute_tool_from_stream_data
+
+```python
+def _execute_tool_from_stream_data(self, tool_call_data: Dict[str, Any]):
+```
+
+Execute a tool from accumulated stream data.
+
+<a id="camel.agents.chat_agent.ChatAgent._create_error_response"></a>
+
+### _create_error_response
+
+```python
+def _create_error_response(
+ self,
+ error_message: str,
+ tool_call_records: List[ToolCallingRecord]
+):
+```
+
+Create an error response for streaming.
+
+<a id="camel.agents.chat_agent.ChatAgent._record_assistant_tool_calls_message"></a>
+
+### _record_assistant_tool_calls_message
+
+```python
+def _record_assistant_tool_calls_message(self, accumulated_tool_calls: Dict[str, Any], content: str = ''):
+```
+
+Record the assistant message that contains tool calls.
+
+This method creates and records an assistant message that includes
+the tool calls information, which is required by OpenAI's API format.
+
+<a id="camel.agents.chat_agent.ChatAgent._create_tool_status_response"></a>
+
+### _create_tool_status_response
+
+```python
+def _create_tool_status_response(
+ self,
+ content: str,
+ status_message: str,
+ status_type: str,
+ step_token_usage: Dict[str, int],
+ tool_calls: Optional[List[ToolCallingRecord]] = None
+):
+```
+
+Create a generic tool status response to
+reduce code duplication.
+
+<a id="camel.agents.chat_agent.ChatAgent._create_simple_tool_calling_status"></a>
+
+### _create_simple_tool_calling_status
+
+```python
+def _create_simple_tool_calling_status(
+ self,
+ tool_call_data: Dict[str, Any],
+ content: str,
+ step_token_usage: Dict[str, int]
+):
+```
+
+Create a simple tool calling status response.
+
+<a id="camel.agents.chat_agent.ChatAgent._create_simple_tool_output_status"></a>
+
+### _create_simple_tool_output_status
+
+```python
+def _create_simple_tool_output_status(
+ self,
+ tool_call_record: ToolCallingRecord,
+ content: str,
+ step_token_usage: Dict[str, int]
+):
+```
+
+Create a simple tool output status response.
+
+<a id="camel.agents.chat_agent.ChatAgent._create_tool_status_response_with_accumulator"></a>
+
+### _create_tool_status_response_with_accumulator
+
+```python
+def _create_tool_status_response_with_accumulator(
+ self,
+ accumulator: '_StreamContentAccumulator',
+ status_message: str,
+ status_type: str,
+ step_token_usage: Dict[str, int],
+ tool_calls: Optional[List[ToolCallingRecord]] = None
+):
+```
+
+Create a tool status response using content accumulator.
+
+<a id="camel.agents.chat_agent.ChatAgent._create_streaming_response_with_accumulator"></a>
+
+### _create_streaming_response_with_accumulator
+
+```python
+def _create_streaming_response_with_accumulator(
+ self,
+ accumulator: '_StreamContentAccumulator',
+ new_content: str,
+ step_token_usage: Dict[str, int],
+ response_id: str = '',
+ tool_call_records: Optional[List[ToolCallingRecord]] = None
+):
+```
+
+Create a streaming response using content accumulator.
+
+<a id="camel.agents.chat_agent._StreamContentAccumulator"></a>
+
+## _StreamContentAccumulator
+
+```python
+class _StreamContentAccumulator:
+```
+
+Manages content accumulation across streaming responses to ensure
+all responses contain complete cumulative content.
+
+<a id="camel.agents.chat_agent._StreamContentAccumulator.__init__"></a>
+
+### __init__
+
+```python
+def __init__(self):
+```
+
+<a id="camel.agents.chat_agent._StreamContentAccumulator.set_base_content"></a>
+
+### set_base_content
+
+```python
+def set_base_content(self, content: str):
+```
+
+Set the base content (usually empty or pre-tool content).
+
+<a id="camel.agents.chat_agent._StreamContentAccumulator.add_streaming_content"></a>
+
+### add_streaming_content
+
+```python
+def add_streaming_content(self, new_content: str):
+```
+
+Add new streaming content.
+
+<a id="camel.agents.chat_agent._StreamContentAccumulator.add_tool_status"></a>
+
+### add_tool_status
+
+```python
+def add_tool_status(self, status_message: str):
+```
+
+Add a tool status message.
+
+<a id="camel.agents.chat_agent._StreamContentAccumulator.get_full_content"></a>
+
+### get_full_content
+
+```python
+def get_full_content(self):
+```
+
+Get the complete accumulated content.
+
+<a id="camel.agents.chat_agent._StreamContentAccumulator.get_content_with_new_status"></a>
+
+### get_content_with_new_status
+
+```python
+def get_content_with_new_status(self, status_message: str):
+```
+
+Get content with a new status message appended.
+
+<a id="camel.agents.chat_agent._StreamContentAccumulator.reset_streaming_content"></a>
+
+### reset_streaming_content
+
+```python
+def reset_streaming_content(self):
+```
+
+Reset only the streaming content, keep base and tool status.
diff --git a/docs/mintlify/reference/camel.models.azure_openai_model.mdx b/docs/mintlify/reference/camel.models.azure_openai_model.mdx
index eecf690b5..f27231d0d 100644
--- a/docs/mintlify/reference/camel.models.azure_openai_model.mdx
+++ b/docs/mintlify/reference/camel.models.azure_openai_model.mdx
@@ -87,6 +87,8 @@ Runs inference of Azure OpenAI chat completion.
Union[ChatCompletion, Stream[ChatCompletionChunk]]:
`ChatCompletion` in the non-stream mode, or
`Stream[ChatCompletionChunk]` in the stream mode.
+`ChatCompletionStreamManager[BaseModel]` for
+structured output streaming.
<a id="camel.models.azure_openai_model.AzureOpenAIModel._request_chat_completion"></a>
@@ -113,6 +115,23 @@ def _request_parse(
):
```
+<a id="camel.models.azure_openai_model.AzureOpenAIModel._request_stream_parse"></a>
+
+### _request_stream_parse
+
+```python
+def _request_stream_parse(
+ self,
+ messages: List[OpenAIMessage],
+ response_format: Type[BaseModel],
+ tools: Optional[List[Dict[str, Any]]] = None
+):
+```
+
+Request streaming structured output parsing.
+
+Note: This uses OpenAI's beta streaming API for structured outputs.
+
<a id="camel.models.azure_openai_model.AzureOpenAIModel.check_model_config"></a>
### check_model_config
diff --git a/docs/mintlify/reference/camel.models.base_model.mdx b/docs/mintlify/reference/camel.models.base_model.mdx
index 658bf2cfd..d6db74e5f 100644
--- a/docs/mintlify/reference/camel.models.base_model.mdx
+++ b/docs/mintlify/reference/camel.models.base_model.mdx
@@ -148,6 +148,21 @@ def _run(
):
```
+Runs the query to the backend model in a non-stream mode.
+
+**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], Any]:
+`ChatCompletion` in the non-stream mode, or
+`Stream[ChatCompletionChunk]` in the stream mode,
+or other stream managers for structured output.
+
<a id="camel.models.base_model.BaseModelBackend.run"></a>
### run
@@ -171,9 +186,10 @@ Runs the query to the backend model.
**Returns:**
- Union[ChatCompletion, Stream[ChatCompletionChunk]]:
-`ChatCompletion` in the non-stream mode, or
-`Stream[ChatCompletionChunk]` in the stream mode.
+ Union[ChatCompletion, Stream[ChatCompletionChunk], Any]:
+`ChatCompletion` in the non-stream mode,
+`Stream[ChatCompletionChunk]` in the stream mode, or
+other stream managers for structured output.
<a id="camel.models.base_model.BaseModelBackend.check_model_config"></a>
diff --git a/docs/mintlify/reference/camel.models.openai_compatible_model.mdx b/docs/mintlify/reference/camel.models.openai_compatible_model.mdx
index 6d432901a..fe86349f6 100644
--- a/docs/mintlify/reference/camel.models.openai_compatible_model.mdx
+++ b/docs/mintlify/reference/camel.models.openai_compatible_model.mdx
@@ -64,6 +64,8 @@ Runs inference of OpenAI chat completion.
Union[ChatCompletion, Stream[ChatCompletionChunk]]:
`ChatCompletion` in the non-stream mode, or
`Stream[ChatCompletionChunk]` in the stream mode.
+`ChatCompletionStreamManager[BaseModel]` for
+structured output streaming.
<a id="camel.models.openai_compatible_model.OpenAICompatibleModel._request_chat_completion"></a>
@@ -90,6 +92,23 @@ def _request_parse(
):
```
+<a id="camel.models.openai_compatible_model.OpenAICompatibleModel._request_stream_parse"></a>
+
+### _request_stream_parse
+
+```python
+def _request_stream_parse(
+ self,
+ messages: List[OpenAIMessage],
+ response_format: Type[BaseModel],
+ tools: Optional[List[Dict[str, Any]]] = None
+):
+```
+
+Request streaming structured output parsing.
+
+Note: This uses OpenAI's beta streaming API for structured outputs.
+
<a id="camel.models.openai_compatible_model.OpenAICompatibleModel.token_counter"></a>
### token_counter
diff --git a/docs/mintlify/reference/camel.models.openai_model.mdx b/docs/mintlify/reference/camel.models.openai_model.mdx
index 2a6032e9c..8a6955465 100644
--- a/docs/mintlify/reference/camel.models.openai_model.mdx
+++ b/docs/mintlify/reference/camel.models.openai_model.mdx
@@ -104,9 +104,12 @@ Runs inference of OpenAI chat completion.
**Returns:**
- Union[ChatCompletion, Stream[ChatCompletionChunk]]:
-`ChatCompletion` in the non-stream mode, or
-`Stream[ChatCompletionChunk]` in the stream mode.
+ Union[ChatCompletion, Stream[ChatCompletionChunk],
+ChatCompletionStreamManager[BaseModel]]:
+`ChatCompletion` in the non-stream mode,
+`Stream[ChatCompletionChunk]`in the stream mode,
+or `ChatCompletionStreamManager[BaseModel]` for
+structured output streaming.
<a id="camel.models.openai_model.OpenAIModel._request_chat_completion"></a>
@@ -133,6 +136,23 @@ def _request_parse(
):
```
+<a id="camel.models.openai_model.OpenAIModel._request_stream_parse"></a>
+
+### _request_stream_parse
+
+```python
+def _request_stream_parse(
+ self,
+ messages: List[OpenAIMessage],
+ response_format: Type[BaseModel],
+ tools: Optional[List[Dict[str, Any]]] = None
+):
+```
+
+Request streaming structured output parsing.
+
+Note: This uses OpenAI's beta streaming API for structured outputs.
+
<a id="camel.models.openai_model.OpenAIModel.check_model_config"></a>
### check_model_config
diff --git a/examples/agents/chatagent_stream.py b/examples/agents/chatagent_stream.py
new file mode 100644
index 000000000..f020c5b44
--- /dev/null
+++ b/examples/agents/chatagent_stream.py
@@ -0,0 +1,292 @@
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+import asyncio
+import time
+
+from pydantic import BaseModel, Field
+
+from camel.agents import ChatAgent
+from camel.models import ModelFactory
+from camel.toolkits import FunctionTool
+from camel.types import ModelPlatformType, ModelType
+
+# Create a streaming model
+streaming_model = ModelFactory.create(
+ model_platform=ModelPlatformType.OPENAI,
+ model_type=ModelType.GPT_4O_MINI,
+ model_config_dict={
+ "stream": True,
+ },
+)
+
+
+# Define structured output model
+class Thinking(BaseModel):
+ think: str = Field(description="Your thinking process")
+ answer: str = Field(description="Your answer")
+
+
+def get_weather(city: str) -> str:
+ r"""Get weather information for a city"""
+ time.sleep(1) # Simulate some processing time
+ return f"The weather in {city} is sunny, with a temperature of 22°C."
+
+
+def slow_calculation(n: int) -> str:
+ r"""Perform a slow calculation"""
+ time.sleep(3) # Simulate slow calculation
+ result = n * n
+ return f"The square of {n} is {result}"
+
+
+def fast_lookup(word: str) -> str:
+ r"""Perform a fast lookup"""
+ time.sleep(0.5) # Simulate fast lookup
+ return f"Definition of '{word}': a sample definition"
+
+
+def test_content_accumulation():
+ r"""Test that content accumulation works correctly"""
+ print("=== Testing Content Accumulation Fix ===")
+
+ agent = ChatAgent(
+ system_message="You are a helpful assistant.",
+ model=streaming_model,
+ )
+
+ query = "Say hello to me"
+ print(f"Query: {query}")
+ print("Checking content accumulation:")
+
+ previous_content = ""
+
+ for i, response in enumerate(agent.step(query)):
+ if response.msgs:
+ current_content = response.msgs[0].content
+
+ # Verify that current content always contains all previous content
+ if not current_content.startswith(previous_content):
+ print(f"❌ CONTENT ACCUMULATION ERROR at response {i}:")
+ print(f"Previous: '{previous_content}'")
+ print(f"Current: '{current_content}'")
+ print("Current content should contain all previous content!")
+ return False
+
+ # Only print new content
+ new_content = current_content[len(previous_content) :]
+ if new_content:
+ print(new_content, end="", flush=True)
+
+ previous_content = current_content
+
+ print("\n✅ Content accumulation test passed!")
+ print("\n" + "=" * 50)
+ return True
+
+
+async def test_async_tool_execution():
+ r"""Test async tool execution with proper content accumulation"""
+ print("\n=== Testing Async Tool Execution ===")
+
+ agent = ChatAgent(
+ system_message="You are a helpful assistant who can perform calculations and lookups.", # noqa: E501
+ model=streaming_model,
+ tools=[
+ FunctionTool(slow_calculation),
+ FunctionTool(fast_lookup),
+ FunctionTool(get_weather),
+ ],
+ )
+
+ query = "Calculate the square of 5, look up the word 'sync', and get weather for Shanghai" # noqa: E501
+ print(f"Query: {query}")
+ print("Testing async execution and content accumulation:")
+
+ previous_content = ""
+
+ async for response in agent.astep(query):
+ if response.msgs:
+ current_content = response.msgs[0].content
+
+ # Verify content accumulation
+ if not current_content.startswith(previous_content):
+ print("❌ ASYNC CONTENT ACCUMULATION ERROR:")
+ print(f"Previous: '{previous_content}'")
+ print(f"Current: '{current_content}'")
+ return False
+
+ # Only print new content
+ new_content = current_content[len(previous_content) :]
+ if new_content:
+ print(new_content, end="", flush=True)
+
+ previous_content = current_content
+
+ print("\n" + "=" * 50)
+ return True
+
+
+def test_sync_tool_execution():
+ r"""Test sync tool execution with proper content accumulation"""
+ print("\n=== Testing Sync Tool Execution ===")
+
+ agent = ChatAgent(
+ system_message="You are a helpful assistant who can perform calculations and lookups.", # noqa: E501
+ model=streaming_model,
+ tools=[
+ FunctionTool(slow_calculation),
+ FunctionTool(fast_lookup),
+ FunctionTool(get_weather),
+ ],
+ )
+
+ query = "Calculate the square of 5, look up the word 'sync', and get weather for Shanghai" # noqa: E501
+ print(f"Query: {query}")
+ print("Testing sync structured output and content accumulation:")
+
+ previous_content = ""
+
+ for response in agent.step(query):
+ if response.msgs:
+ current_content = response.msgs[0].content
+
+ # Verify content accumulation
+ if not current_content.startswith(previous_content):
+ print("❌ SYNC CONTENT ACCUMULATION ERROR:")
+ print(f"Previous: '{previous_content}'")
+ print(f"Current: '{current_content}'")
+ return False
+
+ # Only print new content
+ new_content = current_content[len(previous_content) :]
+ if new_content:
+ print(new_content, end="", flush=True)
+
+ previous_content = current_content
+
+ print("\n" + "=" * 50)
+ return True
+
+
+def test_sync_structured_output():
+ r"""Test sync structured output"""
+ print("\n=== Testing Sync Structured Output ===")
+
+ agent = ChatAgent(
+ system_message="You are a helpful assistant .", model=streaming_model
+ )
+
+ query = "how many r in strawberry?"
+ print(f"Query: {query}")
+ print("Testing sync structured output and content accumulation:")
+
+ previous_content = ""
+
+ for response in agent.step(query, response_format=Thinking):
+ if response.msgs:
+ current_content = response.msgs[0].content
+
+ # Verify content accumulation
+ if not current_content.startswith(previous_content):
+ print("❌ SYNC CONTENT ACCUMULATION ERROR:")
+ print(f"Previous: '{previous_content}'")
+ print(f"Current: '{current_content}'")
+ return False
+
+ # Only print new content
+ new_content = current_content[len(previous_content) :]
+ if new_content:
+ print(new_content, end="", flush=True)
+
+ previous_content = current_content
+
+ print("\n" + "=" * 50)
+ return True
+
+
+async def test_async_structured_output():
+ r"""Test async structured output"""
+ print("\n=== Testing Async Structured Output ===")
+
+ agent = ChatAgent(
+ system_message="You are a helpful assistant .", model=streaming_model
+ )
+
+ query = "how many r in strawberry?"
+ print(f"Query: {query}")
+ print("Testing async structured output and content accumulation:")
+
+ previous_content = ""
+
+ async for response in agent.astep(query, response_format=Thinking):
+ if response.msgs:
+ current_content = response.msgs[0].content
+
+ # Verify content accumulation
+ if not current_content.startswith(previous_content):
+ print("❌ ASYNC CONTENT ACCUMULATION ERROR:")
+ print(f"Previous: '{previous_content}'")
+ print(f"Current: '{current_content}'")
+ return False
+
+ # Only print new content
+ new_content = current_content[len(previous_content) :]
+ if new_content:
+ print(new_content, end="", flush=True)
+
+ previous_content = current_content
+
+ print("\n" + "=" * 50)
+ return True
+
+
+async def run_all_tests():
+ r"""Run all tests"""
+ print("🧪 Running Content Accumulation and Tool Execution Tests\n")
+
+ # Test basic content accumulation
+ if not test_content_accumulation():
+ print("❌ Basic content accumulation test failed!")
+ return
+
+ # # Test sync tool execution
+ if not test_sync_tool_execution():
+ print("❌ Sync tool execution test failed!")
+ return
+
+ # Test async tool execution
+ if not await test_async_tool_execution():
+ print("❌ Async tool execution test failed!")
+ return
+
+ # Test sync structured output
+ if not test_sync_structured_output():
+ print("❌ Sync structured output test failed!")
+ return
+
+ # Test async structured output
+
+ if not await test_async_structured_output():
+ print("❌ Async structured output test failed!")
+ return
+
+
+if __name__ == "__main__":
+ try:
+ asyncio.run(run_all_tests())
+ except Exception as e:
+ print(f"Test error: {e}")
+ import traceback
+
+ traceback.print_exc()
diff --git a/pyproject.toml b/pyproject.toml
index c9599cae5..c221a1666 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
[project]
name = "camel-ai"
-version = "0.2.71a4"
+version = "0.2.71a5"
description = "Communicative Agents for AI Society Study"
authors = [{ name = "CAMEL-AI.org" }]
requires-python = ">=3.10,<3.13"
diff --git a/test/agents/test_repo_agent.py b/test/agents/test_repo_agent.py
index cd45c813f..62fa1e497 100644
--- a/test/agents/test_repo_agent.py
+++ b/test/agents/test_repo_agent.py
@@ -25,6 +25,7 @@ from camel.agents.repo_agent import (
)
from camel.messages import BaseMessage
from camel.models import BaseModelBackend
+from camel.responses import ChatAgentResponse
from camel.types import ModelType
# Create mock Github module
@@ -286,13 +287,16 @@ def test_step_in_rag_mode(mock_vector_retriever):
# Mock the super().step() method
with patch('camel.agents.repo_agent.ChatAgent.step') as mock_step:
- mock_step.return_value = "mocked response"
+ # Create a proper ChatAgentResponse mock
+ mock_response = MagicMock(spec=ChatAgentResponse)
+ mock_step.return_value = mock_response
# Act - Call the step method with a test message
- agent.step("Test query")
+ result = agent.step("Test query")
# Assert
assert mock_step.called
+ assert result == mock_response
# Check that the input was augmented with retrieved content
call_args = mock_step.call_args[0][0]
assert isinstance(call_args, BaseMessage)
diff --git a/uv.lock b/uv.lock
index 5d4891edc..2d6b22312 100644
--- a/uv.lock
+++ b/uv.lock
@@ -167,14 +167,15 @@ wheels = [
[[package]]
name = "aiosignal"
-version = "1.3.2"
+version = "1.4.0"
source = { registry = "https://pypi.org/simple" }
dependencies = [
{ name = "frozenlist" },
+ { name = "typing-extensions" },
]
-sdist = { url = "https://files.pythonhosted.org/packages/ba/b5/6d55e80f6d8a08ce22b982eafa278d823b541c925f11ee774b0b9c43473d/aiosignal-1.3.2.tar.gz", hash = "sha256:a8c255c66fafb1e499c9351d0bf32ff2d8a0321595ebac3b93713656d2436f54", size = 19424, upload-time = "2024-12-13T17:10:40.86Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/61/62/06741b579156360248d1ec624842ad0edf697050bbaf7c3e46394e106ad1/aiosignal-1.4.0.tar.gz", hash = "sha256:f47eecd9468083c2029cc99945502cb7708b082c232f9aca65da147157b251c7", size = 25007, upload-time = "2025-07-03T22:54:43.528Z" }
wheels = [
- { url = "https://files.pythonhosted.org/packages/ec/6a/bc7e17a3e87a2985d3e8f4da4cd0f481060eb78fb08596c42be62c90a4d9/aiosignal-1.3.2-py2.py3-none-any.whl", hash = "sha256:45cde58e409a301715980c2b01d0c28bdde3770d8290b5eb2173759d9acb31a5", size = 7597, upload-time = "2024-12-13T17:10:38.469Z" },
+ { url = "https://files.pythonhosted.org/packages/fb/76/641ae371508676492379f16e2fa48f4e2c11741bd63c48be4b12a6b09cba/aiosignal-1.4.0-py3-none-any.whl", hash = "sha256:053243f8b92b990551949e63930a839ff0cf0b0ebbe0597b0f3fb19e1a0fe82e", size = 7490, upload-time = "2025-07-03T22:54:42.156Z" },
]
[[package]]
@@ -341,14 +342,14 @@ wheels = [
[[package]]
name = "asgiref"
-version = "3.8.1"
+version = "3.9.0"
source = { registry = "https://pypi.org/simple" }
dependencies = [
{ name = "typing-extensions", marker = "python_full_version < '3.11'" },
]
-sdist = { url = "https://files.pythonhosted.org/packages/29/38/b3395cc9ad1b56d2ddac9970bc8f4141312dbaec28bc7c218b0dfafd0f42/asgiref-3.8.1.tar.gz", hash = "sha256:c343bd80a0bec947a9860adb4c432ffa7db769836c64238fc34bdc3fec84d590", size = 35186, upload-time = "2024-03-22T14:39:36.863Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/6a/68/fb4fb78c9eac59d5e819108a57664737f855c5a8e9b76aec1738bb137f9e/asgiref-3.9.0.tar.gz", hash = "sha256:3dd2556d0f08c4fab8a010d9ab05ef8c34565f6bf32381d17505f7ca5b273767", size = 36772, upload-time = "2025-07-03T13:25:01.491Z" }
wheels = [
- { url = "https://files.pythonhosted.org/packages/39/e3/893e8757be2612e6c266d9bb58ad2e3651524b5b40cf56761e985a28b13e/asgiref-3.8.1-py3-none-any.whl", hash = "sha256:3e1e3ecc849832fe52ccf2cb6686b7a55f82bb1d6aee72a58826471390335e47", size = 23828, upload-time = "2024-03-22T14:39:34.521Z" },
+ { url = "https://files.pythonhosted.org/packages/3d/f9/76c9f4d4985b5a642926162e2d41fe6019b1fa929cfa58abb7d2dc9041e5/asgiref-3.9.0-py3-none-any.whl", hash = "sha256:06a41250a0114d2b6f6a2cb3ab962147d355b53d1de15eebc34a9d04a7b79981", size = 23788, upload-time = "2025-07-03T13:24:59.115Z" },
]
[[package]]
@@ -410,51 +411,51 @@ wheels = [
[[package]]
name = "av"
-version = "14.4.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/86/f6/0b473dab52dfdea05f28f3578b1c56b6c796ce85e76951bab7c4e38d5a74/av-14.4.0.tar.gz", hash = "sha256:3ecbf803a7fdf67229c0edada0830d6bfaea4d10bfb24f0c3f4e607cd1064b42", size = 3892203, upload-time = "2025-05-16T19:13:35.737Z" }
-wheels = [
- { url = "https://files.pythonhosted.org/packages/34/0f/cf6b888747cd1e10eafc4a28942e5b666417c03c39853818900bdaa86116/av-14.4.0-cp310-cp310-macosx_12_0_arm64.whl", hash = "sha256:10219620699a65b9829cfa08784da2ed38371f1a223ab8f3523f440a24c8381c", size = 19979523, upload-time = "2025-05-16T19:08:59.751Z" },
- { url = "https://files.pythonhosted.org/packages/45/30/8f09ac71ad23344ff247f16a9229b36b1e2a36214fd56ba55df885e9bf85/av-14.4.0-cp310-cp310-macosx_12_0_x86_64.whl", hash = "sha256:8bac981fde1c05e231df9f73a06ed9febce1f03fb0f1320707ac2861bba2567f", size = 23765838, upload-time = "2025-05-16T19:09:02.362Z" },
- { url = "https://files.pythonhosted.org/packages/a2/57/e0c30ceb1e59e7b2b88c9cd6bf79a0a979128de19a94b300a700d3a7ca52/av-14.4.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cc634ed5bdeb362f0523b73693b079b540418d35d7f3003654f788ae6c317eef", size = 33122039, upload-time = "2025-05-16T19:09:04.729Z" },
- { url = "https://files.pythonhosted.org/packages/c6/a7/9b3064c49f2d2219ee1b895cc77fca18c84d6121b51c8ce6b7f618a2661b/av-14.4.0-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:23973ed5c5bec9565094d2b3643f10a6996707ddffa5252e112d578ad34aa9ae", size = 31758563, upload-time = "2025-05-16T19:09:07.679Z" },
- { url = "https://files.pythonhosted.org/packages/23/42/0eafe0de75de6a0db71add8e4ea51ebf090482bad3068f4a874c90fbd110/av-14.4.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0655f7207db6a211d7cedb8ac6a2f7ccc9c4b62290130e393a3fd99425247311", size = 34750358, upload-time = "2025-05-16T19:09:10.932Z" },
- { url = "https://files.pythonhosted.org/packages/75/33/5430ba9ad73036f2d69395d36f3d57b261c51db6f6542bcfc60087640bb7/av-14.4.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:1edaab73319bfefe53ee09c4b1cf7b141ea7e6678a0a1c62f7bac1e2c68ec4e7", size = 35793636, upload-time = "2025-05-16T19:09:13.726Z" },
- { url = "https://files.pythonhosted.org/packages/00/a9/d8c07f0ab69be05a4939719d7a31dc3e9fb112ee8ec6c9411a6c9c085f0a/av-14.4.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:b54838fa17c031ffd780df07b9962fac1be05220f3c28468f7fe49474f1bf8d2", size = 34123666, upload-time = "2025-05-16T19:09:16.968Z" },
- { url = "https://files.pythonhosted.org/packages/48/e1/2f2f607553f2ac6369e5fc814e77b41f9ceb285ce9d8c02c9ee034b8b6db/av-14.4.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:f4b59ac6c563b9b6197299944145958a8ec34710799fd851f1a889b0cbcd1059", size = 36756157, upload-time = "2025-05-16T19:09:21.447Z" },
- { url = "https://files.pythonhosted.org/packages/d7/f0/d653d4eaa7e68732f8c0013aee40f31ff0cd49e90fdec89cca6c193db207/av-14.4.0-cp310-cp310-win_amd64.whl", hash = "sha256:a0192a584fae9f6cedfac03c06d5bf246517cdf00c8779bc33414404796a526e", size = 27931039, upload-time = "2025-05-16T19:09:24.739Z" },
- { url = "https://files.pythonhosted.org/packages/18/8a/d57418b686ffd05fabd5a0a9cfa97e63b38c35d7101af00e87c51c8cc43c/av-14.4.0-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:5b21d5586a88b9fce0ab78e26bd1c38f8642f8e2aad5b35e619f4d202217c701", size = 19965048, upload-time = "2025-05-16T19:09:27.419Z" },
- { url = "https://files.pythonhosted.org/packages/f5/aa/3f878b0301efe587e9b07bb773dd6b47ef44ca09a3cffb4af50c08a170f3/av-14.4.0-cp311-cp311-macosx_12_0_x86_64.whl", hash = "sha256:cf8762d90b0f94a20c9f6e25a94f1757db5a256707964dfd0b1d4403e7a16835", size = 23750064, upload-time = "2025-05-16T19:09:30.012Z" },
- { url = "https://files.pythonhosted.org/packages/9a/b4/6fe94a31f9ed3a927daa72df67c7151968587106f30f9f8fcd792b186633/av-14.4.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c0ac9f08920c7bbe0795319689d901e27cb3d7870b9a0acae3f26fc9daa801a6", size = 33648775, upload-time = "2025-05-16T19:09:33.811Z" },
- { url = "https://files.pythonhosted.org/packages/6c/f3/7f3130753521d779450c935aec3f4beefc8d4645471159f27b54e896470c/av-14.4.0-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a56d9ad2afdb638ec0404e962dc570960aae7e08ae331ad7ff70fbe99a6cf40e", size = 32216915, upload-time = "2025-05-16T19:09:36.99Z" },
- { url = "https://files.pythonhosted.org/packages/f8/9a/8ffabfcafb42154b4b3a67d63f9b69e68fa8c34cb39ddd5cb813dd049ed4/av-14.4.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6bed513cbcb3437d0ae47743edc1f5b4a113c0b66cdd4e1aafc533abf5b2fbf2", size = 35287279, upload-time = "2025-05-16T19:09:39.711Z" },
- { url = "https://files.pythonhosted.org/packages/ad/11/7023ba0a2ca94a57aedf3114ab8cfcecb0819b50c30982a4c5be4d31df41/av-14.4.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d030c2d3647931e53d51f2f6e0fcf465263e7acf9ec6e4faa8dbfc77975318c3", size = 36294683, upload-time = "2025-05-16T19:09:42.668Z" },
- { url = "https://files.pythonhosted.org/packages/3d/fa/b8ac9636bd5034e2b899354468bef9f4dadb067420a16d8a493a514b7817/av-14.4.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:1cc21582a4f606271d8c2036ec7a6247df0831050306c55cf8a905701d0f0474", size = 34552391, upload-time = "2025-05-16T19:09:46.852Z" },
- { url = "https://files.pythonhosted.org/packages/fb/29/0db48079c207d1cba7a2783896db5aec3816e17de55942262c244dffbc0f/av-14.4.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ce7c9cd452153d36f1b1478f904ed5f9ab191d76db873bdd3a597193290805d4", size = 37265250, upload-time = "2025-05-16T19:09:50.013Z" },
- { url = "https://files.pythonhosted.org/packages/1c/55/715858c3feb7efa4d667ce83a829c8e6ee3862e297fb2b568da3f968639d/av-14.4.0-cp311-cp311-win_amd64.whl", hash = "sha256:fd261e31cc6b43ca722f80656c39934199d8f2eb391e0147e704b6226acebc29", size = 27925845, upload-time = "2025-05-16T19:09:52.663Z" },
- { url = "https://files.pythonhosted.org/packages/a6/75/b8641653780336c90ba89e5352cac0afa6256a86a150c7703c0b38851c6d/av-14.4.0-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:a53e682b239dd23b4e3bc9568cfb1168fc629ab01925fdb2e7556eb426339e94", size = 19954125, upload-time = "2025-05-16T19:09:54.909Z" },
- { url = "https://files.pythonhosted.org/packages/99/e6/37fe6fa5853a48d54d749526365780a63a4bc530be6abf2115e3a21e292a/av-14.4.0-cp312-cp312-macosx_12_0_x86_64.whl", hash = "sha256:5aa0b901751a32703fa938d2155d56ce3faf3630e4a48d238b35d2f7e49e5395", size = 23751479, upload-time = "2025-05-16T19:09:57.113Z" },
- { url = "https://files.pythonhosted.org/packages/f7/75/9a5f0e6bda5f513b62bafd1cff2b495441a8b07ab7fb7b8e62f0c0d1683f/av-14.4.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a3b316fed3597675fe2aacfed34e25fc9d5bb0196dc8c0b014ae5ed4adda48de", size = 33801401, upload-time = "2025-05-16T19:09:59.479Z" },
- { url = "https://files.pythonhosted.org/packages/6a/c9/e4df32a2ad1cb7f3a112d0ed610c5e43c89da80b63c60d60e3dc23793ec0/av-14.4.0-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a587b5c5014c3c0e16143a0f8d99874e46b5d0c50db6111aa0b54206b5687c81", size = 32364330, upload-time = "2025-05-16T19:10:02.111Z" },
- { url = "https://files.pythonhosted.org/packages/ca/f0/64e7444a41817fde49a07d0239c033f7e9280bec4a4bb4784f5c79af95e6/av-14.4.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:10d53f75e8ac1ec8877a551c0db32a83c0aaeae719d05285281eaaba211bbc30", size = 35519508, upload-time = "2025-05-16T19:10:05.008Z" },
- { url = "https://files.pythonhosted.org/packages/c2/a8/a370099daa9033a3b6f9b9bd815304b3d8396907a14d09845f27467ba138/av-14.4.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:c8558cfde79dd8fc92d97c70e0f0fa8c94c7a66f68ae73afdf58598f0fe5e10d", size = 36448593, upload-time = "2025-05-16T19:10:07.887Z" },
- { url = "https://files.pythonhosted.org/packages/27/bb/edb6ceff8fa7259cb6330c51dbfbc98dd1912bd6eb5f7bc05a4bb14a9d6e/av-14.4.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:455b6410dea0ab2d30234ffb28df7d62ca3cdf10708528e247bec3a4cdcced09", size = 34701485, upload-time = "2025-05-16T19:10:10.886Z" },
- { url = "https://files.pythonhosted.org/packages/a7/8a/957da1f581aa1faa9a5dfa8b47ca955edb47f2b76b949950933b457bfa1d/av-14.4.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:1661efbe9d975f927b8512d654704223d936f39016fad2ddab00aee7c40f412c", size = 37521981, upload-time = "2025-05-16T19:10:13.678Z" },
- { url = "https://files.pythonhosted.org/packages/28/76/3f1cf0568592f100fd68eb40ed8c491ce95ca3c1378cc2d4c1f6d1bd295d/av-14.4.0-cp312-cp312-win_amd64.whl", hash = "sha256:fbbeef1f421a3461086853d6464ad5526b56ffe8ccb0ab3fd0a1f121dfbf26ad", size = 27925944, upload-time = "2025-05-16T19:10:16.485Z" },
+version = "15.0.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/17/89/940a509ee7e9449f0c877fa984b37b7cc485546035cc67bbc353f2ac20f3/av-15.0.0.tar.gz", hash = "sha256:871c1a9becddf00b60b1294dc0bff9ff193ac31286aeec1a34039bd27e650183", size = 3833128, upload-time = "2025-07-03T16:23:48.455Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/de/c6/4646aeffca77fb9e557509528341fdef409f7e5de44c70858fb639bb9a3e/av-15.0.0-cp310-cp310-macosx_13_0_arm64.whl", hash = "sha256:f20c7565ad9aed8a5e3ca7ed30b151d4d8a937e072b6a4901c3200134fe7c68b", size = 21808084, upload-time = "2025-07-03T16:21:17.028Z" },
+ { url = "https://files.pythonhosted.org/packages/89/a2/8a0349e2ebf998f2305b61365240a748bc137f94f431e769c2ac83c5a321/av-15.0.0-cp310-cp310-macosx_13_0_x86_64.whl", hash = "sha256:0d8b78a88f0fdaf6591bca32b41301e40ba60be294b0698318948c4d1fa6f206", size = 26989279, upload-time = "2025-07-03T16:21:20.63Z" },
+ { url = "https://files.pythonhosted.org/packages/de/f7/2e3b9cc831a1891914ca09aaeac88195f36f24a22f8c18e57637604a8ef1/av-15.0.0-cp310-cp310-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:5d14f6cea6c4966d5478a50555fa92af4948f83e7843b63b747d4a451c53d4f1", size = 33955236, upload-time = "2025-07-03T16:21:23.752Z" },
+ { url = "https://files.pythonhosted.org/packages/23/fa/cc4e32d85d6e765f9e9c2680ce9bee6a4d66c8a069f136322be04a66e70d/av-15.0.0-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:09f516947890dcf27482af2f0f7b31a579dbd11d5566dd74ce5f1f6396c452b7", size = 37681552, upload-time = "2025-07-03T16:21:27.265Z" },
+ { url = "https://files.pythonhosted.org/packages/f9/e3/438e1095c064fd21f1325ddae9383b4bcdc8f8493247144ed15bc1b931a2/av-15.0.0-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:908e2fb4358210a463f81e2dbfac77d5977cc53a400fea3f6decef6f9f9267e4", size = 39179769, upload-time = "2025-07-03T16:21:31.941Z" },
+ { url = "https://files.pythonhosted.org/packages/b7/b7/e6c27a8bd75e3eede07c1ce888fc1aa6293ba35393d2f4adc1d2e41d563b/av-15.0.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:911fe092b1c75c35d3e9d836b750ff725599a343b6126449cb2c1b4aa8ac2792", size = 39725200, upload-time = "2025-07-03T16:21:35.73Z" },
+ { url = "https://files.pythonhosted.org/packages/d1/42/06e91b07c77465af1b845ac5cf83be1b4cbe042fd940509ae3c5ad70e386/av-15.0.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:25743a08b674596f3b993392259a4953a445b4211796d168c992174c983b76f0", size = 36639563, upload-time = "2025-07-03T16:21:39.395Z" },
+ { url = "https://files.pythonhosted.org/packages/f8/d6/92aafdd8ef420100aca3503b7772ca2484d3688b83b09ca6f96bfb47b7c1/av-15.0.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:2ecd5df62b9697a9304a084fbfed13fa890ec9ba2f647aaed35dca291991c7b1", size = 40482430, upload-time = "2025-07-03T16:21:42.671Z" },
+ { url = "https://files.pythonhosted.org/packages/41/1a/22d7b2a151d4aeff6a1fb530e25c8d677dd59580418cab4a95c4628d5009/av-15.0.0-cp310-cp310-win_amd64.whl", hash = "sha256:7156d1b326e328aaba7f10a0d89bec53d087aba16f4c5c7ae13890b9eefde972", size = 31363168, upload-time = "2025-07-03T16:21:45.809Z" },
+ { url = "https://files.pythonhosted.org/packages/e5/2a/40e0ec34e8235e4a1f9fe60288cd1eebe6413765931b5b74aeb3ce79c422/av-15.0.0-cp311-cp311-macosx_13_0_arm64.whl", hash = "sha256:eb19386466aafbac4ede549ed7dc6198714e8d35ecc238d5b5c0d91e770d53d4", size = 21793541, upload-time = "2025-07-03T16:21:48.819Z" },
+ { url = "https://files.pythonhosted.org/packages/7d/21/74acec5492a901699a94715e94cb83772679b92183592a3d8b3e58cf0202/av-15.0.0-cp311-cp311-macosx_13_0_x86_64.whl", hash = "sha256:e3c841befff26823524f3260d29fb3162540535c43238587b24226d345c82af3", size = 26973175, upload-time = "2025-07-03T16:21:51.63Z" },
+ { url = "https://files.pythonhosted.org/packages/7b/d9/04e7fc09c6246aaf8e695620cc026779e366c49dcab561f8f434fbed3256/av-15.0.0-cp311-cp311-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:fe50ddab68af27bb9f7123dac5b1ff43ee8c7d941499c625018f3cac7da01ff3", size = 34423925, upload-time = "2025-07-03T16:21:54.628Z" },
+ { url = "https://files.pythonhosted.org/packages/19/e0/f4a93c901d65188ffe21e182499abf5304403f47e24da001b21042c888ec/av-15.0.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:5877f9dacf04bba9e966e0feb707e0fc2955476dc50cc6de5707604f51440e1b", size = 38178587, upload-time = "2025-07-03T16:21:57.966Z" },
+ { url = "https://files.pythonhosted.org/packages/ed/64/6dcfb449ed287a590ecf70d6259f1f2c06fa9a576996f53d1949d65c4ee5/av-15.0.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:e2a5f0d1817ab73370fdb35e2e2ecd4c2e5a45d43b8d96d5ae8dfe86098fb9b3", size = 39683188, upload-time = "2025-07-03T16:22:01.315Z" },
+ { url = "https://files.pythonhosted.org/packages/a9/ef/a89775afc0487a4f5ab892b423972ae47bd3ef004faeb666135c657ea308/av-15.0.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:710ad0307da524be553db123c0681edadb5cefc15baa49cf25217364fb7a80b5", size = 40230243, upload-time = "2025-07-03T16:22:04.811Z" },
+ { url = "https://files.pythonhosted.org/packages/35/4b/39c40ce50c7290b5091afe75264c31bb1afb53e918c16991c808131a5d27/av-15.0.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:d275d3015ab13aadc7bf38df3b2398ad992e30b1685cd350fd46c71913e98af4", size = 37059511, upload-time = "2025-07-03T16:22:09.216Z" },
+ { url = "https://files.pythonhosted.org/packages/d3/39/947815be601b2dc9f43ea59fc5582cb7125070ef352cb0157ea29b98b796/av-15.0.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:5b300f824a7ca1854ca29a37265281fa07d3dd0f69a6d2ff55d4c54ee3d734e2", size = 40993811, upload-time = "2025-07-03T16:22:12.524Z" },
+ { url = "https://files.pythonhosted.org/packages/de/ca/0c77802f70248bc3e182451a174db30fca349858840c4fbf1c7f8e1beaa0/av-15.0.0-cp311-cp311-win_amd64.whl", hash = "sha256:cb7a85b4fe853a9c2725cdf02f457221fcc24f0391c8333b25a3a889e16ff26d", size = 31358970, upload-time = "2025-07-03T16:22:15.78Z" },
+ { url = "https://files.pythonhosted.org/packages/89/81/c5d009ea9c01a513b7af6aac2ac49c0f2f7193345071cd6dd4d91bef3ab9/av-15.0.0-cp312-cp312-macosx_13_0_arm64.whl", hash = "sha256:84e2ede9459e64e768f4bc56d9df65da9e94b704ee3eccfe2e5b1da1da754313", size = 21782026, upload-time = "2025-07-03T16:22:18.41Z" },
+ { url = "https://files.pythonhosted.org/packages/16/8a/ffe9fcac35a07efc6aa0d765015efa499d88823c01499f318760460f8088/av-15.0.0-cp312-cp312-macosx_13_0_x86_64.whl", hash = "sha256:9473ed92d6942c5a449a2c79d49f3425eb0272499d1a3559b32c1181ff736a08", size = 26974939, upload-time = "2025-07-03T16:22:21.493Z" },
+ { url = "https://files.pythonhosted.org/packages/a0/e7/0816e52134dc2d0259bb1aaad78573eacaf2bebc1a643de34e3384b520d6/av-15.0.0-cp312-cp312-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:56a53fe4e09bebd99355eaa0ce221b681eaf205bdda114f5e17fb79f3c3746ad", size = 34573486, upload-time = "2025-07-03T16:22:24.684Z" },
+ { url = "https://files.pythonhosted.org/packages/a3/f4/07cc05712e9824a4bb68beea44eb5a7369dee3f00fa258879190004b7fc5/av-15.0.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:247dd9a99d7ed3577b8c1e9977e811f423b04504ff36c9dcd7a4de3e6e5fe5ad", size = 38418908, upload-time = "2025-07-03T16:22:27.799Z" },
+ { url = "https://files.pythonhosted.org/packages/19/48/7f3a21a41e291f8c5b8a98f95cfef308ce1b024a634413ce910c270efd7d/av-15.0.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:fc50a7d5f60109221ccf44f8fa4c56ce73f22948b7f19b1717fcc58f7fbc383e", size = 40010257, upload-time = "2025-07-03T16:22:31.15Z" },
+ { url = "https://files.pythonhosted.org/packages/6d/c9/ced392e82d39084544d2d0c05decb36446028928eddf0d40ec3d8fe6c050/av-15.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:77deaec8943abfebd4e262924f2f452d6594cf0bc67d8d98aac0462b476e4182", size = 40381801, upload-time = "2025-07-03T16:22:34.254Z" },
+ { url = "https://files.pythonhosted.org/packages/d2/73/a23ad111200e27f5773e94b0b6f9e2ea492a72ded7f4787a358d9d504a8b/av-15.0.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:601d9b0740e47a17ec96ba2a537ebfd4d6edc859ae6f298475c06caa51f0a019", size = 37219417, upload-time = "2025-07-03T16:22:37.497Z" },
+ { url = "https://files.pythonhosted.org/packages/45/0c/2ac20143b74e3792ede40bfd397ce72fa4e76a03999c2fd0aee3997b6971/av-15.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e021f67e0db7256c9f5d3d6a2a4237a4a4a804b131b33e7f2778981070519b20", size = 41242077, upload-time = "2025-07-03T16:22:40.86Z" },
+ { url = "https://files.pythonhosted.org/packages/bd/30/40452705dffbfef0f5505d36218970dfeff0a86048689910219c8717b310/av-15.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:383f1b57520d790069d85fc75f43cfa32fca07f5fb3fb842be37bd596638602c", size = 31357617, upload-time = "2025-07-03T16:22:43.934Z" },
]
[[package]]
name = "azure-core"
-version = "1.34.0"
+version = "1.35.0"
source = { registry = "https://pypi.org/simple" }
dependencies = [
{ name = "requests" },
{ name = "six" },
{ name = "typing-extensions" },
]
-sdist = { url = "https://files.pythonhosted.org/packages/c9/29/ff7a519a315e41c85bab92a7478c6acd1cf0b14353139a08caee4c691f77/azure_core-1.34.0.tar.gz", hash = "sha256:bdb544989f246a0ad1c85d72eeb45f2f835afdcbc5b45e43f0dbde7461c81ece", size = 297999, upload-time = "2025-05-01T23:17:27.59Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/ce/89/f53968635b1b2e53e4aad2dd641488929fef4ca9dfb0b97927fa7697ddf3/azure_core-1.35.0.tar.gz", hash = "sha256:c0be528489485e9ede59b6971eb63c1eaacf83ef53001bfe3904e475e972be5c", size = 339689, upload-time = "2025-07-03T00:55:23.496Z" }
wheels = [
- { url = "https://files.pythonhosted.org/packages/84/9e/5c87b49f65bb16571599bc789857d0ded2f53014d3392bc88a5d1f3ad779/azure_core-1.34.0-py3-none-any.whl", hash = "sha256:0615d3b756beccdb6624d1c0ae97284f38b78fb59a2a9839bf927c66fbbdddd6", size = 207409, upload-time = "2025-05-01T23:17:29.818Z" },
+ { url = "https://files.pythonhosted.org/packages/d4/78/bf94897361fdd650850f0f2e405b2293e2f12808239046232bdedf554301/azure_core-1.35.0-py3-none-any.whl", hash = "sha256:8db78c72868a58f3de8991eb4d22c4d368fae226dac1002998d6c50437e7dad1", size = 210708, upload-time = "2025-07-03T00:55:25.238Z" },
]
[[package]]
@@ -646,7 +647,7 @@ wheels = [
[[package]]
name = "camel-ai"
-version = "0.2.71a4"
+version = "0.2.71a5"
source = { editable = "." }
dependencies = [
{ name = "colorama" },
@@ -1664,44 +1665,44 @@ wheels = [
[[package]]
name = "coverage"
-version = "7.9.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/e7/e0/98670a80884f64578f0c22cd70c5e81a6e07b08167721c7487b4d70a7ca0/coverage-7.9.1.tar.gz", hash = "sha256:6cf43c78c4282708a28e466316935ec7489a9c487518a77fa68f716c67909cec", size = 813650, upload-time = "2025-06-13T13:02:28.627Z" }
-wheels = [
- { url = "https://files.pythonhosted.org/packages/c1/78/1c1c5ec58f16817c09cbacb39783c3655d54a221b6552f47ff5ac9297603/coverage-7.9.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:cc94d7c5e8423920787c33d811c0be67b7be83c705f001f7180c7b186dcf10ca", size = 212028, upload-time = "2025-06-13T13:00:29.293Z" },
- { url = "https://files.pythonhosted.org/packages/98/db/e91b9076f3a888e3b4ad7972ea3842297a52cc52e73fd1e529856e473510/coverage-7.9.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:16aa0830d0c08a2c40c264cef801db8bc4fc0e1892782e45bcacbd5889270509", size = 212420, upload-time = "2025-06-13T13:00:34.027Z" },
- { url = "https://files.pythonhosted.org/packages/0e/d0/2b3733412954576b0aea0a16c3b6b8fbe95eb975d8bfa10b07359ead4252/coverage-7.9.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cf95981b126f23db63e9dbe4cf65bd71f9a6305696fa5e2262693bc4e2183f5b", size = 241529, upload-time = "2025-06-13T13:00:35.786Z" },
- { url = "https://files.pythonhosted.org/packages/b3/00/5e2e5ae2e750a872226a68e984d4d3f3563cb01d1afb449a17aa819bc2c4/coverage-7.9.1-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f05031cf21699785cd47cb7485f67df619e7bcdae38e0fde40d23d3d0210d3c3", size = 239403, upload-time = "2025-06-13T13:00:37.399Z" },
- { url = "https://files.pythonhosted.org/packages/37/3b/a2c27736035156b0a7c20683afe7df498480c0dfdf503b8c878a21b6d7fb/coverage-7.9.1-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bb4fbcab8764dc072cb651a4bcda4d11fb5658a1d8d68842a862a6610bd8cfa3", size = 240548, upload-time = "2025-06-13T13:00:39.647Z" },
- { url = "https://files.pythonhosted.org/packages/98/f5/13d5fc074c3c0e0dc80422d9535814abf190f1254d7c3451590dc4f8b18c/coverage-7.9.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:0f16649a7330ec307942ed27d06ee7e7a38417144620bb3d6e9a18ded8a2d3e5", size = 240459, upload-time = "2025-06-13T13:00:40.934Z" },
- { url = "https://files.pythonhosted.org/packages/36/24/24b9676ea06102df824c4a56ffd13dc9da7904478db519efa877d16527d5/coverage-7.9.1-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:cea0a27a89e6432705fffc178064503508e3c0184b4f061700e771a09de58187", size = 239128, upload-time = "2025-06-13T13:00:42.343Z" },
- { url = "https://files.pythonhosted.org/packages/be/05/242b7a7d491b369ac5fee7908a6e5ba42b3030450f3ad62c645b40c23e0e/coverage-7.9.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:e980b53a959fa53b6f05343afbd1e6f44a23ed6c23c4b4c56c6662bbb40c82ce", size = 239402, upload-time = "2025-06-13T13:00:43.634Z" },
- { url = "https://files.pythonhosted.org/packages/73/e0/4de7f87192fa65c9c8fbaeb75507e124f82396b71de1797da5602898be32/coverage-7.9.1-cp310-cp310-win32.whl", hash = "sha256:70760b4c5560be6ca70d11f8988ee6542b003f982b32f83d5ac0b72476607b70", size = 214518, upload-time = "2025-06-13T13:00:45.622Z" },
- { url = "https://files.pythonhosted.org/packages/d5/ab/5e4e2fe458907d2a65fab62c773671cfc5ac704f1e7a9ddd91996f66e3c2/coverage-7.9.1-cp310-cp310-win_amd64.whl", hash = "sha256:a66e8f628b71f78c0e0342003d53b53101ba4e00ea8dabb799d9dba0abbbcebe", size = 215436, upload-time = "2025-06-13T13:00:47.245Z" },
- { url = "https://files.pythonhosted.org/packages/60/34/fa69372a07d0903a78ac103422ad34db72281c9fc625eba94ac1185da66f/coverage-7.9.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:95c765060e65c692da2d2f51a9499c5e9f5cf5453aeaf1420e3fc847cc060582", size = 212146, upload-time = "2025-06-13T13:00:48.496Z" },
- { url = "https://files.pythonhosted.org/packages/27/f0/da1894915d2767f093f081c42afeba18e760f12fdd7a2f4acbe00564d767/coverage-7.9.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:ba383dc6afd5ec5b7a0d0c23d38895db0e15bcba7fb0fa8901f245267ac30d86", size = 212536, upload-time = "2025-06-13T13:00:51.535Z" },
- { url = "https://files.pythonhosted.org/packages/10/d5/3fc33b06e41e390f88eef111226a24e4504d216ab8e5d1a7089aa5a3c87a/coverage-7.9.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:37ae0383f13cbdcf1e5e7014489b0d71cc0106458878ccde52e8a12ced4298ed", size = 245092, upload-time = "2025-06-13T13:00:52.883Z" },
- { url = "https://files.pythonhosted.org/packages/0a/39/7aa901c14977aba637b78e95800edf77f29f5a380d29768c5b66f258305b/coverage-7.9.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:69aa417a030bf11ec46149636314c24c8d60fadb12fc0ee8f10fda0d918c879d", size = 242806, upload-time = "2025-06-13T13:00:54.571Z" },
- { url = "https://files.pythonhosted.org/packages/43/fc/30e5cfeaf560b1fc1989227adedc11019ce4bb7cce59d65db34fe0c2d963/coverage-7.9.1-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0a4be2a28656afe279b34d4f91c3e26eccf2f85500d4a4ff0b1f8b54bf807338", size = 244610, upload-time = "2025-06-13T13:00:56.932Z" },
- { url = "https://files.pythonhosted.org/packages/bf/15/cca62b13f39650bc87b2b92bb03bce7f0e79dd0bf2c7529e9fc7393e4d60/coverage-7.9.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:382e7ddd5289f140259b610e5f5c58f713d025cb2f66d0eb17e68d0a94278875", size = 244257, upload-time = "2025-06-13T13:00:58.545Z" },
- { url = "https://files.pythonhosted.org/packages/cd/1a/c0f2abe92c29e1464dbd0ff9d56cb6c88ae2b9e21becdb38bea31fcb2f6c/coverage-7.9.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:e5532482344186c543c37bfad0ee6069e8ae4fc38d073b8bc836fc8f03c9e250", size = 242309, upload-time = "2025-06-13T13:00:59.836Z" },
- { url = "https://files.pythonhosted.org/packages/57/8d/c6fd70848bd9bf88fa90df2af5636589a8126d2170f3aade21ed53f2b67a/coverage-7.9.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:a39d18b3f50cc121d0ce3838d32d58bd1d15dab89c910358ebefc3665712256c", size = 242898, upload-time = "2025-06-13T13:01:02.506Z" },
- { url = "https://files.pythonhosted.org/packages/c2/9e/6ca46c7bff4675f09a66fe2797cd1ad6a24f14c9c7c3b3ebe0470a6e30b8/coverage-7.9.1-cp311-cp311-win32.whl", hash = "sha256:dd24bd8d77c98557880def750782df77ab2b6885a18483dc8588792247174b32", size = 214561, upload-time = "2025-06-13T13:01:04.012Z" },
- { url = "https://files.pythonhosted.org/packages/a1/30/166978c6302010742dabcdc425fa0f938fa5a800908e39aff37a7a876a13/coverage-7.9.1-cp311-cp311-win_amd64.whl", hash = "sha256:6b55ad10a35a21b8015eabddc9ba31eb590f54adc9cd39bcf09ff5349fd52125", size = 215493, upload-time = "2025-06-13T13:01:05.702Z" },
- { url = "https://files.pythonhosted.org/packages/60/07/a6d2342cd80a5be9f0eeab115bc5ebb3917b4a64c2953534273cf9bc7ae6/coverage-7.9.1-cp311-cp311-win_arm64.whl", hash = "sha256:6ad935f0016be24c0e97fc8c40c465f9c4b85cbbe6eac48934c0dc4d2568321e", size = 213869, upload-time = "2025-06-13T13:01:09.345Z" },
- { url = "https://files.pythonhosted.org/packages/68/d9/7f66eb0a8f2fce222de7bdc2046ec41cb31fe33fb55a330037833fb88afc/coverage-7.9.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:a8de12b4b87c20de895f10567639c0797b621b22897b0af3ce4b4e204a743626", size = 212336, upload-time = "2025-06-13T13:01:10.909Z" },
- { url = "https://files.pythonhosted.org/packages/20/20/e07cb920ef3addf20f052ee3d54906e57407b6aeee3227a9c91eea38a665/coverage-7.9.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:5add197315a054e92cee1b5f686a2bcba60c4c3e66ee3de77ace6c867bdee7cb", size = 212571, upload-time = "2025-06-13T13:01:12.518Z" },
- { url = "https://files.pythonhosted.org/packages/78/f8/96f155de7e9e248ca9c8ff1a40a521d944ba48bec65352da9be2463745bf/coverage-7.9.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:600a1d4106fe66f41e5d0136dfbc68fe7200a5cbe85610ddf094f8f22e1b0300", size = 246377, upload-time = "2025-06-13T13:01:14.87Z" },
- { url = "https://files.pythonhosted.org/packages/3e/cf/1d783bd05b7bca5c10ded5f946068909372e94615a4416afadfe3f63492d/coverage-7.9.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:2a876e4c3e5a2a1715a6608906aa5a2e0475b9c0f68343c2ada98110512ab1d8", size = 243394, upload-time = "2025-06-13T13:01:16.23Z" },
- { url = "https://files.pythonhosted.org/packages/02/dd/e7b20afd35b0a1abea09fb3998e1abc9f9bd953bee548f235aebd2b11401/coverage-7.9.1-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:81f34346dd63010453922c8e628a52ea2d2ccd73cb2487f7700ac531b247c8a5", size = 245586, upload-time = "2025-06-13T13:01:17.532Z" },
- { url = "https://files.pythonhosted.org/packages/4e/38/b30b0006fea9d617d1cb8e43b1bc9a96af11eff42b87eb8c716cf4d37469/coverage-7.9.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:888f8eee13f2377ce86d44f338968eedec3291876b0b8a7289247ba52cb984cd", size = 245396, upload-time = "2025-06-13T13:01:19.164Z" },
- { url = "https://files.pythonhosted.org/packages/31/e4/4d8ec1dc826e16791f3daf1b50943e8e7e1eb70e8efa7abb03936ff48418/coverage-7.9.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:9969ef1e69b8c8e1e70d591f91bbc37fc9a3621e447525d1602801a24ceda898", size = 243577, upload-time = "2025-06-13T13:01:22.433Z" },
- { url = "https://files.pythonhosted.org/packages/25/f4/b0e96c5c38e6e40ef465c4bc7f138863e2909c00e54a331da335faf0d81a/coverage-7.9.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:60c458224331ee3f1a5b472773e4a085cc27a86a0b48205409d364272d67140d", size = 244809, upload-time = "2025-06-13T13:01:24.143Z" },
- { url = "https://files.pythonhosted.org/packages/8a/65/27e0a1fa5e2e5079bdca4521be2f5dabf516f94e29a0defed35ac2382eb2/coverage-7.9.1-cp312-cp312-win32.whl", hash = "sha256:5f646a99a8c2b3ff4c6a6e081f78fad0dde275cd59f8f49dc4eab2e394332e74", size = 214724, upload-time = "2025-06-13T13:01:25.435Z" },
- { url = "https://files.pythonhosted.org/packages/9b/a8/d5b128633fd1a5e0401a4160d02fa15986209a9e47717174f99dc2f7166d/coverage-7.9.1-cp312-cp312-win_amd64.whl", hash = "sha256:30f445f85c353090b83e552dcbbdad3ec84c7967e108c3ae54556ca69955563e", size = 215535, upload-time = "2025-06-13T13:01:27.861Z" },
- { url = "https://files.pythonhosted.org/packages/a3/37/84bba9d2afabc3611f3e4325ee2c6a47cd449b580d4a606b240ce5a6f9bf/coverage-7.9.1-cp312-cp312-win_arm64.whl", hash = "sha256:af41da5dca398d3474129c58cb2b106a5d93bbb196be0d307ac82311ca234342", size = 213904, upload-time = "2025-06-13T13:01:29.202Z" },
- { url = "https://files.pythonhosted.org/packages/3e/e5/c723545c3fd3204ebde3b4cc4b927dce709d3b6dc577754bb57f63ca4a4a/coverage-7.9.1-pp39.pp310.pp311-none-any.whl", hash = "sha256:db0f04118d1db74db6c9e1cb1898532c7dcc220f1d2718f058601f7c3f499514", size = 204009, upload-time = "2025-06-13T13:02:25.787Z" },
- { url = "https://files.pythonhosted.org/packages/08/b8/7ddd1e8ba9701dea08ce22029917140e6f66a859427406579fd8d0ca7274/coverage-7.9.1-py3-none-any.whl", hash = "sha256:66b974b145aa189516b6bf2d8423e888b742517d37872f6ee4c5be0073bd9a3c", size = 204000, upload-time = "2025-06-13T13:02:27.173Z" },
+version = "7.9.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/04/b7/c0465ca253df10a9e8dae0692a4ae6e9726d245390aaef92360e1d6d3832/coverage-7.9.2.tar.gz", hash = "sha256:997024fa51e3290264ffd7492ec97d0690293ccd2b45a6cd7d82d945a4a80c8b", size = 813556, upload-time = "2025-07-03T10:54:15.101Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/a1/0d/5c2114fd776c207bd55068ae8dc1bef63ecd1b767b3389984a8e58f2b926/coverage-7.9.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:66283a192a14a3854b2e7f3418d7db05cdf411012ab7ff5db98ff3b181e1f912", size = 212039, upload-time = "2025-07-03T10:52:38.955Z" },
+ { url = "https://files.pythonhosted.org/packages/cf/ad/dc51f40492dc2d5fcd31bb44577bc0cc8920757d6bc5d3e4293146524ef9/coverage-7.9.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:4e01d138540ef34fcf35c1aa24d06c3de2a4cffa349e29a10056544f35cca15f", size = 212428, upload-time = "2025-07-03T10:52:41.36Z" },
+ { url = "https://files.pythonhosted.org/packages/a2/a3/55cb3ff1b36f00df04439c3993d8529193cdf165a2467bf1402539070f16/coverage-7.9.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f22627c1fe2745ee98d3ab87679ca73a97e75ca75eb5faee48660d060875465f", size = 241534, upload-time = "2025-07-03T10:52:42.956Z" },
+ { url = "https://files.pythonhosted.org/packages/eb/c9/a8410b91b6be4f6e9c2e9f0dce93749b6b40b751d7065b4410bf89cb654b/coverage-7.9.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4b1c2d8363247b46bd51f393f86c94096e64a1cf6906803fa8d5a9d03784bdbf", size = 239408, upload-time = "2025-07-03T10:52:44.199Z" },
+ { url = "https://files.pythonhosted.org/packages/ff/c4/6f3e56d467c612b9070ae71d5d3b114c0b899b5788e1ca3c93068ccb7018/coverage-7.9.2-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c10c882b114faf82dbd33e876d0cbd5e1d1ebc0d2a74ceef642c6152f3f4d547", size = 240552, upload-time = "2025-07-03T10:52:45.477Z" },
+ { url = "https://files.pythonhosted.org/packages/fd/20/04eda789d15af1ce79bce5cc5fd64057c3a0ac08fd0576377a3096c24663/coverage-7.9.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:de3c0378bdf7066c3988d66cd5232d161e933b87103b014ab1b0b4676098fa45", size = 240464, upload-time = "2025-07-03T10:52:46.809Z" },
+ { url = "https://files.pythonhosted.org/packages/a9/5a/217b32c94cc1a0b90f253514815332d08ec0812194a1ce9cca97dda1cd20/coverage-7.9.2-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:1e2f097eae0e5991e7623958a24ced3282676c93c013dde41399ff63e230fcf2", size = 239134, upload-time = "2025-07-03T10:52:48.149Z" },
+ { url = "https://files.pythonhosted.org/packages/34/73/1d019c48f413465eb5d3b6898b6279e87141c80049f7dbf73fd020138549/coverage-7.9.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:28dc1f67e83a14e7079b6cea4d314bc8b24d1aed42d3582ff89c0295f09b181e", size = 239405, upload-time = "2025-07-03T10:52:49.687Z" },
+ { url = "https://files.pythonhosted.org/packages/49/6c/a2beca7aa2595dad0c0d3f350382c381c92400efe5261e2631f734a0e3fe/coverage-7.9.2-cp310-cp310-win32.whl", hash = "sha256:bf7d773da6af9e10dbddacbf4e5cab13d06d0ed93561d44dae0188a42c65be7e", size = 214519, upload-time = "2025-07-03T10:52:51.036Z" },
+ { url = "https://files.pythonhosted.org/packages/fc/c8/91e5e4a21f9a51e2c7cdd86e587ae01a4fcff06fc3fa8cde4d6f7cf68df4/coverage-7.9.2-cp310-cp310-win_amd64.whl", hash = "sha256:0c0378ba787681ab1897f7c89b415bd56b0b2d9a47e5a3d8dc0ea55aac118d6c", size = 215400, upload-time = "2025-07-03T10:52:52.313Z" },
+ { url = "https://files.pythonhosted.org/packages/39/40/916786453bcfafa4c788abee4ccd6f592b5b5eca0cd61a32a4e5a7ef6e02/coverage-7.9.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:a7a56a2964a9687b6aba5b5ced6971af308ef6f79a91043c05dd4ee3ebc3e9ba", size = 212152, upload-time = "2025-07-03T10:52:53.562Z" },
+ { url = "https://files.pythonhosted.org/packages/9f/66/cc13bae303284b546a030762957322bbbff1ee6b6cb8dc70a40f8a78512f/coverage-7.9.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:123d589f32c11d9be7fe2e66d823a236fe759b0096f5db3fb1b75b2fa414a4fa", size = 212540, upload-time = "2025-07-03T10:52:55.196Z" },
+ { url = "https://files.pythonhosted.org/packages/0f/3c/d56a764b2e5a3d43257c36af4a62c379df44636817bb5f89265de4bf8bd7/coverage-7.9.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:333b2e0ca576a7dbd66e85ab402e35c03b0b22f525eed82681c4b866e2e2653a", size = 245097, upload-time = "2025-07-03T10:52:56.509Z" },
+ { url = "https://files.pythonhosted.org/packages/b1/46/bd064ea8b3c94eb4ca5d90e34d15b806cba091ffb2b8e89a0d7066c45791/coverage-7.9.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:326802760da234baf9f2f85a39e4a4b5861b94f6c8d95251f699e4f73b1835dc", size = 242812, upload-time = "2025-07-03T10:52:57.842Z" },
+ { url = "https://files.pythonhosted.org/packages/43/02/d91992c2b29bc7afb729463bc918ebe5f361be7f1daae93375a5759d1e28/coverage-7.9.2-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:19e7be4cfec248df38ce40968c95d3952fbffd57b400d4b9bb580f28179556d2", size = 244617, upload-time = "2025-07-03T10:52:59.239Z" },
+ { url = "https://files.pythonhosted.org/packages/b7/4f/8fadff6bf56595a16d2d6e33415841b0163ac660873ed9a4e9046194f779/coverage-7.9.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:0b4a4cb73b9f2b891c1788711408ef9707666501ba23684387277ededab1097c", size = 244263, upload-time = "2025-07-03T10:53:00.601Z" },
+ { url = "https://files.pythonhosted.org/packages/9b/d2/e0be7446a2bba11739edb9f9ba4eff30b30d8257370e237418eb44a14d11/coverage-7.9.2-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:2c8937fa16c8c9fbbd9f118588756e7bcdc7e16a470766a9aef912dd3f117dbd", size = 242314, upload-time = "2025-07-03T10:53:01.932Z" },
+ { url = "https://files.pythonhosted.org/packages/9d/7d/dcbac9345000121b8b57a3094c2dfcf1ccc52d8a14a40c1d4bc89f936f80/coverage-7.9.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:42da2280c4d30c57a9b578bafd1d4494fa6c056d4c419d9689e66d775539be74", size = 242904, upload-time = "2025-07-03T10:53:03.478Z" },
+ { url = "https://files.pythonhosted.org/packages/41/58/11e8db0a0c0510cf31bbbdc8caf5d74a358b696302a45948d7c768dfd1cf/coverage-7.9.2-cp311-cp311-win32.whl", hash = "sha256:14fa8d3da147f5fdf9d298cacc18791818f3f1a9f542c8958b80c228320e90c6", size = 214553, upload-time = "2025-07-03T10:53:05.174Z" },
+ { url = "https://files.pythonhosted.org/packages/3a/7d/751794ec8907a15e257136e48dc1021b1f671220ecccfd6c4eaf30802714/coverage-7.9.2-cp311-cp311-win_amd64.whl", hash = "sha256:549cab4892fc82004f9739963163fd3aac7a7b0df430669b75b86d293d2df2a7", size = 215441, upload-time = "2025-07-03T10:53:06.472Z" },
+ { url = "https://files.pythonhosted.org/packages/62/5b/34abcedf7b946c1c9e15b44f326cb5b0da852885312b30e916f674913428/coverage-7.9.2-cp311-cp311-win_arm64.whl", hash = "sha256:c2667a2b913e307f06aa4e5677f01a9746cd08e4b35e14ebcde6420a9ebb4c62", size = 213873, upload-time = "2025-07-03T10:53:07.699Z" },
+ { url = "https://files.pythonhosted.org/packages/53/d7/7deefc6fd4f0f1d4c58051f4004e366afc9e7ab60217ac393f247a1de70a/coverage-7.9.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:ae9eb07f1cfacd9cfe8eaee6f4ff4b8a289a668c39c165cd0c8548484920ffc0", size = 212344, upload-time = "2025-07-03T10:53:09.3Z" },
+ { url = "https://files.pythonhosted.org/packages/95/0c/ee03c95d32be4d519e6a02e601267769ce2e9a91fc8faa1b540e3626c680/coverage-7.9.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:9ce85551f9a1119f02adc46d3014b5ee3f765deac166acf20dbb851ceb79b6f3", size = 212580, upload-time = "2025-07-03T10:53:11.52Z" },
+ { url = "https://files.pythonhosted.org/packages/8b/9f/826fa4b544b27620086211b87a52ca67592622e1f3af9e0a62c87aea153a/coverage-7.9.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f8f6389ac977c5fb322e0e38885fbbf901743f79d47f50db706e7644dcdcb6e1", size = 246383, upload-time = "2025-07-03T10:53:13.134Z" },
+ { url = "https://files.pythonhosted.org/packages/7f/b3/4477aafe2a546427b58b9c540665feff874f4db651f4d3cb21b308b3a6d2/coverage-7.9.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ff0d9eae8cdfcd58fe7893b88993723583a6ce4dfbfd9f29e001922544f95615", size = 243400, upload-time = "2025-07-03T10:53:14.614Z" },
+ { url = "https://files.pythonhosted.org/packages/f8/c2/efffa43778490c226d9d434827702f2dfbc8041d79101a795f11cbb2cf1e/coverage-7.9.2-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fae939811e14e53ed8a9818dad51d434a41ee09df9305663735f2e2d2d7d959b", size = 245591, upload-time = "2025-07-03T10:53:15.872Z" },
+ { url = "https://files.pythonhosted.org/packages/c6/e7/a59888e882c9a5f0192d8627a30ae57910d5d449c80229b55e7643c078c4/coverage-7.9.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:31991156251ec202c798501e0a42bbdf2169dcb0f137b1f5c0f4267f3fc68ef9", size = 245402, upload-time = "2025-07-03T10:53:17.124Z" },
+ { url = "https://files.pythonhosted.org/packages/92/a5/72fcd653ae3d214927edc100ce67440ed8a0a1e3576b8d5e6d066ed239db/coverage-7.9.2-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:d0d67963f9cbfc7c7f96d4ac74ed60ecbebd2ea6eeb51887af0f8dce205e545f", size = 243583, upload-time = "2025-07-03T10:53:18.781Z" },
+ { url = "https://files.pythonhosted.org/packages/5c/f5/84e70e4df28f4a131d580d7d510aa1ffd95037293da66fd20d446090a13b/coverage-7.9.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:49b752a2858b10580969ec6af6f090a9a440a64a301ac1528d7ca5f7ed497f4d", size = 244815, upload-time = "2025-07-03T10:53:20.168Z" },
+ { url = "https://files.pythonhosted.org/packages/39/e7/d73d7cbdbd09fdcf4642655ae843ad403d9cbda55d725721965f3580a314/coverage-7.9.2-cp312-cp312-win32.whl", hash = "sha256:88d7598b8ee130f32f8a43198ee02edd16d7f77692fa056cb779616bbea1b355", size = 214719, upload-time = "2025-07-03T10:53:21.521Z" },
+ { url = "https://files.pythonhosted.org/packages/9f/d6/7486dcc3474e2e6ad26a2af2db7e7c162ccd889c4c68fa14ea8ec189c9e9/coverage-7.9.2-cp312-cp312-win_amd64.whl", hash = "sha256:9dfb070f830739ee49d7c83e4941cc767e503e4394fdecb3b54bfdac1d7662c0", size = 215509, upload-time = "2025-07-03T10:53:22.853Z" },
+ { url = "https://files.pythonhosted.org/packages/b7/34/0439f1ae2593b0346164d907cdf96a529b40b7721a45fdcf8b03c95fcd90/coverage-7.9.2-cp312-cp312-win_arm64.whl", hash = "sha256:4e2c058aef613e79df00e86b6d42a641c877211384ce5bd07585ed7ba71ab31b", size = 213910, upload-time = "2025-07-03T10:53:24.472Z" },
+ { url = "https://files.pythonhosted.org/packages/d7/85/f8bbefac27d286386961c25515431482a425967e23d3698b75a250872924/coverage-7.9.2-pp39.pp310.pp311-none-any.whl", hash = "sha256:8a1166db2fb62473285bcb092f586e081e92656c7dfa8e9f62b4d39d7e6b5050", size = 204013, upload-time = "2025-07-03T10:54:12.084Z" },
+ { url = "https://files.pythonhosted.org/packages/3c/38/bbe2e63902847cf79036ecc75550d0698af31c91c7575352eb25190d0fb3/coverage-7.9.2-py3-none-any.whl", hash = "sha256:e425cd5b00f6fc0ed7cdbd766c70be8baab4b7839e4d4fe5fac48581dd968ea4", size = 204005, upload-time = "2025-07-03T10:54:13.491Z" },
]
[package.optional-dependencies]
@@ -1739,49 +1740,49 @@ wheels = [
[[package]]
name = "cryptography"
-version = "45.0.4"
+version = "45.0.5"
source = { registry = "https://pypi.org/simple" }
dependencies = [
{ name = "cffi", marker = "platform_python_implementation != 'PyPy'" },
]
-sdist = { url = "https://files.pythonhosted.org/packages/fe/c8/a2a376a8711c1e11708b9c9972e0c3223f5fc682552c82d8db844393d6ce/cryptography-45.0.4.tar.gz", hash = "sha256:7405ade85c83c37682c8fe65554759800a4a8c54b2d96e0f8ad114d31b808d57", size = 744890, upload-time = "2025-06-10T00:03:51.297Z" }
-wheels = [
- { url = "https://files.pythonhosted.org/packages/cc/1c/92637793de053832523b410dbe016d3f5c11b41d0cf6eef8787aabb51d41/cryptography-45.0.4-cp311-abi3-macosx_10_9_universal2.whl", hash = "sha256:425a9a6ac2823ee6e46a76a21a4e8342d8fa5c01e08b823c1f19a8b74f096069", size = 7055712, upload-time = "2025-06-10T00:02:38.826Z" },
- { url = "https://files.pythonhosted.org/packages/ba/14/93b69f2af9ba832ad6618a03f8a034a5851dc9a3314336a3d71c252467e1/cryptography-45.0.4-cp311-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:680806cf63baa0039b920f4976f5f31b10e772de42f16310a6839d9f21a26b0d", size = 4205335, upload-time = "2025-06-10T00:02:41.64Z" },
- { url = "https://files.pythonhosted.org/packages/67/30/fae1000228634bf0b647fca80403db5ca9e3933b91dd060570689f0bd0f7/cryptography-45.0.4-cp311-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:4ca0f52170e821bc8da6fc0cc565b7bb8ff8d90d36b5e9fdd68e8a86bdf72036", size = 4431487, upload-time = "2025-06-10T00:02:43.696Z" },
- { url = "https://files.pythonhosted.org/packages/6d/5a/7dffcf8cdf0cb3c2430de7404b327e3db64735747d641fc492539978caeb/cryptography-45.0.4-cp311-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:f3fe7a5ae34d5a414957cc7f457e2b92076e72938423ac64d215722f6cf49a9e", size = 4208922, upload-time = "2025-06-10T00:02:45.334Z" },
- { url = "https://files.pythonhosted.org/packages/c6/f3/528729726eb6c3060fa3637253430547fbaaea95ab0535ea41baa4a6fbd8/cryptography-45.0.4-cp311-abi3-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:25eb4d4d3e54595dc8adebc6bbd5623588991d86591a78c2548ffb64797341e2", size = 3900433, upload-time = "2025-06-10T00:02:47.359Z" },
- { url = "https://files.pythonhosted.org/packages/d9/4a/67ba2e40f619e04d83c32f7e1d484c1538c0800a17c56a22ff07d092ccc1/cryptography-45.0.4-cp311-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:ce1678a2ccbe696cf3af15a75bb72ee008d7ff183c9228592ede9db467e64f1b", size = 4464163, upload-time = "2025-06-10T00:02:49.412Z" },
- { url = "https://files.pythonhosted.org/packages/7e/9a/b4d5aa83661483ac372464809c4b49b5022dbfe36b12fe9e323ca8512420/cryptography-45.0.4-cp311-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:49fe9155ab32721b9122975e168a6760d8ce4cffe423bcd7ca269ba41b5dfac1", size = 4208687, upload-time = "2025-06-10T00:02:50.976Z" },
- { url = "https://files.pythonhosted.org/packages/db/b7/a84bdcd19d9c02ec5807f2ec2d1456fd8451592c5ee353816c09250e3561/cryptography-45.0.4-cp311-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:2882338b2a6e0bd337052e8b9007ced85c637da19ef9ecaf437744495c8c2999", size = 4463623, upload-time = "2025-06-10T00:02:52.542Z" },
- { url = "https://files.pythonhosted.org/packages/d8/84/69707d502d4d905021cac3fb59a316344e9f078b1da7fb43ecde5e10840a/cryptography-45.0.4-cp311-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:23b9c3ea30c3ed4db59e7b9619272e94891f8a3a5591d0b656a7582631ccf750", size = 4332447, upload-time = "2025-06-10T00:02:54.63Z" },
- { url = "https://files.pythonhosted.org/packages/f3/ee/d4f2ab688e057e90ded24384e34838086a9b09963389a5ba6854b5876598/cryptography-45.0.4-cp311-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:b0a97c927497e3bc36b33987abb99bf17a9a175a19af38a892dc4bbb844d7ee2", size = 4572830, upload-time = "2025-06-10T00:02:56.689Z" },
- { url = "https://files.pythonhosted.org/packages/70/d4/994773a261d7ff98034f72c0e8251fe2755eac45e2265db4c866c1c6829c/cryptography-45.0.4-cp311-abi3-win32.whl", hash = "sha256:e00a6c10a5c53979d6242f123c0a97cff9f3abed7f064fc412c36dc521b5f257", size = 2932769, upload-time = "2025-06-10T00:02:58.467Z" },
- { url = "https://files.pythonhosted.org/packages/5a/42/c80bd0b67e9b769b364963b5252b17778a397cefdd36fa9aa4a5f34c599a/cryptography-45.0.4-cp311-abi3-win_amd64.whl", hash = "sha256:817ee05c6c9f7a69a16200f0c90ab26d23a87701e2a284bd15156783e46dbcc8", size = 3410441, upload-time = "2025-06-10T00:03:00.14Z" },
- { url = "https://files.pythonhosted.org/packages/ce/0b/2488c89f3a30bc821c9d96eeacfcab6ff3accc08a9601ba03339c0fd05e5/cryptography-45.0.4-cp37-abi3-macosx_10_9_universal2.whl", hash = "sha256:964bcc28d867e0f5491a564b7debb3ffdd8717928d315d12e0d7defa9e43b723", size = 7031836, upload-time = "2025-06-10T00:03:01.726Z" },
- { url = "https://files.pythonhosted.org/packages/fe/51/8c584ed426093aac257462ae62d26ad61ef1cbf5b58d8b67e6e13c39960e/cryptography-45.0.4-cp37-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:6a5bf57554e80f75a7db3d4b1dacaa2764611ae166ab42ea9a72bcdb5d577637", size = 4195746, upload-time = "2025-06-10T00:03:03.94Z" },
- { url = "https://files.pythonhosted.org/packages/5c/7d/4b0ca4d7af95a704eef2f8f80a8199ed236aaf185d55385ae1d1610c03c2/cryptography-45.0.4-cp37-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:46cf7088bf91bdc9b26f9c55636492c1cce3e7aaf8041bbf0243f5e5325cfb2d", size = 4424456, upload-time = "2025-06-10T00:03:05.589Z" },
- { url = "https://files.pythonhosted.org/packages/1d/45/5fabacbc6e76ff056f84d9f60eeac18819badf0cefc1b6612ee03d4ab678/cryptography-45.0.4-cp37-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:7bedbe4cc930fa4b100fc845ea1ea5788fcd7ae9562e669989c11618ae8d76ee", size = 4198495, upload-time = "2025-06-10T00:03:09.172Z" },
- { url = "https://files.pythonhosted.org/packages/55/b7/ffc9945b290eb0a5d4dab9b7636706e3b5b92f14ee5d9d4449409d010d54/cryptography-45.0.4-cp37-abi3-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:eaa3e28ea2235b33220b949c5a0d6cf79baa80eab2eb5607ca8ab7525331b9ff", size = 3885540, upload-time = "2025-06-10T00:03:10.835Z" },
- { url = "https://files.pythonhosted.org/packages/7f/e3/57b010282346980475e77d414080acdcb3dab9a0be63071efc2041a2c6bd/cryptography-45.0.4-cp37-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:7ef2dde4fa9408475038fc9aadfc1fb2676b174e68356359632e980c661ec8f6", size = 4452052, upload-time = "2025-06-10T00:03:12.448Z" },
- { url = "https://files.pythonhosted.org/packages/37/e6/ddc4ac2558bf2ef517a358df26f45bc774a99bf4653e7ee34b5e749c03e3/cryptography-45.0.4-cp37-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:6a3511ae33f09094185d111160fd192c67aa0a2a8d19b54d36e4c78f651dc5ad", size = 4198024, upload-time = "2025-06-10T00:03:13.976Z" },
- { url = "https://files.pythonhosted.org/packages/3a/c0/85fa358ddb063ec588aed4a6ea1df57dc3e3bc1712d87c8fa162d02a65fc/cryptography-45.0.4-cp37-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:06509dc70dd71fa56eaa138336244e2fbaf2ac164fc9b5e66828fccfd2b680d6", size = 4451442, upload-time = "2025-06-10T00:03:16.248Z" },
- { url = "https://files.pythonhosted.org/packages/33/67/362d6ec1492596e73da24e669a7fbbaeb1c428d6bf49a29f7a12acffd5dc/cryptography-45.0.4-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:5f31e6b0a5a253f6aa49be67279be4a7e5a4ef259a9f33c69f7d1b1191939872", size = 4325038, upload-time = "2025-06-10T00:03:18.4Z" },
- { url = "https://files.pythonhosted.org/packages/53/75/82a14bf047a96a1b13ebb47fb9811c4f73096cfa2e2b17c86879687f9027/cryptography-45.0.4-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:944e9ccf67a9594137f942d5b52c8d238b1b4e46c7a0c2891b7ae6e01e7c80a4", size = 4560964, upload-time = "2025-06-10T00:03:20.06Z" },
- { url = "https://files.pythonhosted.org/packages/cd/37/1a3cba4c5a468ebf9b95523a5ef5651244693dc712001e276682c278fc00/cryptography-45.0.4-cp37-abi3-win32.whl", hash = "sha256:c22fe01e53dc65edd1945a2e6f0015e887f84ced233acecb64b4daadb32f5c97", size = 2924557, upload-time = "2025-06-10T00:03:22.563Z" },
- { url = "https://files.pythonhosted.org/packages/2a/4b/3256759723b7e66380397d958ca07c59cfc3fb5c794fb5516758afd05d41/cryptography-45.0.4-cp37-abi3-win_amd64.whl", hash = "sha256:627ba1bc94f6adf0b0a2e35d87020285ead22d9f648c7e75bb64f367375f3b22", size = 3395508, upload-time = "2025-06-10T00:03:24.586Z" },
- { url = "https://files.pythonhosted.org/packages/16/33/b38e9d372afde56906a23839302c19abdac1c505bfb4776c1e4b07c3e145/cryptography-45.0.4-pp310-pypy310_pp73-macosx_10_9_x86_64.whl", hash = "sha256:a77c6fb8d76e9c9f99f2f3437c1a4ac287b34eaf40997cfab1e9bd2be175ac39", size = 3580103, upload-time = "2025-06-10T00:03:26.207Z" },
- { url = "https://files.pythonhosted.org/packages/c4/b9/357f18064ec09d4807800d05a48f92f3b369056a12f995ff79549fbb31f1/cryptography-45.0.4-pp310-pypy310_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:7aad98a25ed8ac917fdd8a9c1e706e5a0956e06c498be1f713b61734333a4507", size = 4143732, upload-time = "2025-06-10T00:03:27.896Z" },
- { url = "https://files.pythonhosted.org/packages/c4/9c/7f7263b03d5db329093617648b9bd55c953de0b245e64e866e560f9aac07/cryptography-45.0.4-pp310-pypy310_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:3530382a43a0e524bc931f187fc69ef4c42828cf7d7f592f7f249f602b5a4ab0", size = 4385424, upload-time = "2025-06-10T00:03:29.992Z" },
- { url = "https://files.pythonhosted.org/packages/a6/5a/6aa9d8d5073d5acc0e04e95b2860ef2684b2bd2899d8795fc443013e263b/cryptography-45.0.4-pp310-pypy310_pp73-manylinux_2_34_aarch64.whl", hash = "sha256:6b613164cb8425e2f8db5849ffb84892e523bf6d26deb8f9bb76ae86181fa12b", size = 4142438, upload-time = "2025-06-10T00:03:31.782Z" },
- { url = "https://files.pythonhosted.org/packages/42/1c/71c638420f2cdd96d9c2b287fec515faf48679b33a2b583d0f1eda3a3375/cryptography-45.0.4-pp310-pypy310_pp73-manylinux_2_34_x86_64.whl", hash = "sha256:96d4819e25bf3b685199b304a0029ce4a3caf98947ce8a066c9137cc78ad2c58", size = 4384622, upload-time = "2025-06-10T00:03:33.491Z" },
- { url = "https://files.pythonhosted.org/packages/ef/ab/e3a055c34e97deadbf0d846e189237d3385dca99e1a7e27384c3b2292041/cryptography-45.0.4-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:b97737a3ffbea79eebb062eb0d67d72307195035332501722a9ca86bab9e3ab2", size = 3328911, upload-time = "2025-06-10T00:03:35.035Z" },
- { url = "https://files.pythonhosted.org/packages/ea/ba/cf442ae99ef363855ed84b39e0fb3c106ac66b7a7703f3c9c9cfe05412cb/cryptography-45.0.4-pp311-pypy311_pp73-macosx_10_9_x86_64.whl", hash = "sha256:4828190fb6c4bcb6ebc6331f01fe66ae838bb3bd58e753b59d4b22eb444b996c", size = 3590512, upload-time = "2025-06-10T00:03:36.982Z" },
- { url = "https://files.pythonhosted.org/packages/28/9a/a7d5bb87d149eb99a5abdc69a41e4e47b8001d767e5f403f78bfaafc7aa7/cryptography-45.0.4-pp311-pypy311_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:03dbff8411206713185b8cebe31bc5c0eb544799a50c09035733716b386e61a4", size = 4146899, upload-time = "2025-06-10T00:03:38.659Z" },
- { url = "https://files.pythonhosted.org/packages/17/11/9361c2c71c42cc5c465cf294c8030e72fb0c87752bacbd7a3675245e3db3/cryptography-45.0.4-pp311-pypy311_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:51dfbd4d26172d31150d84c19bbe06c68ea4b7f11bbc7b3a5e146b367c311349", size = 4388900, upload-time = "2025-06-10T00:03:40.233Z" },
- { url = "https://files.pythonhosted.org/packages/c0/76/f95b83359012ee0e670da3e41c164a0c256aeedd81886f878911581d852f/cryptography-45.0.4-pp311-pypy311_pp73-manylinux_2_34_aarch64.whl", hash = "sha256:0339a692de47084969500ee455e42c58e449461e0ec845a34a6a9b9bf7df7fb8", size = 4146422, upload-time = "2025-06-10T00:03:41.827Z" },
- { url = "https://files.pythonhosted.org/packages/09/ad/5429fcc4def93e577a5407988f89cf15305e64920203d4ac14601a9dc876/cryptography-45.0.4-pp311-pypy311_pp73-manylinux_2_34_x86_64.whl", hash = "sha256:0cf13c77d710131d33e63626bd55ae7c0efb701ebdc2b3a7952b9b23a0412862", size = 4388475, upload-time = "2025-06-10T00:03:43.493Z" },
- { url = "https://files.pythonhosted.org/packages/99/49/0ab9774f64555a1b50102757811508f5ace451cf5dc0a2d074a4b9deca6a/cryptography-45.0.4-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:bbc505d1dc469ac12a0a064214879eac6294038d6b24ae9f71faae1448a9608d", size = 3337594, upload-time = "2025-06-10T00:03:45.523Z" },
+sdist = { url = "https://files.pythonhosted.org/packages/95/1e/49527ac611af559665f71cbb8f92b332b5ec9c6fbc4e88b0f8e92f5e85df/cryptography-45.0.5.tar.gz", hash = "sha256:72e76caa004ab63accdf26023fccd1d087f6d90ec6048ff33ad0445abf7f605a", size = 744903, upload-time = "2025-07-02T13:06:25.941Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/f0/fb/09e28bc0c46d2c547085e60897fea96310574c70fb21cd58a730a45f3403/cryptography-45.0.5-cp311-abi3-macosx_10_9_universal2.whl", hash = "sha256:101ee65078f6dd3e5a028d4f19c07ffa4dd22cce6a20eaa160f8b5219911e7d8", size = 7043092, upload-time = "2025-07-02T13:05:01.514Z" },
+ { url = "https://files.pythonhosted.org/packages/b1/05/2194432935e29b91fb649f6149c1a4f9e6d3d9fc880919f4ad1bcc22641e/cryptography-45.0.5-cp311-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:3a264aae5f7fbb089dbc01e0242d3b67dffe3e6292e1f5182122bdf58e65215d", size = 4205926, upload-time = "2025-07-02T13:05:04.741Z" },
+ { url = "https://files.pythonhosted.org/packages/07/8b/9ef5da82350175e32de245646b1884fc01124f53eb31164c77f95a08d682/cryptography-45.0.5-cp311-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:e74d30ec9c7cb2f404af331d5b4099a9b322a8a6b25c4632755c8757345baac5", size = 4429235, upload-time = "2025-07-02T13:05:07.084Z" },
+ { url = "https://files.pythonhosted.org/packages/7c/e1/c809f398adde1994ee53438912192d92a1d0fc0f2d7582659d9ef4c28b0c/cryptography-45.0.5-cp311-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:3af26738f2db354aafe492fb3869e955b12b2ef2e16908c8b9cb928128d42c57", size = 4209785, upload-time = "2025-07-02T13:05:09.321Z" },
+ { url = "https://files.pythonhosted.org/packages/d0/8b/07eb6bd5acff58406c5e806eff34a124936f41a4fb52909ffa4d00815f8c/cryptography-45.0.5-cp311-abi3-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e6c00130ed423201c5bc5544c23359141660b07999ad82e34e7bb8f882bb78e0", size = 3893050, upload-time = "2025-07-02T13:05:11.069Z" },
+ { url = "https://files.pythonhosted.org/packages/ec/ef/3333295ed58d900a13c92806b67e62f27876845a9a908c939f040887cca9/cryptography-45.0.5-cp311-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:dd420e577921c8c2d31289536c386aaa30140b473835e97f83bc71ea9d2baf2d", size = 4457379, upload-time = "2025-07-02T13:05:13.32Z" },
+ { url = "https://files.pythonhosted.org/packages/d9/9d/44080674dee514dbb82b21d6fa5d1055368f208304e2ab1828d85c9de8f4/cryptography-45.0.5-cp311-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:d05a38884db2ba215218745f0781775806bde4f32e07b135348355fe8e4991d9", size = 4209355, upload-time = "2025-07-02T13:05:15.017Z" },
+ { url = "https://files.pythonhosted.org/packages/c9/d8/0749f7d39f53f8258e5c18a93131919ac465ee1f9dccaf1b3f420235e0b5/cryptography-45.0.5-cp311-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:ad0caded895a00261a5b4aa9af828baede54638754b51955a0ac75576b831b27", size = 4456087, upload-time = "2025-07-02T13:05:16.945Z" },
+ { url = "https://files.pythonhosted.org/packages/09/d7/92acac187387bf08902b0bf0699816f08553927bdd6ba3654da0010289b4/cryptography-45.0.5-cp311-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:9024beb59aca9d31d36fcdc1604dd9bbeed0a55bface9f1908df19178e2f116e", size = 4332873, upload-time = "2025-07-02T13:05:18.743Z" },
+ { url = "https://files.pythonhosted.org/packages/03/c2/840e0710da5106a7c3d4153c7215b2736151bba60bf4491bdb421df5056d/cryptography-45.0.5-cp311-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:91098f02ca81579c85f66df8a588c78f331ca19089763d733e34ad359f474174", size = 4564651, upload-time = "2025-07-02T13:05:21.382Z" },
+ { url = "https://files.pythonhosted.org/packages/2e/92/cc723dd6d71e9747a887b94eb3827825c6c24b9e6ce2bb33b847d31d5eaa/cryptography-45.0.5-cp311-abi3-win32.whl", hash = "sha256:926c3ea71a6043921050eaa639137e13dbe7b4ab25800932a8498364fc1abec9", size = 2929050, upload-time = "2025-07-02T13:05:23.39Z" },
+ { url = "https://files.pythonhosted.org/packages/1f/10/197da38a5911a48dd5389c043de4aec4b3c94cb836299b01253940788d78/cryptography-45.0.5-cp311-abi3-win_amd64.whl", hash = "sha256:b85980d1e345fe769cfc57c57db2b59cff5464ee0c045d52c0df087e926fbe63", size = 3403224, upload-time = "2025-07-02T13:05:25.202Z" },
+ { url = "https://files.pythonhosted.org/packages/fe/2b/160ce8c2765e7a481ce57d55eba1546148583e7b6f85514472b1d151711d/cryptography-45.0.5-cp37-abi3-macosx_10_9_universal2.whl", hash = "sha256:f3562c2f23c612f2e4a6964a61d942f891d29ee320edb62ff48ffb99f3de9ae8", size = 7017143, upload-time = "2025-07-02T13:05:27.229Z" },
+ { url = "https://files.pythonhosted.org/packages/c2/e7/2187be2f871c0221a81f55ee3105d3cf3e273c0a0853651d7011eada0d7e/cryptography-45.0.5-cp37-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:3fcfbefc4a7f332dece7272a88e410f611e79458fab97b5efe14e54fe476f4fd", size = 4197780, upload-time = "2025-07-02T13:05:29.299Z" },
+ { url = "https://files.pythonhosted.org/packages/b9/cf/84210c447c06104e6be9122661159ad4ce7a8190011669afceeaea150524/cryptography-45.0.5-cp37-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:460f8c39ba66af7db0545a8c6f2eabcbc5a5528fc1cf6c3fa9a1e44cec33385e", size = 4420091, upload-time = "2025-07-02T13:05:31.221Z" },
+ { url = "https://files.pythonhosted.org/packages/3e/6a/cb8b5c8bb82fafffa23aeff8d3a39822593cee6e2f16c5ca5c2ecca344f7/cryptography-45.0.5-cp37-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:9b4cf6318915dccfe218e69bbec417fdd7c7185aa7aab139a2c0beb7468c89f0", size = 4198711, upload-time = "2025-07-02T13:05:33.062Z" },
+ { url = "https://files.pythonhosted.org/packages/04/f7/36d2d69df69c94cbb2473871926daf0f01ad8e00fe3986ac3c1e8c4ca4b3/cryptography-45.0.5-cp37-abi3-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:2089cc8f70a6e454601525e5bf2779e665d7865af002a5dec8d14e561002e135", size = 3883299, upload-time = "2025-07-02T13:05:34.94Z" },
+ { url = "https://files.pythonhosted.org/packages/82/c7/f0ea40f016de72f81288e9fe8d1f6748036cb5ba6118774317a3ffc6022d/cryptography-45.0.5-cp37-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:0027d566d65a38497bc37e0dd7c2f8ceda73597d2ac9ba93810204f56f52ebc7", size = 4450558, upload-time = "2025-07-02T13:05:37.288Z" },
+ { url = "https://files.pythonhosted.org/packages/06/ae/94b504dc1a3cdf642d710407c62e86296f7da9e66f27ab12a1ee6fdf005b/cryptography-45.0.5-cp37-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:be97d3a19c16a9be00edf79dca949c8fa7eff621763666a145f9f9535a5d7f42", size = 4198020, upload-time = "2025-07-02T13:05:39.102Z" },
+ { url = "https://files.pythonhosted.org/packages/05/2b/aaf0adb845d5dabb43480f18f7ca72e94f92c280aa983ddbd0bcd6ecd037/cryptography-45.0.5-cp37-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:7760c1c2e1a7084153a0f68fab76e754083b126a47d0117c9ed15e69e2103492", size = 4449759, upload-time = "2025-07-02T13:05:41.398Z" },
+ { url = "https://files.pythonhosted.org/packages/91/e4/f17e02066de63e0100a3a01b56f8f1016973a1d67551beaf585157a86b3f/cryptography-45.0.5-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:6ff8728d8d890b3dda5765276d1bc6fb099252915a2cd3aff960c4c195745dd0", size = 4319991, upload-time = "2025-07-02T13:05:43.64Z" },
+ { url = "https://files.pythonhosted.org/packages/f2/2e/e2dbd629481b499b14516eed933f3276eb3239f7cee2dcfa4ee6b44d4711/cryptography-45.0.5-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:7259038202a47fdecee7e62e0fd0b0738b6daa335354396c6ddebdbe1206af2a", size = 4554189, upload-time = "2025-07-02T13:05:46.045Z" },
+ { url = "https://files.pythonhosted.org/packages/f8/ea/a78a0c38f4c8736287b71c2ea3799d173d5ce778c7d6e3c163a95a05ad2a/cryptography-45.0.5-cp37-abi3-win32.whl", hash = "sha256:1e1da5accc0c750056c556a93c3e9cb828970206c68867712ca5805e46dc806f", size = 2911769, upload-time = "2025-07-02T13:05:48.329Z" },
+ { url = "https://files.pythonhosted.org/packages/79/b3/28ac139109d9005ad3f6b6f8976ffede6706a6478e21c889ce36c840918e/cryptography-45.0.5-cp37-abi3-win_amd64.whl", hash = "sha256:90cb0a7bb35959f37e23303b7eed0a32280510030daba3f7fdfbb65defde6a97", size = 3390016, upload-time = "2025-07-02T13:05:50.811Z" },
+ { url = "https://files.pythonhosted.org/packages/f8/8b/34394337abe4566848a2bd49b26bcd4b07fd466afd3e8cce4cb79a390869/cryptography-45.0.5-pp310-pypy310_pp73-macosx_10_9_x86_64.whl", hash = "sha256:206210d03c1193f4e1ff681d22885181d47efa1ab3018766a7b32a7b3d6e6afd", size = 3575762, upload-time = "2025-07-02T13:05:53.166Z" },
+ { url = "https://files.pythonhosted.org/packages/8b/5d/a19441c1e89afb0f173ac13178606ca6fab0d3bd3ebc29e9ed1318b507fc/cryptography-45.0.5-pp310-pypy310_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:c648025b6840fe62e57107e0a25f604db740e728bd67da4f6f060f03017d5097", size = 4140906, upload-time = "2025-07-02T13:05:55.914Z" },
+ { url = "https://files.pythonhosted.org/packages/4b/db/daceb259982a3c2da4e619f45b5bfdec0e922a23de213b2636e78ef0919b/cryptography-45.0.5-pp310-pypy310_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:b8fa8b0a35a9982a3c60ec79905ba5bb090fc0b9addcfd3dc2dd04267e45f25e", size = 4374411, upload-time = "2025-07-02T13:05:57.814Z" },
+ { url = "https://files.pythonhosted.org/packages/6a/35/5d06ad06402fc522c8bf7eab73422d05e789b4e38fe3206a85e3d6966c11/cryptography-45.0.5-pp310-pypy310_pp73-manylinux_2_34_aarch64.whl", hash = "sha256:14d96584701a887763384f3c47f0ca7c1cce322aa1c31172680eb596b890ec30", size = 4140942, upload-time = "2025-07-02T13:06:00.137Z" },
+ { url = "https://files.pythonhosted.org/packages/65/79/020a5413347e44c382ef1f7f7e7a66817cd6273e3e6b5a72d18177b08b2f/cryptography-45.0.5-pp310-pypy310_pp73-manylinux_2_34_x86_64.whl", hash = "sha256:57c816dfbd1659a367831baca4b775b2a5b43c003daf52e9d57e1d30bc2e1b0e", size = 4374079, upload-time = "2025-07-02T13:06:02.043Z" },
+ { url = "https://files.pythonhosted.org/packages/9b/c5/c0e07d84a9a2a8a0ed4f865e58f37c71af3eab7d5e094ff1b21f3f3af3bc/cryptography-45.0.5-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:b9e38e0a83cd51e07f5a48ff9691cae95a79bea28fe4ded168a8e5c6c77e819d", size = 3321362, upload-time = "2025-07-02T13:06:04.463Z" },
+ { url = "https://files.pythonhosted.org/packages/c0/71/9bdbcfd58d6ff5084687fe722c58ac718ebedbc98b9f8f93781354e6d286/cryptography-45.0.5-pp311-pypy311_pp73-macosx_10_9_x86_64.whl", hash = "sha256:8c4a6ff8a30e9e3d38ac0539e9a9e02540ab3f827a3394f8852432f6b0ea152e", size = 3587878, upload-time = "2025-07-02T13:06:06.339Z" },
+ { url = "https://files.pythonhosted.org/packages/f0/63/83516cfb87f4a8756eaa4203f93b283fda23d210fc14e1e594bd5f20edb6/cryptography-45.0.5-pp311-pypy311_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:bd4c45986472694e5121084c6ebbd112aa919a25e783b87eb95953c9573906d6", size = 4152447, upload-time = "2025-07-02T13:06:08.345Z" },
+ { url = "https://files.pythonhosted.org/packages/22/11/d2823d2a5a0bd5802b3565437add16f5c8ce1f0778bf3822f89ad2740a38/cryptography-45.0.5-pp311-pypy311_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:982518cd64c54fcada9d7e5cf28eabd3ee76bd03ab18e08a48cad7e8b6f31b18", size = 4386778, upload-time = "2025-07-02T13:06:10.263Z" },
+ { url = "https://files.pythonhosted.org/packages/5f/38/6bf177ca6bce4fe14704ab3e93627c5b0ca05242261a2e43ef3168472540/cryptography-45.0.5-pp311-pypy311_pp73-manylinux_2_34_aarch64.whl", hash = "sha256:12e55281d993a793b0e883066f590c1ae1e802e3acb67f8b442e721e475e6463", size = 4151627, upload-time = "2025-07-02T13:06:13.097Z" },
+ { url = "https://files.pythonhosted.org/packages/38/6a/69fc67e5266bff68a91bcb81dff8fb0aba4d79a78521a08812048913e16f/cryptography-45.0.5-pp311-pypy311_pp73-manylinux_2_34_x86_64.whl", hash = "sha256:5aa1e32983d4443e310f726ee4b071ab7569f58eedfdd65e9675484a4eb67bd1", size = 4385593, upload-time = "2025-07-02T13:06:15.689Z" },
+ { url = "https://files.pythonhosted.org/packages/f6/34/31a1604c9a9ade0fdab61eb48570e09a796f4d9836121266447b0eaf7feb/cryptography-45.0.5-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:e357286c1b76403dd384d938f93c46b2b058ed4dfcdce64a770f0537ed3feb6f", size = 3331106, upload-time = "2025-07-02T13:06:18.058Z" },
]
[[package]]
@@ -2176,7 +2177,7 @@ wheels = [
[[package]]
name = "e2b"
-version = "1.5.3"
+version = "1.5.4"
source = { registry = "https://pypi.org/simple" }
dependencies = [
{ name = "attrs" },
@@ -2187,9 +2188,9 @@ dependencies = [
{ name = "python-dateutil" },
{ name = "typing-extensions" },
]
-sdist = { url = "https://files.pythonhosted.org/packages/ac/5e/c86b8130e275723066c982e81b564042bfb3c5c852b1e92165287e98f4d4/e2b-1.5.3.tar.gz", hash = "sha256:bc059dd5c82b2df54dcb17eb3f95c3524c128d7f35740d0ff4ee00600b906cba", size = 55859, upload-time = "2025-06-27T20:24:33.436Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/66/fa/60479e37e6b7f7432e6b1819b3ae1680fc9215906f45d5d9bc89f7aeeb9e/e2b-1.5.4.tar.gz", hash = "sha256:49f1c115d0198244beef5854d19cc857fda9382e205f137b98d3dae0e7e0b2d2", size = 56001, upload-time = "2025-07-03T18:31:21.161Z" }
wheels = [
- { url = "https://files.pythonhosted.org/packages/0d/39/94f7c6bf52e869c0e3d8e23eb570f88c59774ebd970a4a3d2dd5a775bc8b/e2b-1.5.3-py3-none-any.whl", hash = "sha256:c6fff77c63d371bdc3c76eaf3ead22ea0507db4690a8d0d05aeb4debc349da89", size = 104087, upload-time = "2025-06-27T20:24:31.753Z" },
+ { url = "https://files.pythonhosted.org/packages/45/0c/c1e9db9fa4671b9bbda602674c66dd2a928ff13d372963086a661fa75f03/e2b-1.5.4-py3-none-any.whl", hash = "sha256:9c8d22f9203311dff890e037823596daaba3d793300238117f2efc5426888f2c", size = 104255, upload-time = "2025-07-03T18:31:19.313Z" },
]
[[package]]
@@ -2248,7 +2249,7 @@ wheels = [
[[package]]
name = "exa-py"
-version = "1.14.13"
+version = "1.14.15"
source = { registry = "https://pypi.org/simple" }
dependencies = [
{ name = "httpx" },
@@ -2257,9 +2258,9 @@ dependencies = [
{ name = "requests" },
{ name = "typing-extensions" },
]
-sdist = { url = "https://files.pythonhosted.org/packages/82/02/6a328cb347c7ec36d84e0f746e1abf5cdc0f09276d14e40d9ad0e2f5efac/exa_py-1.14.13.tar.gz", hash = "sha256:fb86287d12ef44c1386586ef811c35b8818ed008083d4c884ee55964bfd5cbf1", size = 32576, upload-time = "2025-06-27T02:24:19.711Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/43/62/a8601165ed940f5ef9f358cb02e71aa71c4001de98951a12f3d57a6bc9b7/exa_py-1.14.15.tar.gz", hash = "sha256:996c82fb5bd64efb4a0ac04de48c57239cffe1c432262c8872bfde9c9d7c46da", size = 34262, upload-time = "2025-07-03T00:33:34.636Z" }
wheels = [
- { url = "https://files.pythonhosted.org/packages/25/d1/0ab4e64bd859fdda9b27a97b883688bf969768ccc7d166463cbeeee3a9ed/exa_py-1.14.13-py3-none-any.whl", hash = "sha256:d5d6331181d08bff91205fbaf91db4c52685d7dc66b01377b192c955688cb5c5", size = 42051, upload-time = "2025-06-27T02:24:18.712Z" },
+ { url = "https://files.pythonhosted.org/packages/ba/e7/4a8c5a8fc9960472c4846fc2735b95e360189b9adada4545b1d819512be8/exa_py-1.14.15-py3-none-any.whl", hash = "sha256:f8efcc47b4cbc451c07441e171e2546bc18b378ee50ce9b837dc0d81790cdd37", size = 43928, upload-time = "2025-07-03T00:33:33.635Z" },
]
[[package]]
@@ -2509,35 +2510,35 @@ wheels = [
[[package]]
name = "fonttools"
-version = "4.58.4"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/2e/5a/1124b2c8cb3a8015faf552e92714040bcdbc145dfa29928891b02d147a18/fonttools-4.58.4.tar.gz", hash = "sha256:928a8009b9884ed3aae17724b960987575155ca23c6f0b8146e400cc9e0d44ba", size = 3525026, upload-time = "2025-06-13T17:25:15.426Z" }
-wheels = [
- { url = "https://files.pythonhosted.org/packages/ed/86/d22c24caa574449b56e994ed1a96d23b23af85557fb62a92df96439d3f6c/fonttools-4.58.4-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:834542f13fee7625ad753b2db035edb674b07522fcbdd0ed9e9a9e2a1034467f", size = 2748349, upload-time = "2025-06-13T17:23:49.179Z" },
- { url = "https://files.pythonhosted.org/packages/f9/b8/384aca93856def00e7de30341f1e27f439694857d82c35d74a809c705ed0/fonttools-4.58.4-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:2e6c61ce330142525296170cd65666e46121fc0d44383cbbcfa39cf8f58383df", size = 2318565, upload-time = "2025-06-13T17:23:52.144Z" },
- { url = "https://files.pythonhosted.org/packages/1a/f2/273edfdc8d9db89ecfbbf659bd894f7e07b6d53448b19837a4bdba148d17/fonttools-4.58.4-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e9c75f8faa29579c0fbf29b56ae6a3660c6c025f3b671803cb6a9caa7e4e3a98", size = 4838855, upload-time = "2025-06-13T17:23:54.039Z" },
- { url = "https://files.pythonhosted.org/packages/13/fa/403703548c093c30b52ab37e109b369558afa221130e67f06bef7513f28a/fonttools-4.58.4-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:88dedcedbd5549e35b2ea3db3de02579c27e62e51af56779c021e7b33caadd0e", size = 4767637, upload-time = "2025-06-13T17:23:56.17Z" },
- { url = "https://files.pythonhosted.org/packages/6e/a8/3380e1e0bff6defb0f81c9abf274a5b4a0f30bc8cab4fd4e346c6f923b4c/fonttools-4.58.4-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:ae80a895adab43586f4da1521d58fd4f4377cef322ee0cc205abcefa3a5effc3", size = 4819397, upload-time = "2025-06-13T17:23:58.263Z" },
- { url = "https://files.pythonhosted.org/packages/cd/1b/99e47eb17a8ca51d808622a4658584fa8f340857438a4e9d7ac326d4a041/fonttools-4.58.4-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:0d3acc7f0d151da116e87a182aefb569cf0a3c8e0fd4c9cd0a7c1e7d3e7adb26", size = 4926641, upload-time = "2025-06-13T17:24:00.368Z" },
- { url = "https://files.pythonhosted.org/packages/31/75/415254408f038e35b36c8525fc31feb8561f98445688dd2267c23eafd7a2/fonttools-4.58.4-cp310-cp310-win32.whl", hash = "sha256:1244f69686008e7e8d2581d9f37eef330a73fee3843f1107993eb82c9d306577", size = 2201917, upload-time = "2025-06-13T17:24:02.587Z" },
- { url = "https://files.pythonhosted.org/packages/c5/69/f019a15ed2946317c5318e1bcc8876f8a54a313848604ad1d4cfc4c07916/fonttools-4.58.4-cp310-cp310-win_amd64.whl", hash = "sha256:2a66c0af8a01eb2b78645af60f3b787de5fe5eb1fd8348163715b80bdbfbde1f", size = 2246327, upload-time = "2025-06-13T17:24:04.087Z" },
- { url = "https://files.pythonhosted.org/packages/17/7b/cc6e9bb41bab223bd2dc70ba0b21386b85f604e27f4c3206b4205085a2ab/fonttools-4.58.4-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:a3841991c9ee2dc0562eb7f23d333d34ce81e8e27c903846f0487da21e0028eb", size = 2768901, upload-time = "2025-06-13T17:24:05.901Z" },
- { url = "https://files.pythonhosted.org/packages/3d/15/98d75df9f2b4e7605f3260359ad6e18e027c11fa549f74fce567270ac891/fonttools-4.58.4-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:3c98f91b6a9604e7ffb5ece6ea346fa617f967c2c0944228801246ed56084664", size = 2328696, upload-time = "2025-06-13T17:24:09.18Z" },
- { url = "https://files.pythonhosted.org/packages/a8/c8/dc92b80f5452c9c40164e01b3f78f04b835a00e673bd9355ca257008ff61/fonttools-4.58.4-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ab9f891eb687ddf6a4e5f82901e00f992e18012ca97ab7acd15f13632acd14c1", size = 5018830, upload-time = "2025-06-13T17:24:11.282Z" },
- { url = "https://files.pythonhosted.org/packages/19/48/8322cf177680505d6b0b6062e204f01860cb573466a88077a9b795cb70e8/fonttools-4.58.4-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:891c5771e8f0094b7c0dc90eda8fc75e72930b32581418f2c285a9feedfd9a68", size = 4960922, upload-time = "2025-06-13T17:24:14.9Z" },
- { url = "https://files.pythonhosted.org/packages/14/e0/2aff149ed7eb0916de36da513d473c6fff574a7146891ce42de914899395/fonttools-4.58.4-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:43ba4d9646045c375d22e3473b7d82b18b31ee2ac715cd94220ffab7bc2d5c1d", size = 4997135, upload-time = "2025-06-13T17:24:16.959Z" },
- { url = "https://files.pythonhosted.org/packages/e6/6f/4d9829b29a64a2e63a121cb11ecb1b6a9524086eef3e35470949837a1692/fonttools-4.58.4-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:33d19f16e6d2ffd6669bda574a6589941f6c99a8d5cfb9f464038244c71555de", size = 5108701, upload-time = "2025-06-13T17:24:18.849Z" },
- { url = "https://files.pythonhosted.org/packages/6f/1e/2d656ddd1b0cd0d222f44b2d008052c2689e66b702b9af1cd8903ddce319/fonttools-4.58.4-cp311-cp311-win32.whl", hash = "sha256:b59e5109b907da19dc9df1287454821a34a75f2632a491dd406e46ff432c2a24", size = 2200177, upload-time = "2025-06-13T17:24:20.823Z" },
- { url = "https://files.pythonhosted.org/packages/fb/83/ba71ad053fddf4157cb0697c8da8eff6718d059f2a22986fa5f312b49c92/fonttools-4.58.4-cp311-cp311-win_amd64.whl", hash = "sha256:3d471a5b567a0d1648f2e148c9a8bcf00d9ac76eb89e976d9976582044cc2509", size = 2247892, upload-time = "2025-06-13T17:24:22.927Z" },
- { url = "https://files.pythonhosted.org/packages/04/3c/1d1792bfe91ef46f22a3d23b4deb514c325e73c17d4f196b385b5e2faf1c/fonttools-4.58.4-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:462211c0f37a278494e74267a994f6be9a2023d0557aaa9ecbcbfce0f403b5a6", size = 2754082, upload-time = "2025-06-13T17:24:24.862Z" },
- { url = "https://files.pythonhosted.org/packages/2a/1f/2b261689c901a1c3bc57a6690b0b9fc21a9a93a8b0c83aae911d3149f34e/fonttools-4.58.4-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:0c7a12fb6f769165547f00fcaa8d0df9517603ae7e04b625e5acb8639809b82d", size = 2321677, upload-time = "2025-06-13T17:24:26.815Z" },
- { url = "https://files.pythonhosted.org/packages/fe/6b/4607add1755a1e6581ae1fc0c9a640648e0d9cdd6591cc2d581c2e07b8c3/fonttools-4.58.4-cp312-cp312-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:2d42c63020a922154add0a326388a60a55504629edc3274bc273cd3806b4659f", size = 4896354, upload-time = "2025-06-13T17:24:28.428Z" },
- { url = "https://files.pythonhosted.org/packages/cd/95/34b4f483643d0cb11a1f830b72c03fdd18dbd3792d77a2eb2e130a96fada/fonttools-4.58.4-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8f2b4e6fd45edc6805f5f2c355590b092ffc7e10a945bd6a569fc66c1d2ae7aa", size = 4941633, upload-time = "2025-06-13T17:24:30.568Z" },
- { url = "https://files.pythonhosted.org/packages/81/ac/9bafbdb7694059c960de523e643fa5a61dd2f698f3f72c0ca18ae99257c7/fonttools-4.58.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:f155b927f6efb1213a79334e4cb9904d1e18973376ffc17a0d7cd43d31981f1e", size = 4886170, upload-time = "2025-06-13T17:24:32.724Z" },
- { url = "https://files.pythonhosted.org/packages/ae/44/a3a3b70d5709405f7525bb7cb497b4e46151e0c02e3c8a0e40e5e9fe030b/fonttools-4.58.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e38f687d5de97c7fb7da3e58169fb5ba349e464e141f83c3c2e2beb91d317816", size = 5037851, upload-time = "2025-06-13T17:24:35.034Z" },
- { url = "https://files.pythonhosted.org/packages/21/cb/e8923d197c78969454eb876a4a55a07b59c9c4c46598f02b02411dc3b45c/fonttools-4.58.4-cp312-cp312-win32.whl", hash = "sha256:636c073b4da9db053aa683db99580cac0f7c213a953b678f69acbca3443c12cc", size = 2187428, upload-time = "2025-06-13T17:24:36.996Z" },
- { url = "https://files.pythonhosted.org/packages/46/e6/fe50183b1a0e1018e7487ee740fa8bb127b9f5075a41e20d017201e8ab14/fonttools-4.58.4-cp312-cp312-win_amd64.whl", hash = "sha256:82e8470535743409b30913ba2822e20077acf9ea70acec40b10fcf5671dceb58", size = 2236649, upload-time = "2025-06-13T17:24:38.985Z" },
- { url = "https://files.pythonhosted.org/packages/0b/2f/c536b5b9bb3c071e91d536a4d11f969e911dbb6b227939f4c5b0bca090df/fonttools-4.58.4-py3-none-any.whl", hash = "sha256:a10ce13a13f26cbb9f37512a4346bb437ad7e002ff6fa966a7ce7ff5ac3528bd", size = 1114660, upload-time = "2025-06-13T17:25:13.321Z" },
+version = "4.58.5"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/52/97/5735503e58d3816b0989955ef9b2df07e4c99b246469bd8b3823a14095da/fonttools-4.58.5.tar.gz", hash = "sha256:b2a35b0a19f1837284b3a23dd64fd7761b8911d50911ecd2bdbaf5b2d1b5df9c", size = 3526243, upload-time = "2025-07-03T14:04:47.736Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/0b/cd/d2a50d9e9e9f01491993acd557051a05b0bbe57eb47710c6381dca741ac9/fonttools-4.58.5-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:d500d399aa4e92d969a0d21052696fa762385bb23c3e733703af4a195ad9f34c", size = 2749015, upload-time = "2025-07-03T14:03:15.683Z" },
+ { url = "https://files.pythonhosted.org/packages/ee/5e/8f9a4781f79042b2efb68a1636b9013c54f80311dbbc05e6a4bacdaf7661/fonttools-4.58.5-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:b00530b84f87792891874938bd42f47af2f7f4c2a1d70466e6eb7166577853ab", size = 2319224, upload-time = "2025-07-03T14:03:18.627Z" },
+ { url = "https://files.pythonhosted.org/packages/51/87/dddb6c9b4af1f49b100e3ec84d45c769947fd8e58943d35a58f27aa017b0/fonttools-4.58.5-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c5579fb3744dfec151b5c29b35857df83e01f06fe446e8c2ebaf1effd7e6cdce", size = 4839510, upload-time = "2025-07-03T14:03:22.785Z" },
+ { url = "https://files.pythonhosted.org/packages/30/57/63fd49a3328e39e3f8868dd0b0f00370f4f40c4bd44a8478efad3338ebd9/fonttools-4.58.5-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:adf440deecfcc2390998e649156e3bdd0b615863228c484732dc06ac04f57385", size = 4768294, upload-time = "2025-07-03T14:03:24.853Z" },
+ { url = "https://files.pythonhosted.org/packages/84/1a/e943dfecf56b48d7e684be7c37749c48560461d14f480b4e7c42285976ce/fonttools-4.58.5-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:a81769fc4d473c808310c9ed91fbe01b67f615e3196fb9773e093939f59e6783", size = 4820057, upload-time = "2025-07-03T14:03:26.939Z" },
+ { url = "https://files.pythonhosted.org/packages/02/68/04e9dd0b711ca720f5473adde9325941c73faf947b771ea21fac9e3613c3/fonttools-4.58.5-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:0162a6a37b0ca70d8505311d541e291cd6cab54d1a986ae3d2686c56c0581e8f", size = 4927299, upload-time = "2025-07-03T14:03:29.136Z" },
+ { url = "https://files.pythonhosted.org/packages/80/82/9d36a24c47ae4b93377332343b4f018c965e9c4835bbebaed951f99784d0/fonttools-4.58.5-cp310-cp310-win32.whl", hash = "sha256:1cde303422198fdc7f502dbdf1bf65306166cdb9446debd6c7fb826b4d66a530", size = 2203042, upload-time = "2025-07-03T14:03:31.139Z" },
+ { url = "https://files.pythonhosted.org/packages/b7/d1/c2c3582d575ef901cad6cfbe77aa5396debd652f51bf32b6963245f00dfa/fonttools-4.58.5-cp310-cp310-win_amd64.whl", hash = "sha256:75cf8c2812c898dd3d70d62b2b768df4eeb524a83fb987a512ddb3863d6a8c54", size = 2247338, upload-time = "2025-07-03T14:03:33.24Z" },
+ { url = "https://files.pythonhosted.org/packages/14/50/26c683bf6f30dcbde6955c8e07ec6af23764aab86ff06b36383654ab6739/fonttools-4.58.5-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:cda226253bf14c559bc5a17c570d46abd70315c9a687d91c0e01147f87736182", size = 2769557, upload-time = "2025-07-03T14:03:35.383Z" },
+ { url = "https://files.pythonhosted.org/packages/b1/00/c3c75fb6196b9ff9988e6a82319ae23f4ae7098e1c01e2408e58d2e7d9c7/fonttools-4.58.5-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:83a96e4a4e65efd6c098da549ec34f328f08963acd2d7bc910ceba01d2dc73e6", size = 2329367, upload-time = "2025-07-03T14:03:37.322Z" },
+ { url = "https://files.pythonhosted.org/packages/59/e9/6946366c8e88650c199da9b284559de5d47a6e66ed6d175a166953347959/fonttools-4.58.5-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2d172b92dff59ef8929b4452d5a7b19b8e92081aa87bfb2d82b03b1ff14fc667", size = 5019491, upload-time = "2025-07-03T14:03:39.759Z" },
+ { url = "https://files.pythonhosted.org/packages/76/12/2f3f7d09bba7a93bd48dcb54b170fba665f0b7e80e959ac831b907d40785/fonttools-4.58.5-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:0bfddfd09aafbbfb3bd98ae67415fbe51eccd614c17db0c8844fe724fbc5d43d", size = 4961579, upload-time = "2025-07-03T14:03:41.611Z" },
+ { url = "https://files.pythonhosted.org/packages/2c/95/87e84071189e51c714074646dfac8275b2e9c6b2b118600529cc74f7451e/fonttools-4.58.5-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:cfde5045f1bc92ad11b4b7551807564045a1b38cb037eb3c2bc4e737cd3a8d0f", size = 4997792, upload-time = "2025-07-03T14:03:44.529Z" },
+ { url = "https://files.pythonhosted.org/packages/73/47/5c4df7473ecbeb8aa4e01373e4f614ca33f53227fe13ae673c6d5ca99be7/fonttools-4.58.5-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:3515ac47a9a5ac025d2899d195198314023d89492340ba86e4ba79451f7518a8", size = 5109361, upload-time = "2025-07-03T14:03:46.693Z" },
+ { url = "https://files.pythonhosted.org/packages/06/00/31406853c570210232b845e08e5a566e15495910790381566ffdbdc7f9a2/fonttools-4.58.5-cp311-cp311-win32.whl", hash = "sha256:9f7e2ab9c10b6811b4f12a0768661325a48e664ec0a0530232c1605896a598db", size = 2201369, upload-time = "2025-07-03T14:03:48.885Z" },
+ { url = "https://files.pythonhosted.org/packages/c5/90/ac0facb57962cef53a5734d0be5d2f2936e55aa5c62647c38ca3497263d8/fonttools-4.58.5-cp311-cp311-win_amd64.whl", hash = "sha256:126c16ec4a672c9cb5c1c255dc438d15436b470afc8e9cac25a2d39dd2dc26eb", size = 2249021, upload-time = "2025-07-03T14:03:51.232Z" },
+ { url = "https://files.pythonhosted.org/packages/d6/68/66b498ee66f3e7e92fd68476c2509508082b7f57d68c0cdb4b8573f44331/fonttools-4.58.5-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:c3af3fefaafb570a03051a0d6899b8374dcf8e6a4560e42575843aef33bdbad6", size = 2754751, upload-time = "2025-07-03T14:03:52.976Z" },
+ { url = "https://files.pythonhosted.org/packages/f1/1e/edbc14b79290980c3944a1f43098624bc8965f534964aa03d52041f24cb4/fonttools-4.58.5-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:688137789dbd44e8757ad77b49a771539d8069195ffa9a8bcf18176e90bbd86d", size = 2322342, upload-time = "2025-07-03T14:03:54.957Z" },
+ { url = "https://files.pythonhosted.org/packages/c1/d7/3c87cf147185d91c2e946460a5cf68c236427b4a23ab96793ccb7d8017c9/fonttools-4.58.5-cp312-cp312-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:2af65836cf84cd7cb882d0b353bdc73643a497ce23b7414c26499bb8128ca1af", size = 4897011, upload-time = "2025-07-03T14:03:56.829Z" },
+ { url = "https://files.pythonhosted.org/packages/a0/d6/fbb44cc85d4195fe54356658bd9f934328b4f74ae14addd90b4b5558b5c9/fonttools-4.58.5-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d2d79cfeb456bf438cb9fb87437634d4d6f228f27572ca5c5355e58472d5519d", size = 4942291, upload-time = "2025-07-03T14:03:59.204Z" },
+ { url = "https://files.pythonhosted.org/packages/4d/c8/453f82e21aedf25cdc2ae619c03a73512398cec9bd8b6c3b1c571e0b6632/fonttools-4.58.5-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:0feac9dda9a48a7a342a593f35d50a5cee2dbd27a03a4c4a5192834a4853b204", size = 4886824, upload-time = "2025-07-03T14:04:01.517Z" },
+ { url = "https://files.pythonhosted.org/packages/40/54/e9190001b8e22d123f78925b2f508c866d9d18531694b979277ad45d59b0/fonttools-4.58.5-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:36555230e168511e83ad8637232268649634b8dfff6ef58f46e1ebc057a041ad", size = 5038510, upload-time = "2025-07-03T14:04:03.917Z" },
+ { url = "https://files.pythonhosted.org/packages/cf/9c/07cdad4774841a6304aabae939f8cbb9538cb1d8e97f5016b334da98e73a/fonttools-4.58.5-cp312-cp312-win32.whl", hash = "sha256:26ec05319353842d127bd02516eacb25b97ca83966e40e9ad6fab85cab0576f4", size = 2188459, upload-time = "2025-07-03T14:04:06.103Z" },
+ { url = "https://files.pythonhosted.org/packages/0e/4d/1eaaad22781d55f49d1b184563842172aeb6a4fe53c029e503be81114314/fonttools-4.58.5-cp312-cp312-win_amd64.whl", hash = "sha256:778a632e538f82c1920579c0c01566a8f83dc24470c96efbf2fbac698907f569", size = 2236565, upload-time = "2025-07-03T14:04:08.27Z" },
+ { url = "https://files.pythonhosted.org/packages/d7/d4/1d85a1996b6188cd2713230e002d79a6f3a289bb17cef600cba385848b72/fonttools-4.58.5-py3-none-any.whl", hash = "sha256:e48a487ed24d9b611c5c4b25db1e50e69e9854ca2670e39a3486ffcd98863ec4", size = 1115318, upload-time = "2025-07-03T14:04:45.378Z" },
]
[[package]]
@@ -3161,7 +3162,7 @@ wheels = [
[[package]]
name = "huggingface-hub"
-version = "0.33.1"
+version = "0.33.2"
source = { registry = "https://pypi.org/simple" }
dependencies = [
{ name = "filelock" },
@@ -3173,9 +3174,9 @@ dependencies = [
{ name = "tqdm" },
{ name = "typing-extensions" },
]
-sdist = { url = "https://files.pythonhosted.org/packages/a4/01/bfe0534a63ce7a2285e90dbb33e8a5b815ff096d8f7743b135c256916589/huggingface_hub-0.33.1.tar.gz", hash = "sha256:589b634f979da3ea4b8bdb3d79f97f547840dc83715918daf0b64209c0844c7b", size = 426728, upload-time = "2025-06-25T12:02:57.605Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/fa/42/8a95c5632080ae312c0498744b2b852195e10b05a20b1be11c5141092f4c/huggingface_hub-0.33.2.tar.gz", hash = "sha256:84221defaec8fa09c090390cd68c78b88e3c4c2b7befba68d3dc5aacbc3c2c5f", size = 426637, upload-time = "2025-07-02T06:26:05.156Z" }
wheels = [
- { url = "https://files.pythonhosted.org/packages/d0/fb/5307bd3612eb0f0e62c3a916ae531d3a31e58fb5c82b58e3ebf7fd6f47a1/huggingface_hub-0.33.1-py3-none-any.whl", hash = "sha256:ec8d7444628210c0ba27e968e3c4c973032d44dcea59ca0d78ef3f612196f095", size = 515377, upload-time = "2025-06-25T12:02:55.611Z" },
+ { url = "https://files.pythonhosted.org/packages/44/f4/5f3f22e762ad1965f01122b42dae5bf0e009286e2dba601ce1d0dba72424/huggingface_hub-0.33.2-py3-none-any.whl", hash = "sha256:3749498bfa91e8cde2ddc2c1db92c79981f40e66434c20133b39e5928ac9bcc5", size = 515373, upload-time = "2025-07-02T06:26:03.072Z" },
]
[[package]]
@@ -3233,9 +3234,10 @@ sdist = { url = "https://files.pythonhosted.org/packages/8e/ca/3c4c48c2a180e3410
[[package]]
name = "ibm-watsonx-ai"
-version = "1.3.26"
+version = "1.3.28"
source = { registry = "https://pypi.org/simple" }
dependencies = [
+ { name = "cachetools" },
{ name = "certifi" },
{ name = "httpx" },
{ name = "ibm-cos-sdk" },
@@ -3246,9 +3248,9 @@ dependencies = [
{ name = "tabulate" },
{ name = "urllib3" },
]
-sdist = { url = "https://files.pythonhosted.org/packages/c1/06/f9a8e0fc2c39a8071bbc4b1e28b1d3dbda1441ba598fc8608cfc8bf69f94/ibm_watsonx_ai-1.3.26.tar.gz", hash = "sha256:e7953f4a552d1724c11ffbae999fa87153cc8e56e0cdb12ff536b0b5237d0929", size = 740974, upload-time = "2025-06-12T07:52:37.119Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/ca/0d/5c03c406ef2c04928d707784ab695535b64130adad267bb6c74a8b465dcc/ibm_watsonx_ai-1.3.28.tar.gz", hash = "sha256:b66c754320334e0fd5396ec3661344bb621983c0b12d89677fd7afdfdb44ddf0", size = 745752, upload-time = "2025-07-02T17:33:37.516Z" }
wheels = [
- { url = "https://files.pythonhosted.org/packages/3b/97/7623e777f46ac00863592ed7334bba8174c24c46fdde0df053a8bd08606f/ibm_watsonx_ai-1.3.26-py3-none-any.whl", hash = "sha256:f891efd39e90f20d16db2c3eb5d6d690f8c4263eb9423fbd2a91f59d8927e6d7", size = 1149090, upload-time = "2025-06-12T07:52:34.832Z" },
+ { url = "https://files.pythonhosted.org/packages/7b/b7/5d38308f22166f3935e686f37a7d40c234bed7c63b7a397b992c51efbf6e/ibm_watsonx_ai-1.3.28-py3-none-any.whl", hash = "sha256:f564e1ddea5728301ed28cdc1fafda2070e3d87522c348d77e09cd419edec9b2", size = 1154449, upload-time = "2025-07-02T17:33:35.783Z" },
]
[[package]]
@@ -3709,7 +3711,7 @@ sdist = { url = "https://files.pythonhosted.org/packages/0e/72/a3add0e4eec4eb9e2
[[package]]
name = "langfuse"
-version = "3.0.9"
+version = "3.1.2"
source = { registry = "https://pypi.org/simple" }
dependencies = [
{ name = "backoff" },
@@ -3722,9 +3724,9 @@ dependencies = [
{ name = "requests" },
{ name = "wrapt" },
]
-sdist = { url = "https://files.pythonhosted.org/packages/5d/d6/58ab49a27921ac98d11f78060016bcd07674d599e82197448638f6b7f14e/langfuse-3.0.9.tar.gz", hash = "sha256:db0423868f6295f5eaf729b1b86f3d82837b9582c7718a820d413014002308ca", size = 149898, upload-time = "2025-07-01T13:47:48.797Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/7c/2c/a77548129f2409b53c466cda901d671b17a36d2b792d2d94a52ece4b3cd3/langfuse-3.1.2.tar.gz", hash = "sha256:1caaf02ce51ab327ba8cc39ca42f719924849d5f0127b2801705c6993953ff41", size = 151154, upload-time = "2025-07-04T14:37:45.967Z" }
wheels = [
- { url = "https://files.pythonhosted.org/packages/1c/39/3c5403e285a54532a5d486624c9d2dfef0aa189a98d91331ff1d0d16ec32/langfuse-3.0.9-py3-none-any.whl", hash = "sha256:ed79bcf060577c6fa2f3c3854c59ca46268d0127dd8e5c5fb48feb574cb42181", size = 294424, upload-time = "2025-07-01T13:47:46.927Z" },
+ { url = "https://files.pythonhosted.org/packages/f1/d6/e5990d30a9f7a9975ba706e10364bea4392a0148f44f3e1c70fad015e110/langfuse-3.1.2-py3-none-any.whl", hash = "sha256:cbfaa16834753a22abc9393c745d221eeaa4c2f008f9bf2089a999b8bbce4a8e", size = 297281, upload-time = "2025-07-04T14:37:44.314Z" },
]
[[package]]
@@ -3782,7 +3784,7 @@ wheels = [
[[package]]
name = "litellm"
-version = "1.73.6"
+version = "1.74.0"
source = { registry = "https://pypi.org/simple" }
dependencies = [
{ name = "aiohttp" },
@@ -3797,9 +3799,9 @@ dependencies = [
{ name = "tiktoken" },
{ name = "tokenizers" },
]
-sdist = { url = "https://files.pythonhosted.org/packages/26/58/1a8ecf64b9a1f01dbddc123200f3156638c919fc3de683bd206235ccd33c/litellm-1.73.6.tar.gz", hash = "sha256:072ff9225aaa9caafe0fa9782df0ba4c93f893791cc55dd5ed218a401e788e88", size = 8750656, upload-time = "2025-06-28T20:05:38.654Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/24/1f/eb4a931e7bc5fc7ab398df61df75801a0825dcd7edeecf5ccd07d427c36e/litellm-1.74.0.tar.gz", hash = "sha256:2ee64579568cc81835025db45da6d91ee7ec6706ab4adf1a833866999ed822e7", size = 9095626, upload-time = "2025-07-05T05:16:24.576Z" }
wheels = [
- { url = "https://files.pythonhosted.org/packages/81/be/3e9a3097c3b25bd1bc24073afdf5e6316120d8f4127e38bd6dcc3e193f55/litellm-1.73.6-py3-none-any.whl", hash = "sha256:98b3c7f436e6521e280f98faf9bad06c4c76d6a1678db2b370ffa175c206d288", size = 8467603, upload-time = "2025-06-28T20:05:36.325Z" },
+ { url = "https://files.pythonhosted.org/packages/8b/28/ada87d58dc4dfaf8a1858df712b9c21c3775d6c7d303598e9ab3a57a63cf/litellm-1.74.0-py3-none-any.whl", hash = "sha256:f6c41169e0dbf182c2d74a0b9e146f1c67735351a721c8498eea7ec6306be309", size = 8567304, upload-time = "2025-07-05T05:16:21.993Z" },
]
[[package]]
@@ -4136,7 +4138,7 @@ wheels = [
[[package]]
name = "mem0ai"
-version = "0.1.113"
+version = "0.1.114"
source = { registry = "https://pypi.org/simple" }
dependencies = [
{ name = "openai" },
@@ -4146,9 +4148,9 @@ dependencies = [
{ name = "qdrant-client" },
{ name = "sqlalchemy" },
]
-sdist = { url = "https://files.pythonhosted.org/packages/9e/d1/7664b4a0f9bc234d0214f1a70bbb4446fe08a8cc5b50de3492cdc28017f0/mem0ai-0.1.113.tar.gz", hash = "sha256:f6b5aff930e2de574630264a5d54d22404bb8f82e3d577a17bcbc13ca759293e", size = 108426, upload-time = "2025-06-30T08:03:18.659Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/87/47/81f43e173940d000694eb20a70c0a92149c53edd2095e34b618afa41ca7d/mem0ai-0.1.114.tar.gz", hash = "sha256:b27886132eaec78544e8b8b54f0b14a36728f3c99da54cb7cb417150e2fad7e1", size = 113652, upload-time = "2025-07-04T23:31:28.537Z" }
wheels = [
- { url = "https://files.pythonhosted.org/packages/98/0b/1d8204418bc69f9763f141e1f88e72a09a2fa7af54de156022e67f1dac62/mem0ai-0.1.113-py3-none-any.whl", hash = "sha256:0b68fe5b2786bb4da59cd8dae53ccf8f59024eb1078af42489930281ea5dd785", size = 168264, upload-time = "2025-06-30T08:03:16.912Z" },
+ { url = "https://files.pythonhosted.org/packages/5e/b7/50d1d1d0600e9e5a861e733644513816011504b9a3d0ba870eadb32a481f/mem0ai-0.1.114-py3-none-any.whl", hash = "sha256:dfb7f0079ee282f5d9782e220f6f09707bcf5e107925d1901dbca30d8dd83f9b", size = 174843, upload-time = "2025-07-04T23:31:26.912Z" },
]
[[package]]
@@ -5307,7 +5309,7 @@ wheels = [
[[package]]
name = "posthog"
-version = "6.0.1"
+version = "6.0.2"
source = { registry = "https://pypi.org/simple" }
dependencies = [
{ name = "backoff" },
@@ -5317,9 +5319,9 @@ dependencies = [
{ name = "six" },
{ name = "typing-extensions" },
]
-sdist = { url = "https://files.pythonhosted.org/packages/86/0f/442860ec60985705b4ca5465274284e6bd1916eda535586198fe0a7edb77/posthog-6.0.1.tar.gz", hash = "sha256:c0f28bfc0f1dc8d4b47aa2bed670343273fa1d69f1e775313d78eec3cb169daa", size = 88108, upload-time = "2025-07-01T12:27:23.935Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/d9/10/37ea988b3ae73cbfd1f2d5e523cca31cecfcc40cbd0de6511f40462fdb78/posthog-6.0.2.tar.gz", hash = "sha256:94a28e65d7a2d1b2952e53a1b97fa4d6504b8d7e4c197c57f653621e55b549eb", size = 88141, upload-time = "2025-07-02T19:21:50.306Z" }
wheels = [
- { url = "https://files.pythonhosted.org/packages/0f/09/4f3dc1c5f330f76da0cc5c85d7eb42aa5da9d9d1d22f1385d95466cec7da/posthog-6.0.1-py3-none-any.whl", hash = "sha256:fab081cba269b743cfdc995692f97d71ef3e952c414188415158f5a5c37b1848", size = 104956, upload-time = "2025-07-01T12:27:21.48Z" },
+ { url = "https://files.pythonhosted.org/packages/85/2c/0c5dbbf9bc30401ae2a1b6b52b8abc19e4060cf28c3288ae9d962e65e3ad/posthog-6.0.2-py3-none-any.whl", hash = "sha256:756cc9adad9e42961454f8ac391b92a2f70ebb6607d29b0c568de08e5d8f1b18", size = 104946, upload-time = "2025-07-02T19:21:48.77Z" },
]
[[package]]
@@ -5894,7 +5896,7 @@ sdist = { url = "https://files.pythonhosted.org/packages/6d/a8/10cf6b955b5fa1943
[[package]]
name = "pymilvus"
-version = "2.5.11"
+version = "2.5.12"
source = { registry = "https://pypi.org/simple" }
dependencies = [
{ name = "grpcio" },
@@ -5905,9 +5907,9 @@ dependencies = [
{ name = "setuptools" },
{ name = "ujson" },
]
-sdist = { url = "https://files.pythonhosted.org/packages/e4/d9/3a76b1f5014a20efcfe1bb0aa46423d9cf1df5ab2ce8b1479248b943692a/pymilvus-2.5.11.tar.gz", hash = "sha256:cb1c291c659da73c58f2f5c2bd5bcbb87feb76f720afd72b9e7ace813d384c83", size = 1262466, upload-time = "2025-06-10T00:41:54.295Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/fa/53/4af820a37163225a76656222ee43a0eb8f1bd2ceec063315680a585435da/pymilvus-2.5.12.tar.gz", hash = "sha256:79ec7dc0616c2484f77abe98bca8deafb613645b5703c492b51961afd4f985d8", size = 1265893, upload-time = "2025-07-02T15:34:00.385Z" }
wheels = [
- { url = "https://files.pythonhosted.org/packages/e7/2c/a9f2c2daff511e127616a4294e597bf4c7626d49865f62865432698c7ba9/pymilvus-2.5.11-py3-none-any.whl", hash = "sha256:20417ea0f364cd8e9d3783b432ad25c32cff8f3ceb40cdfdf54f8bbcf052cd7e", size = 228115, upload-time = "2025-06-10T00:41:52.354Z" },
+ { url = "https://files.pythonhosted.org/packages/68/4f/80a4940f2772d10272c3292444af767a5aa1a5bbb631874568713ca01d54/pymilvus-2.5.12-py3-none-any.whl", hash = "sha256:ef77a4a0076469a30b05f0bb23b5a058acfbdca83d82af9574ca651764017f44", size = 231425, upload-time = "2025-07-02T15:33:58.938Z" },
]
[[package]]
@@ -5918,17 +5920,17 @@ sdist = { url = "https://files.pythonhosted.org/packages/7d/ff/4c6f31a4f08979f12
[[package]]
name = "pymupdf"
-version = "1.26.1"
+version = "1.26.3"
source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/bd/62/d29612ca33b7844e77d2c789fec359f4c44fd84bdd08ce673f6279d257e9/pymupdf-1.26.1.tar.gz", hash = "sha256:372c77c831f82090ce7a6e4de284ca7c5a78220f63038bb28c5d9b279cd7f4d9", size = 75912371, upload-time = "2025-06-11T22:18:30.932Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/6d/d4/70a265e4bcd43e97480ae62da69396ef4507c8f9cfd179005ee731c92a04/pymupdf-1.26.3.tar.gz", hash = "sha256:b7d2c3ffa9870e1e4416d18862f5ccd356af5fe337b4511093bbbce2ca73b7e5", size = 75990308, upload-time = "2025-07-02T21:34:22.243Z" }
wheels = [
- { url = "https://files.pythonhosted.org/packages/32/5a/3399a2caf51c91db650de57464465b830c2d4ea15b23d24a98182202b704/pymupdf-1.26.1-cp39-abi3-macosx_10_9_x86_64.whl", hash = "sha256:32296f12a7c7f36febd59cee77823a54490313bcaba9879b17def6518186f94e", size = 23054640, upload-time = "2025-06-11T22:14:07.439Z" },
- { url = "https://files.pythonhosted.org/packages/64/e0/cc3ec6a4d5ada8992b8610f134565ceb517243f12736b50d795cb3459315/pymupdf-1.26.1-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:aad7949eca62aca40854510cdb125cf873b181726dc9497a90834200f31faa63", size = 22402766, upload-time = "2025-06-11T22:14:25.557Z" },
- { url = "https://files.pythonhosted.org/packages/e8/cf/d5b1cd775a17a7b83e25cbf4c46f64cf1352c962ca97646e3e01953cf0df/pymupdf-1.26.1-cp39-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:3b62c4d443121ed9a2eb967c3a0e45f8dbabcc838db8604ece02c4e868808edc", size = 23448474, upload-time = "2025-06-20T17:51:56.446Z" },
- { url = "https://files.pythonhosted.org/packages/82/9f/e7101bd24a0f5cbfa0310c8e5c3a8ec0dd9a86986812ff86ac2fbd273c92/pymupdf-1.26.1-cp39-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:a65c411eb1cbb79e40c307e10fbad23658f19e9d7334ac4de21d24b58009a7b9", size = 24056183, upload-time = "2025-06-11T22:14:53.777Z" },
- { url = "https://files.pythonhosted.org/packages/99/39/23ac15cf0edc2877ef366dc7ae041ac199d212433c2c3113661d1a1d5ad0/pymupdf-1.26.1-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:26cebdcc1b2b7a7445423599ce2e0000f2be0333cce0fa0e6846e5a7da46f965", size = 24258802, upload-time = "2025-06-11T22:15:20.499Z" },
- { url = "https://files.pythonhosted.org/packages/e1/8c/56bd5951128d5c5c0b64d2942090c2cd7bc44302bac991b941ac736e3d63/pymupdf-1.26.1-cp39-abi3-win32.whl", hash = "sha256:82ed9e106cf564fc959c0691c374ba68443086ba1a1c9f26128eebbc3e6df9e5", size = 16927933, upload-time = "2025-06-11T22:15:59.72Z" },
- { url = "https://files.pythonhosted.org/packages/a7/1b/0613759a059c8c952c18811c7c7dd0ba5d7945ed13a535719489f533d700/pymupdf-1.26.1-cp39-abi3-win_amd64.whl", hash = "sha256:8deae5168fce37d707f68d1981da6c0bb71f1f176d9835d5914ad46f779a036f", size = 18519587, upload-time = "2025-06-11T22:16:38.155Z" },
+ { url = "https://files.pythonhosted.org/packages/70/d3/c7af70545cd3097a869fd635bb6222108d3a0fb28c0b8254754a126c4cbb/pymupdf-1.26.3-cp39-abi3-macosx_10_9_x86_64.whl", hash = "sha256:ded891963944e5f13b03b88f6d9e982e816a4ec8689fe360876eef000c161f2b", size = 23057205, upload-time = "2025-07-02T21:26:16.326Z" },
+ { url = "https://files.pythonhosted.org/packages/04/3d/ec5b69bfeaa5deefa7141fc0b20d77bb20404507cf17196b4eb59f1f2977/pymupdf-1.26.3-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:436a33c738bb10eadf00395d18a6992b801ffb26521ee1f361ae786dd283327a", size = 22406630, upload-time = "2025-07-02T21:27:10.112Z" },
+ { url = "https://files.pythonhosted.org/packages/fc/20/661d3894bb05ad75ed6ca103ee2c3fa44d88a458b5c8d4a946b9c0f2569b/pymupdf-1.26.3-cp39-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:a2d7a3cd442f12f05103cb3bb1415111517f0a97162547a3720f3bbbc5e0b51c", size = 23450287, upload-time = "2025-07-03T07:22:19.317Z" },
+ { url = "https://files.pythonhosted.org/packages/9c/7f/21828f018e65b16a033731d21f7b46d93fa81c6e8257f769ca4a1c2a1cb0/pymupdf-1.26.3-cp39-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:454f38c8cf07eb333eb4646dca10517b6e90f57ce2daa2265a78064109d85555", size = 24057319, upload-time = "2025-07-02T21:28:26.697Z" },
+ { url = "https://files.pythonhosted.org/packages/71/5d/e8f88cd5a45b8f5fa6590ce8cef3ce0fad30eac6aac8aea12406f95bee7d/pymupdf-1.26.3-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:759b75d2f710ff4edf8d097d2e98f60e9ecef47632cead6f949b3412facdb9f0", size = 24261350, upload-time = "2025-07-02T21:29:21.733Z" },
+ { url = "https://files.pythonhosted.org/packages/82/22/ecc560e4f281b5dffafbf3a81f023d268b1746d028044f495115b74a2e70/pymupdf-1.26.3-cp39-abi3-win32.whl", hash = "sha256:a839ed44742faa1cd4956bb18068fe5aae435d67ce915e901318646c4e7bbea6", size = 17116371, upload-time = "2025-07-02T21:30:23.253Z" },
+ { url = "https://files.pythonhosted.org/packages/4a/26/8c72973b8833a72785cedc3981eb59b8ac7075942718bbb7b69b352cdde4/pymupdf-1.26.3-cp39-abi3-win_amd64.whl", hash = "sha256:b4cd5124d05737944636cf45fc37ce5824f10e707b0342efe109c7b6bd37a9cc", size = 18735124, upload-time = "2025-07-02T21:31:10.992Z" },
]
[[package]]
@@ -7844,7 +7846,7 @@ wheels = [
[[package]]
name = "transformers"
-version = "4.53.0"
+version = "4.53.1"
source = { registry = "https://pypi.org/simple" }
dependencies = [
{ name = "filelock" },
@@ -7858,9 +7860,9 @@ dependencies = [
{ name = "tokenizers" },
{ name = "tqdm" },
]
-sdist = { url = "https://files.pythonhosted.org/packages/e8/40/f2d2c3bcf5c6135027cab0fd7db52f6149a1c23acc4e45f914c43d362386/transformers-4.53.0.tar.gz", hash = "sha256:f89520011b4a73066fdc7aabfa158317c3934a22e3cd652d7ffbc512c4063841", size = 9177265, upload-time = "2025-06-26T16:10:54.729Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/9f/2c/68a0024c311db41bb92d4ec17d22e90b7406a4d28aa18d87662f2bbebcd9/transformers-4.53.1.tar.gz", hash = "sha256:da5a9f66ad480bc2a7f75bc32eaf735fd20ac56af4325ca4ce994021ceb37710", size = 9192189, upload-time = "2025-07-04T08:28:40.571Z" }
wheels = [
- { url = "https://files.pythonhosted.org/packages/5e/0c/68d03a38f6ab2ba2b2829eb11b334610dd236e7926787f7656001b68e1f2/transformers-4.53.0-py3-none-any.whl", hash = "sha256:7d8039ff032c01a2d7f8a8fe0066620367003275f023815a966e62203f9f5dd7", size = 10821970, upload-time = "2025-06-26T16:10:51.505Z" },
+ { url = "https://files.pythonhosted.org/packages/8d/10/8cef2288810a3210659eb3a20711e8387cc35a881a7762ae387806e2d651/transformers-4.53.1-py3-none-any.whl", hash = "sha256:c84f3c3e41c71fdf2c60c8a893e1cd31191b0cb463385f4c276302d2052d837b", size = 10825681, upload-time = "2025-07-04T08:28:37.318Z" },
]
[[package]]
@@ -8029,11 +8031,11 @@ wheels = [
[[package]]
name = "typing-extensions"
-version = "4.14.0"
+version = "4.14.1"
source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/d1/bc/51647cd02527e87d05cb083ccc402f93e441606ff1f01739a62c8ad09ba5/typing_extensions-4.14.0.tar.gz", hash = "sha256:8676b788e32f02ab42d9e7c61324048ae4c6d844a399eebace3d4979d75ceef4", size = 107423, upload-time = "2025-06-02T14:52:11.399Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/98/5a/da40306b885cc8c09109dc2e1abd358d5684b1425678151cdaed4731c822/typing_extensions-4.14.1.tar.gz", hash = "sha256:38b39f4aeeab64884ce9f74c94263ef78f3c22467c8724005483154c26648d36", size = 107673, upload-time = "2025-07-04T13:28:34.16Z" }
wheels = [
- { url = "https://files.pythonhosted.org/packages/69/e0/552843e0d356fbb5256d21449fa957fa4eff3bbc135a74a691ee70c7c5da/typing_extensions-4.14.0-py3-none-any.whl", hash = "sha256:a1514509136dd0b477638fc68d6a91497af5076466ad0fa6c338e44e359944af", size = 43839, upload-time = "2025-06-02T14:52:10.026Z" },
+ { url = "https://files.pythonhosted.org/packages/b5/00/d631e67a838026495268c2f6884f3711a15a9a2a96cd244fdaea53b823fb/typing_extensions-4.14.1-py3-none-any.whl", hash = "sha256:d1e1e3b58374dc93031d6eda2420a48ea44a36c2b4766a4fdeb3710755731d76", size = 43906, upload-time = "2025-07-04T13:28:32.743Z" },
]
[[package]]
@@ -8157,7 +8159,7 @@ wheels = [
[[package]]
name = "unstructured-client"
-version = "0.37.2"
+version = "0.38.1"
source = { registry = "https://pypi.org/simple" }
dependencies = [
{ name = "aiofiles" },
@@ -8168,9 +8170,9 @@ dependencies = [
{ name = "pypdf" },
{ name = "requests-toolbelt" },
]
-sdist = { url = "https://files.pythonhosted.org/packages/f9/9d/73a8df280c92260d4cb44fa3acb32865ef5729e5c06c603b5dde880e07fe/unstructured_client-0.37.2.tar.gz", hash = "sha256:936b67e7f1108248160d00ac0e673f06e2f6269d2955368ac523c0cd7c65af5e", size = 90272, upload-time = "2025-06-24T16:16:16.496Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/85/60/412092671bfc4952640739f2c0c9b2f4c8af26a3c921738fd12621b4ddd8/unstructured_client-0.38.1.tar.gz", hash = "sha256:43ab0670dd8ff53d71e74f9b6dfe490a84a5303dab80a4873e118a840c6d46ca", size = 91781, upload-time = "2025-07-03T15:46:35.054Z" }
wheels = [
- { url = "https://files.pythonhosted.org/packages/fa/03/024d832bb98716293e70507f1bb9f62771fb44fc20e63e425eb5b60792bb/unstructured_client-0.37.2-py3-none-any.whl", hash = "sha256:2bf5d55fc36ba06881b720eb8540400e60f70aaec011401075979b472cf45c60", size = 210724, upload-time = "2025-06-24T16:16:15.145Z" },
+ { url = "https://files.pythonhosted.org/packages/26/e0/8c249f00ba85fb4aba5c541463312befbfbf491105ff5c06e508089467be/unstructured_client-0.38.1-py3-none-any.whl", hash = "sha256:71e5467870d0a0119c788c29ec8baf5c0f7123f424affc9d6682eeeb7b8d45fa", size = 212626, upload-time = "2025-07-03T15:46:33.929Z" },
]
[[package]]
@@ -8210,27 +8212,27 @@ socks = [
[[package]]
name = "uv"
-version = "0.7.17"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/3d/46/4caac2d83e892dc5af557c99ea85b83977509658d964f3176a0d89943bf0/uv-0.7.17.tar.gz", hash = "sha256:afa3bc3d9ef414a40d49ae1e97b388d86b453d5018af9a30a9742f0e0389b30a", size = 3348833, upload-time = "2025-06-29T14:20:03.217Z" }
-wheels = [
- { url = "https://files.pythonhosted.org/packages/a9/6b/1ff0add7108845d457d405302ef20788f9b8382dbcc88e354f8303ae20a1/uv-0.7.17-py3-none-linux_armv6l.whl", hash = "sha256:5cce5694a3ed55c5064a27b296c21d1dcbc11dfa9f0c40a34933456f2a701a63", size = 17591460, upload-time = "2025-06-29T14:19:20.765Z" },
- { url = "https://files.pythonhosted.org/packages/f9/d2/3417f32c85f82acb99550497d6cf7aa1ca1f961a346c0901233d4e777ea5/uv-0.7.17-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:4f0789be0ce9c0188fd8304ce91c71f99a5a2f9945589ec7de2cafd53f007fbc", size = 17691434, upload-time = "2025-06-29T14:19:24.831Z" },
- { url = "https://files.pythonhosted.org/packages/33/65/41470bc69ec1cac0a49bd11e0a2d83d5d28d17e6b6e9f77be0004d2d9b81/uv-0.7.17-py3-none-macosx_11_0_arm64.whl", hash = "sha256:6aefa5b19dad73f585d86f4542778d39b8d7ef6d6983e9a15385be53a8d05a62", size = 16336037, upload-time = "2025-06-29T14:19:27.352Z" },
- { url = "https://files.pythonhosted.org/packages/ab/72/2d1f406b83d7b5abaa4064bba8d7a0c261ff2c990c1aedb1bf9dd0155d60/uv-0.7.17-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.musllinux_1_1_aarch64.whl", hash = "sha256:311615fe6867edb8a4164724af60af45b247fa725f564e170da63e6ca97ba223", size = 16893232, upload-time = "2025-06-29T14:19:30.083Z" },
- { url = "https://files.pythonhosted.org/packages/a2/80/b7632a549f01dcae611d049eb2f577d09100d7bef529d9a2ad7e142966e7/uv-0.7.17-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:fd757f5fa7a3cf9bdb86175bdf038ca749f5d4a9e4be4b3ea6de413d57933ed6", size = 17285966, upload-time = "2025-06-29T14:19:32.606Z" },
- { url = "https://files.pythonhosted.org/packages/81/bb/3e7518b0f0ff0f961da0519f3d7000b184b76c5350028e822c73e968c11e/uv-0.7.17-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:df02470a988526262c8c575ae976ee80ad7503ee942a3948fca7e3474c024abd", size = 17971871, upload-time = "2025-06-29T14:19:35.082Z" },
- { url = "https://files.pythonhosted.org/packages/92/97/eb66b2c635f9645e945cd1d77f75689bd51a690b056f1d21339a65817a43/uv-0.7.17-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:87dd56ad44a4ea7138fb090d5ef1bf525bf07cd12f54d53a22fb666b31aa09c5", size = 19163402, upload-time = "2025-06-29T14:19:37.62Z" },
- { url = "https://files.pythonhosted.org/packages/f7/07/f5989caad49fd36f6e080ea29f5a5827c5bdc9d0e20aff4ada88e5060eb1/uv-0.7.17-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:764d64fd5f7fce6e5678fdcd1e2e80325b455aedaf47f3c82f0f91f4f510d570", size = 18950283, upload-time = "2025-06-29T14:19:39.997Z" },
- { url = "https://files.pythonhosted.org/packages/28/6a/1ccd2fae732d3950612ada9079882800b7ed4eda5916ebce80045b376c57/uv-0.7.17-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:1070d1f8b6199bc6f83753fe8e76a052c2655466a82d28713f3b890541d75703", size = 18534501, upload-time = "2025-06-29T14:19:42.23Z" },
- { url = "https://files.pythonhosted.org/packages/81/bd/66abf16b0c16bae685d832affde946917723adbccc1edfca69a391f5dbda/uv-0.7.17-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:17def57d55372556a72e5a274d440dff3cc7030a1c6fb389c356484d5d78ad51", size = 18423387, upload-time = "2025-06-29T14:19:44.461Z" },
- { url = "https://files.pythonhosted.org/packages/5a/98/c9b69f646f21208967e051ce2744de7fb6147d5ff92c621b1119254a7e3e/uv-0.7.17-py3-none-manylinux_2_28_aarch64.whl", hash = "sha256:223fa568f9bbb893ed008fb89fcbc4f1ebae2a3181409b4606024a0643d75f5e", size = 17128608, upload-time = "2025-06-29T14:19:46.825Z" },
- { url = "https://files.pythonhosted.org/packages/f5/ff/8f7f3aab879398fcb76caf498fae047e0f6a07ae9adb3b981a69ea81d80f/uv-0.7.17-py3-none-musllinux_1_1_armv7l.whl", hash = "sha256:75fd22d218b0c406cee622380d11f39d8989af1b094c5523d0e09cecb7574408", size = 17247399, upload-time = "2025-06-29T14:19:49.093Z" },
- { url = "https://files.pythonhosted.org/packages/cd/e1/694903910ca2531763b40b4958d537bee14e6a3e85276202e4e70841d256/uv-0.7.17-py3-none-musllinux_1_1_i686.whl", hash = "sha256:260ee846e7d5c8ca9d4be2cacbd5b4d469b4269a6a9a6a4efb6ab96aca38d896", size = 17479616, upload-time = "2025-06-29T14:19:51.606Z" },
- { url = "https://files.pythonhosted.org/packages/26/97/178ea727f0260799eafea8e7aa4e5a590ac407cc88e709ccc41669323db3/uv-0.7.17-py3-none-musllinux_1_1_x86_64.whl", hash = "sha256:e660ec1845b5c1c0908084497982d5d854f97d288beac0d7a5b7449447516222", size = 18571399, upload-time = "2025-06-29T14:19:53.888Z" },
- { url = "https://files.pythonhosted.org/packages/7f/57/ca2bdf384a7916b290e75c5f4c50dc4afca943619789c1128a3ad43cade8/uv-0.7.17-py3-none-win32.whl", hash = "sha256:ad93835a5e563bb0f2c869e6ef6c3113154bb2ab729900ae4416776382682f65", size = 17608114, upload-time = "2025-06-29T14:19:56.552Z" },
- { url = "https://files.pythonhosted.org/packages/ff/17/f6d149ff4c274d54dffe14f560dbc2f913edc52724f60e045e5c5962a24a/uv-0.7.17-py3-none-win_amd64.whl", hash = "sha256:9c0a76fc1ccbf79c4902488c551bc47cad4a4121977a68ed54807c5e51f5e9f2", size = 19388189, upload-time = "2025-06-29T14:19:58.863Z" },
- { url = "https://files.pythonhosted.org/packages/8f/c0/253e160950cdc6969d134e91d44b3ce03719ab7d25c1d65ecf31f9b129e9/uv-0.7.17-py3-none-win_arm64.whl", hash = "sha256:2bffb08919cefa69e7f97c0eeaabd0f5378c10fb31967432c453c4ccdb85e7fa", size = 17817791, upload-time = "2025-06-29T14:20:01.344Z" },
+version = "0.7.19"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/69/52/50f8be2cc8c9dc89319e9cbc72656a676742ab59c2d9f78e5bf94898f960/uv-0.7.19.tar.gz", hash = "sha256:c99b4ee986d2ca3a597dfe91baeb86ce5ccc7cd4292a9f5eb108d1ae45ec2705", size = 3355519, upload-time = "2025-07-02T21:42:20.966Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/a6/f4/41d97a3345aebb94ba84d53c7eaef72d5436aac6c89f73956b87604eb1e1/uv-0.7.19-py3-none-linux_armv6l.whl", hash = "sha256:9b1b8908c47509526b6531c4d350c84b0e03a0923a2cb405c3cc53fbc73b1d3e", size = 17587804, upload-time = "2025-07-02T21:41:32.254Z" },
+ { url = "https://files.pythonhosted.org/packages/96/51/a260f73b615ea6953128182c5e03473e6a3321d047af1aa7acba496f7b2f/uv-0.7.19-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:9bd596055c178d5022de4d3c5a3d02a982ad747be83b270893ac3d97d4ab4358", size = 17679828, upload-time = "2025-07-02T21:41:35.809Z" },
+ { url = "https://files.pythonhosted.org/packages/8c/59/4ba64e727b5b570e07e04671c70eda334e91c8375aa2d38cdfda24a64fa0/uv-0.7.19-py3-none-macosx_11_0_arm64.whl", hash = "sha256:f303b80d840298f668ce6a3157e2b0b58402fd4e293a478278234efde8724e75", size = 16367731, upload-time = "2025-07-02T21:41:38.677Z" },
+ { url = "https://files.pythonhosted.org/packages/19/b5/ec4dd36640f2019b0c4cbec7ca182509289d988ba2e8587ca627e0c016b2/uv-0.7.19-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.musllinux_1_1_aarch64.whl", hash = "sha256:692f6e80b4d98b2fbf93b1a17ed00b60ac058b04507e8f32d6fc5205eb2934c7", size = 16933649, upload-time = "2025-07-02T21:41:41.156Z" },
+ { url = "https://files.pythonhosted.org/packages/d7/d5/7dc3382c732aa42257ab03738a5595d3b15890ffcce1972c86dd6845c673/uv-0.7.19-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:576bf4d53385c89e049662c358e8582e7f728af1e55f5eca95d496188cf5a406", size = 17285587, upload-time = "2025-07-02T21:41:46.079Z" },
+ { url = "https://files.pythonhosted.org/packages/46/01/25f78f929d457178fad8f167048d012bbdf4dd4e74372e54fbafa5fccd7b/uv-0.7.19-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:8546bbb5b852a249bb8b4e895eaa1e8ea9de3a0e26954a0413aa402e388868f5", size = 17994092, upload-time = "2025-07-02T21:41:48.438Z" },
+ { url = "https://files.pythonhosted.org/packages/04/fe/f983fc90d98bfb2941d58b35a59a7411f6632e719883431786aa18bad5f9/uv-0.7.19-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:7e1fff9b4552b532264cb3dd39f802aa98cb974a490714cef71ab848269b7e41", size = 19196540, upload-time = "2025-07-02T21:41:50.909Z" },
+ { url = "https://files.pythonhosted.org/packages/91/a9/56bd9de82f2d66db246506196546a8346653e03b118c5488054e7f3fa9f5/uv-0.7.19-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a83416ca351aea36155ec07fce6ac9513e043389646a45a1ad567a532ef101dd", size = 18957639, upload-time = "2025-07-02T21:41:53.224Z" },
+ { url = "https://files.pythonhosted.org/packages/04/d0/6093c3818eaf485de85c821f440191a7fd45ce56297493fb6e01baf5fdf3/uv-0.7.19-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4cb6fa07564d04e751dac1f0a0a641b9795838e8c98b6389135690b61a20753c", size = 18502456, upload-time = "2025-07-02T21:41:58.229Z" },
+ { url = "https://files.pythonhosted.org/packages/2a/5e/bd0594f69dcdc633ffafd500538f137169a8b588f628a4f6abd5dc198426/uv-0.7.19-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5dee2c73fe29e8f119ac074ebb3b2aa4390272e5ab3a5f00f75ca16caf120d64", size = 18391983, upload-time = "2025-07-02T21:42:00.63Z" },
+ { url = "https://files.pythonhosted.org/packages/7b/12/f51c559e4bcf6065fc43491cff1780108a207eca13511ffcd73a5c8dbf8b/uv-0.7.19-py3-none-manylinux_2_28_aarch64.whl", hash = "sha256:52b7d64a97b18196cccbbbd8036ad649a72b7b1a7fd4b22297219c55a733127c", size = 17169522, upload-time = "2025-07-02T21:42:02.983Z" },
+ { url = "https://files.pythonhosted.org/packages/de/15/75d8cf9f809e911a1492bad3988f3aa29319ac2b312d48fea017c48006a3/uv-0.7.19-py3-none-musllinux_1_1_armv7l.whl", hash = "sha256:987059dee02b8e455829f5844dbcbe202cdedf04108942382dadcc29fa140d6a", size = 17257476, upload-time = "2025-07-02T21:42:06.067Z" },
+ { url = "https://files.pythonhosted.org/packages/a4/5e/214d127a4c323e031998b81b7a144c2c72c4056fcc25117515799962b0ee/uv-0.7.19-py3-none-musllinux_1_1_i686.whl", hash = "sha256:e6bffad5d26a2c23ccd5a544ac3fd285427b1f8704cf7b3fdc8ec7954a7f6cad", size = 17569440, upload-time = "2025-07-02T21:42:08.378Z" },
+ { url = "https://files.pythonhosted.org/packages/46/f8/280823b29ca2a19fcdb728b46ef27f969c5b8a2dc952e556d67c7c6f9293/uv-0.7.19-py3-none-musllinux_1_1_x86_64.whl", hash = "sha256:cb6c0d61294af5b6cabd6831aa795abf3134f96736a973c046acc9f5a3501f0d", size = 18531849, upload-time = "2025-07-02T21:42:11.073Z" },
+ { url = "https://files.pythonhosted.org/packages/73/28/690c02e4f63a6fb46cc9f5670a6e208dd6fef1b33f328e0916738f5ddc2f/uv-0.7.19-py3-none-win32.whl", hash = "sha256:e59efa9b0449b49acca0ca817666cc2d4a03bd619c77867bea57b133f224e5f3", size = 17581671, upload-time = "2025-07-02T21:42:13.351Z" },
+ { url = "https://files.pythonhosted.org/packages/f0/d7/9658133273c393bdf5127b87b00abeec04f90bc0e2004d4ea180502f24e8/uv-0.7.19-py3-none-win_amd64.whl", hash = "sha256:b971035a69bf1c28424896894c181d8b65624f43b95858a3b34a33dba04a5a2a", size = 19320233, upload-time = "2025-07-02T21:42:16.025Z" },
+ { url = "https://files.pythonhosted.org/packages/e9/50/59b4141026491b625110161fcc0e383b4eb9a81937d4608c614ab990a789/uv-0.7.19-py3-none-win_arm64.whl", hash = "sha256:729befc8b4d05b9a86192af09228472c058c9ec071dd42d84190f10507b7c6e0", size = 17943387, upload-time = "2025-07-02T21:42:18.804Z" },
]
[[package]]