🐫 CAMEL: The first and the best multi-agent framework. Finding the Scaling Law of Agents. https://www.camel-ai.org
Python agentai-societiesartificial-intelligencecommunicative-aicooperative-aideep-learninglarge-language-modelsmulti-agent-systemsnatural-language-processing
Support for Streaming Responses in ChatAgent (#2559)
Tao Sun6e628a2f423b
diff --git a/.github/ISSUE_TEMPLATE/bug_report.yml b/.github/ISSUE_TEMPLATE/bug_report.ymlindex 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.71a5validations:required: truediff --git a/camel/__init__.py b/camel/__init__.pyindex 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.pyindex 9d879ae56..171b1f7c3 100644--- a/camel/agents/chat_agent.py+++ b/camel/agents/chat_agent.py@@ -16,23 +16,26 @@ from __future__ import annotationsimport asyncioimport jsonimport logging+import queueimport textwrapimport threadingimport timeimport uuid-from collections import defaultdictfrom pathlib import Pathfrom 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 signaltermination of the agent's operation. When set, the agent willterminate 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 sanitizedplaceholder 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_iterationself.stop_event = stop_event+ self.tool_execution_timeout = tool_execution_timeoutself.mask_tool_output = mask_tool_outputself._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 responseto 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 groupingtry: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 responseto 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 schemahelps 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 crasherror_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.pyindex 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 BaseModelfrom camel.agents import ChatAgent+from camel.agents.chat_agent import StreamingChatAgentResponsefrom camel.logger import get_loggerfrom camel.messages import BaseMessagefrom 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 contextfrom the vector store before passing the input to the language model."""diff --git a/camel/benchmarks/browsecomp.py b/camel/benchmarks/browsecomp.pyindex 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]breakchat_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.pyindex 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.pyindex 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 copyimport osfrom typing import Any, Callable, Dict, List, Optional, Type, Unionfrom openai import AsyncAzureOpenAI, AsyncStream, AzureOpenAI, Stream+from openai.lib.streaming.chat import (+ AsyncChatCompletionStreamManager,+ ChatCompletionStreamManager,+)from pydantic import BaseModelfrom 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 anyunexpected arguments to Azure OpenAI API.diff --git a/camel/models/base_model.py b/camel/models/base_model.pyindex 3baae3017..d64fc6b4f 100644--- a/camel/models/base_model.py+++ b/camel/models/base_model.py@@ -18,6 +18,10 @@ from abc import ABC, abstractmethodfrom typing import Any, Dict, List, Optional, Type, Unionfrom openai import AsyncStream, Stream+from openai.lib.streaming.chat import (+ AsyncChatCompletionStreamManager,+ ChatCompletionStreamManager,+)from pydantic import BaseModelfrom 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.+ """passdef 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 enabledlog_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 enabledlog_path = self._log_request(messages)diff --git a/camel/models/model_manager.py b/camel/models/model_manager.pyindex 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 BaseModelfrom 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 onthe 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 onthe 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.pyindex ed4fe7e0f..8b87ddc82 100644--- a/camel/models/openai_compatible_model.py+++ b/camel/models/openai_compatible_model.py@@ -17,6 +17,10 @@ from json import JSONDecodeErrorfrom typing import Any, Dict, List, Optional, Type, Unionfrom openai import AsyncOpenAI, AsyncStream, BadRequestError, OpenAI, Stream+from openai.lib.streaming.chat import (+ AsyncChatCompletionStreamManager,+ ChatCompletionStreamManager,+)from pydantic import BaseModel, ValidationErrorfrom 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,+ )+@propertydef 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.pyindex 009d591f3..ba7d1f981 100644--- a/camel/models/openai_model.py+++ b/camel/models/openai_model.py@@ -16,6 +16,10 @@ import warningsfrom typing import Any, Dict, List, Optional, Type, Unionfrom openai import AsyncOpenAI, AsyncStream, OpenAI, Stream+from openai.lib.streaming.chat import (+ AsyncChatCompletionStreamManager,+ ChatCompletionStreamManager,+)from pydantic import BaseModelfrom 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 anyunexpected arguments to OpenAI API.diff --git a/docs/conf.py b/docs/conf.pyindex 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.mdxindex 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.mdxindex 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_configdiff --git a/docs/mintlify/reference/camel.models.base_model.mdx b/docs/mintlify/reference/camel.models.base_model.mdxindex 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.mdxindex 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_counterdiff --git a/docs/mintlify/reference/camel.models.openai_model.mdx b/docs/mintlify/reference/camel.models.openai_model.mdxindex 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_configdiff --git a/examples/agents/chatagent_stream.py b/examples/agents/chatagent_stream.pynew file mode 100644index 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.tomlindex 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.pyindex 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 BaseMessagefrom camel.models import BaseModelBackend+from camel.responses import ChatAgentResponsefrom 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() methodwith 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")# Assertassert mock_step.called+ assert result == mock_response# Check that the input was augmented with retrieved contentcall_args = mock_step.call_args[0][0]assert isinstance(call_args, BaseMessage)diff --git a/uv.lock b/uv.lockindex 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]]