ag2 0.9.4__tar.gz → 0.9.5__tar.gz

{ag2-0.9.4 → ag2-0.9.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ag2
-Version: 0.9.4
+Version: 0.9.5
 Summary: A programming framework for agentic AI
 Project-URL: Homepage, https://ag2.ai/
 Project-URL: Documentation, https://docs.ag2.ai

{ag2-0.9.4 → ag2-0.9.5}/autogen/agentchat/realtime/experimental/realtime_swarm.py

@@ -359,6 +359,8 @@ class SwarmableRealtimeAgent(SwarmableAgent):
             description=None,
             silent=None,
         )
+        self.input_guardrails = []
+        self.output_guardrails = []
 
     def reset_answer(self) -> None:
         """Reset the answer event."""

{ag2-0.9.4 → ag2-0.9.5}/autogen/code_utils.py

@@ -72,18 +72,20 @@ def content_str(content: Union[str, list[Union[UserMessageTextContentPart, UserM
     if not isinstance(content, list):
         raise TypeError(f"content must be None, str, or list, but got {type(content)}")
 
-    rst = ""
+    rst = []
     for item in content:
         if not isinstance(item, dict):
             raise TypeError("Wrong content format: every element should be dict if the content is a list.")
         assert "type" in item, "Wrong content format. Missing 'type' key in content's dict."
-        if item["type"] == "text":
-            rst += item["text"]
-        elif item["type"] == "image_url":
-            rst += "<image>"
+        if item["type"] in ["text", "input_text"]:
+            rst.append(item["text"])
+        elif item["type"] in ["image_url", "input_image"]:
+            rst.append("<image>")
+        elif item["type"] in ["function", "tool_call", "tool_calls"]:
+            rst.append("<function>" if "name" not in item else f"<function: {item['name']}>")
         else:
             raise ValueError(f"Wrong content format: unknown type {item['type']} within the content")
-    return rst
+    return "\n".join(rst)
 
 
 def infer_lang(code: str) -> str:

{ag2-0.9.4 → ag2-0.9.5}/autogen/oai/client.py

@@ -51,6 +51,8 @@ if openai_result.is_successful:
     from openai.types.completion import Completion
     from openai.types.completion_usage import CompletionUsage
 
+    from autogen.oai.openai_responses import OpenAIResponsesClient
+
     if openai.__version__ >= "1.1.0":
         TOOL_ENABLED = True
     ERROR = None
@@ -314,7 +316,7 @@ class ModelClient(Protocol):
     class ModelClientResponseProtocol(Protocol):
         class Choice(Protocol):
             class Message(Protocol):
-                content: Optional[str]
+                content: Optional[str] | Optional[dict[str, Any]]
 
             message: Message
 
@@ -952,6 +954,15 @@ class OpenAIWrapper:
                     raise ImportError("Please install `boto3` to use the Amazon Bedrock API.")
                 client = BedrockClient(response_format=response_format, **openai_config)
                 self._clients.append(client)
+            elif api_type is not None and api_type.startswith("responses"):
+                # OpenAI Responses API (stateful). Reuse the same OpenAI SDK but call the `/responses` endpoint via the new client.
+                @require_optional_import("openai>=1.66.2", "openai")
+                def create_responses_client() -> "OpenAI":
+                    client = OpenAI(**openai_config)
+                    self._clients.append(OpenAIResponsesClient(client, response_format=response_format))
+                    return client
+
+                client = create_responses_client()
             else:
 
                 @require_optional_import("openai>=1.66.2", "openai")
@@ -1442,3 +1453,35 @@ class OpenAIWrapper:
             A list of text, or a list of ChatCompletion objects if function_call/tool_calls are present.
         """
         return response.message_retrieval_function(response)
+
+
+# -----------------------------------------------------------------------------
+# New: Responses API config entry (OpenAI-hosted preview endpoint)
+# -----------------------------------------------------------------------------
+
+
+@register_llm_config
+class OpenAIResponsesLLMConfigEntry(OpenAILLMConfigEntry):
+    """LLMConfig entry for the OpenAI Responses API (stateful, tool-enabled).
+
+    This reuses all the OpenAI fields but changes *api_type* so the wrapper can
+    route traffic to the `client.responses` endpoint instead of
+    `chat.completions`.  It inherits everything else – including reasoning
+    fields – from *OpenAILLMConfigEntry* so users can simply set
+
+    ```python
+    {
+        "api_type": "responses",  # <-- key differentiator
+        "model": "o3",  # reasoning model
+        "reasoning_effort": "medium",  # low / medium / high
+        "stream": True,
+    }
+    ```
+    """
+
+    api_type: Literal["responses"] = "responses"
+    tool_choice: Optional[Literal["none", "auto", "required"]] = "auto"
+    built_in_tools: Optional[list[str]] = None
+
+    def create_client(self) -> "ModelClient":  # pragma: no cover
+        raise NotImplementedError("Handled via OpenAIWrapper._register_default_client")

ag2-0.9.5/autogen/oai/openai_responses.py

@@ -0,0 +1,426 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import copy
+import warnings
+from typing import TYPE_CHECKING, Any, Tuple, Union
+
+from pydantic import BaseModel
+
+from autogen.code_utils import content_str
+from autogen.import_utils import optional_import_block, require_optional_import
+
+if TYPE_CHECKING:
+    from autogen.oai.client import ModelClient, OpenAI, OpenAILLMConfigEntry
+else:
+    # Import at runtime to avoid circular import
+    OpenAILLMConfigEntry = None
+    ModelClient = None
+    OpenAI = None
+
+with optional_import_block() as openai_result:
+    from openai.types.responses.response import Response
+    from openai.types.responses.response_output_item import ImageGenerationCall
+
+# Image Costs
+# Pricing per image (in USD)
+PRICING = {
+    "gpt-image-1": {
+        "low": {"1024x1024": 0.011, "1024x1536": 0.016, "1536x1024": 0.016},
+        "medium": {"1024x1024": 0.042, "1024x1536": 0.063, "1536x1024": 0.063},
+        "high": {"1024x1024": 0.167, "1024x1536": 0.25, "1536x1024": 0.25},
+    },
+    "dall-e-3": {
+        "standard": {"1024x1024": 0.040, "1024x1792": 0.080, "1792x1024": 0.080},
+        "hd": {"1024x1024": 0.080, "1024x1792": 0.120, "1792x1024": 0.120},
+    },
+    "dall-e-2": {"standard": {"1024x1024": 0.020, "512x512": 0.018, "256x256": 0.016}},
+}
+
+# Valid sizes for each model
+VALID_SIZES = {
+    "gpt-image-1": ["1024x1024", "1024x1536", "1536x1024"],
+    "dall-e-3": ["1024x1024", "1024x1792", "1792x1024"],
+    "dall-e-2": ["1024x1024", "512x512", "256x256"],
+}
+
+
+def calculate_openai_image_cost(
+    model: str = "gpt-image-1", size: str = "1024x1024", quality: str = "high"
+) -> Tuple[float, str]:
+    """
+    Calculate the cost for a single image generation.
+
+    Args:
+        model: Model name ("gpt-image-1", "dall-e-3" or "dall-e-2")
+        size: Image size (e.g., "1024x1024", "1024x1536")
+        quality: Quality setting:
+                - For gpt-image-1: "low", "medium", or "high"
+                - For dall-e-3: "standard" or "hd"
+                - For dall-e-2: "standard" only
+
+    Returns:
+        Tuple of (cost, error_message)
+    """
+    # Normalize inputs
+    model = model.lower()
+    quality = quality.lower()
+
+    # Validate model
+    if model not in PRICING:
+        return 0.0, f"Invalid model: {model}. Valid models: {list(PRICING.keys())}"
+
+    # Validate size
+    if size not in VALID_SIZES[model]:
+        return 0.0, f"Invalid size {size} for {model}. Valid sizes: {VALID_SIZES[model]}"
+
+    # Get the cost based on model type
+    try:
+        if model == "gpt-image-1" or model == "dall-e-3":
+            cost = PRICING[model][quality][size]
+        elif model == "dall-e-2":
+            cost = PRICING[model]["standard"][size]
+        else:
+            return 0.0, f"Model {model} not properly configured"
+
+        return cost, None
+
+    except KeyError:
+        return 0.0, f"Invalid quality '{quality}' for {model}"
+
+
+def _get_base_class():
+    """Lazy import OpenAILLMConfigEntry to avoid circular imports."""
+    from autogen.oai.client import OpenAILLMConfigEntry
+
+    return OpenAILLMConfigEntry
+
+
+# -----------------------------------------------------------------------------
+# OpenAI Client that calls the /responses endpoint
+# -----------------------------------------------------------------------------
+@require_optional_import("openai", "openai")
+class OpenAIResponsesClient:
+    """Minimal implementation targeting the experimental /responses endpoint.
+
+    We purposefully keep the surface small - *create*, *message_retrieval*,
+    *cost* and *get_usage* - enough for ConversableAgent to operate.  Anything
+    that the new endpoint does natively (web_search, file_search, image
+    generation, function calling, etc.) is transparently passed through by the
+    OpenAI SDK so we don't replicate logic here.
+    """
+
+    def __init__(
+        self,
+        client: "OpenAI",
+        response_format: Union[BaseModel, dict[str, Any], None] = None,
+    ):
+        self._oai_client = client  # plain openai.OpenAI instance
+        self.response_format = response_format  # kept for parity but unused for now
+
+        # Initialize the image generation parameters
+        self.image_output_params = {
+            "quality": None,  # "high" or "low"
+            "background": None,  # "white" or "black" or "transparent"
+            "size": None,  # "1024x1024" or "1024x1792" or "1792x1024"
+            "output_format": "png",  # "png", "jpg" or "jpeg" or "webp"
+            "output_compression": None,  # 0-100 if output_format is "jpg" or "jpeg" or "webp"
+        }
+        self.previous_response_id = None
+
+        # Image costs are calculated manually (rather than off returned information)
+        self.image_costs = 0
+
+    # ------------------------------------------------------------------ helpers
+    # responses objects embed usage similarly to chat completions
+    @staticmethod
+    def _usage_dict(resp) -> dict:
+        usage_obj = getattr(resp, "usage", None) or {}
+
+        # Convert pydantic/BaseModel usage objects to dict for uniform access
+        if hasattr(usage_obj, "model_dump"):
+            usage = usage_obj.model_dump()
+        elif isinstance(usage_obj, dict):
+            usage = usage_obj
+        else:  # fallback - unknown structure
+            usage = {}
+
+        output_tokens_details = usage.get("output_tokens_details", {})
+
+        return {
+            "prompt_tokens": usage.get("input_tokens", 0),
+            "completion_tokens": usage.get("output_tokens", 0),
+            "total_tokens": usage.get("total_tokens", 0),
+            "cost": getattr(resp, "cost", 0),
+            "model": getattr(resp, "model", ""),
+            "reasoning_tokens": output_tokens_details.get("reasoning_tokens", 0),
+        }
+
+    def _add_image_cost(self, response: "Response") -> None:
+        """Add image cost to self._image_costs when an image is generated"""
+        for output in response.output:
+            if (
+                isinstance(output, ImageGenerationCall)
+                and hasattr(response.output[0], "model_extra")
+                and response.output[0].model_extra
+            ):
+                extra_fields = output.model_extra
+
+                image_cost, image_error = calculate_openai_image_cost(
+                    model="gpt-image-1",
+                    size=extra_fields.get("size", "1024x1536"),
+                    quality=extra_fields.get("quality", "high"),
+                )
+
+                if not image_error and image_cost:
+                    self.image_costs += image_cost
+
+    def _get_delta_messages(self, messages: list[dict[str, Any]]) -> list[dict[str, Any]]:
+        """Get the delta messages from the messages."""
+        delta_messages = []
+        for m in messages[::-1]:
+            contents = m.get("content")
+            is_last_completed_response = False
+            if isinstance(contents, list):
+                for c in contents:
+                    if "status" in c and c.get("status") == "completed":
+                        is_last_completed_response = True
+                        break
+            elif isinstance(contents, str):
+                is_last_completed_response = "status" in m and m.get("status") == "completed"
+
+            if is_last_completed_response:
+                break
+            delta_messages.append(m)
+        return delta_messages[::-1]
+
+    def create(self, params: dict[str, Any]) -> "Response":
+        """Invoke `client.responses.create() or .parse()`.
+
+        If the caller provided a classic *messages* array we convert it to the
+        *input* format expected by the Responses API.
+        """
+        params = params.copy()
+
+        image_generation_tool_params = {"type": "image_generation"}
+        web_search_tool_params = {"type": "web_search_preview"}
+
+        if self.previous_response_id is not None and "previous_response_id" not in params:
+            params["previous_response_id"] = self.previous_response_id
+
+        # Back-compat: transform messages → input if needed ------------------
+        if "messages" in params and "input" not in params:
+            msgs = self._get_delta_messages(params.pop("messages"))
+            input_items = []
+            for m in msgs[::-1]:  # reverse the list to get the last item first
+                role = m.get("role", "user")
+                # First, we need to convert the content to the Responses API format
+                content = m.get("content")
+                blocks = []
+                if role != "tool":
+                    if isinstance(content, list):
+                        for c in content:
+                            if c.get("type") in ["input_text", "text"]:
+                                blocks.append({"type": "input_text", "text": c.get("text")})
+                            elif c.get("type") == "input_image":
+                                blocks.append({"type": "input_image", "image_url": c.get("image_url")})
+                            elif c.get("type") == "image_params":
+                                for k, v in c.get("image_params", {}).items():
+                                    if k in self.image_output_params:
+                                        image_generation_tool_params[k] = v
+                            else:
+                                raise ValueError(f"Invalid content type: {c.get('type')}")
+                    else:
+                        blocks.append({"type": "input_text", "text": content})
+                    input_items.append({"role": role, "content": blocks})
+
+                else:
+                    if input_items:
+                        break
+                    # tool call response is the last item in the list
+                    content = content_str(m.get("content"))
+                    input_items.append({
+                        "type": "function_call_output",
+                        "call_id": m.get("tool_call_id", None),
+                        "output": content,
+                    })
+                    break
+            params["input"] = input_items[::-1]
+
+        # Initialize tools list
+        tools_list = []
+        # Back-compat: add default tools
+        built_in_tools = params.pop("built_in_tools", [])
+        if built_in_tools:
+            if "image_generation" in built_in_tools:
+                tools_list.append(image_generation_tool_params)
+            if "web_search" in built_in_tools:
+                tools_list.append(web_search_tool_params)
+
+        if "tools" in params:
+            for tool in params["tools"]:
+                tool_item = {"type": "function"}
+                if "function" in tool:
+                    tool_item |= tool["function"]
+                    tools_list.append(tool_item)
+        params["tools"] = tools_list
+        params["tool_choice"] = "auto"
+
+        # Ensure we don't mix legacy params that Responses doesn't accept
+        if params.get("stream") and params.get("background"):
+            warnings.warn(
+                "Streaming a background response may introduce latency.",
+                UserWarning,
+            )
+
+        # ------------------------------------------------------------------
+        # Structured output handling - mimic OpenAIClient behaviour
+        # ------------------------------------------------------------------
+
+        if self.response_format is not None or "response_format" in params:
+
+            def _create_or_parse(**kwargs):
+                # For structured output we must convert dict / pydantic model
+                # into the JSON-schema body expected by the API.
+                if "stream" in kwargs:
+                    kwargs.pop("stream")  # Responses API rejects stream with RF for now
+
+                rf = kwargs.get("response_format", self.response_format)
+
+                if isinstance(rf, dict):
+                    from autogen.oai.client import _ensure_strict_json_schema
+
+                    kwargs["text_format"] = {
+                        "type": "json_schema",
+                        "json_schema": {
+                            "schema": _ensure_strict_json_schema(rf, path=(), root=rf),
+                            "name": "response_format",
+                            "strict": True,
+                        },
+                    }
+                else:
+                    # pydantic.BaseModel subclass
+                    from autogen.oai.client import type_to_response_format_param
+
+                    kwargs["text_format"] = type_to_response_format_param(rf)
+                if "response_format" in kwargs:
+                    kwargs["text_format"] = kwargs.pop("response_format")
+
+                try:
+                    return self._oai_client.responses.parse(**kwargs)
+                except TypeError as e:
+                    # Older openai-python versions may not yet expose the
+                    # text_format parameter on the Responses endpoint.
+                    if "text_format" in str(e) and "unexpected" in str(e):
+                        warnings.warn(
+                            "Installed openai-python version doesn't support "
+                            "`response_format` for the Responses API. "
+                            "Falling back to raw text output.",
+                            UserWarning,
+                        )
+                        kwargs.pop("text_format", None)
+                        return self._oai_client.responses.create(**kwargs)
+
+            response = _create_or_parse(**params)
+            self.previous_response_id = response.id
+            return response
+
+        # No structured output
+        response = self._oai_client.responses.create(**params)
+        self.previous_response_id = response.id
+
+        # Accumulate image costs
+        self._add_image_cost(response)
+
+        return response
+
+    def message_retrieval(
+        self, response
+    ) -> Union[list[str], list["ModelClient.ModelClientResponseProtocol.Choice.Message"]]:
+        output = getattr(response, "output", [])
+        content = []  # list[dict[str, Union[str, dict[str, Any]]]]]
+        tool_calls = []
+        for item in output:
+            # Convert pydantic objects to plain dicts for uniform handling
+            if hasattr(item, "model_dump"):
+                item = item.model_dump()
+
+            item_type = item.get("type")
+
+            # ------------------------------------------------------------------
+            # 1) Normal messages
+            # ------------------------------------------------------------------
+            if item_type == "message":
+                new_item = copy.deepcopy(item)
+                new_item["type"] = "text"
+                new_item["role"] = "assistant"
+                blocks = item.get("content", [])
+                if len(blocks) == 1 and blocks[0].get("type") == "output_text":
+                    new_item["text"] = blocks[0]["text"]
+                if "content" in new_item:
+                    del new_item["content"]
+                content.append(new_item)
+                continue
+
+            # ------------------------------------------------------------------
+            # 2) Custom function calls
+            # ------------------------------------------------------------------
+            if item_type == "function_call":
+                tool_calls.append({
+                    "id": item.get("call_id", None),
+                    "function": {
+                        "name": item.get("name", None),
+                        "arguments": item.get("arguments"),
+                    },
+                    "type": "function_call",
+                })
+                continue
+
+            # ------------------------------------------------------------------
+            # 3) Built-in tool calls
+            # ------------------------------------------------------------------
+            if item_type and item_type.endswith("_call"):
+                tool_name = item_type.replace("_call", "")
+                tool_call_args = {
+                    "id": item.get("id"),
+                    "role": "tool_calls",
+                    "type": "tool_call",  # Responses API currently routes via function-like tools
+                    "name": tool_name,
+                }
+                if tool_name == "image_generation":
+                    for k in self.image_output_params:
+                        if k in item:
+                            tool_call_args[k] = item[k]
+                    encoded_base64_result = item.get("result", "")
+                    tool_call_args["content"] = encoded_base64_result
+                    # add image_url for image input back to oai response api.
+                    output_format = self.image_output_params["output_format"]
+                    tool_call_args["image_url"] = f"data:image/{output_format};base64,{encoded_base64_result}"
+                elif tool_name == "web_search":
+                    pass
+                else:
+                    raise ValueError(f"Invalid tool name: {tool_name}")
+                content.append(tool_call_args)
+                continue
+
+            # ------------------------------------------------------------------
+            # 4) Fallback - store raw dict so information isn't lost
+            # ------------------------------------------------------------------
+            content.append(item)
+
+        return [
+            {
+                "role": "assistant",
+                "id": response.id,
+                "content": content if content else None,
+                "tool_calls": tool_calls,
+            }
+        ]
+
+    def cost(self, response):
+        return self._usage_dict(response).get("cost", 0) + self.image_costs
+
+    @staticmethod
+    def get_usage(response):
+        return OpenAIResponsesClient._usage_dict(response)

{ag2-0.9.4 → ag2-0.9.5}/autogen/version.py

@@ -4,4 +4,4 @@
 
 __all__ = ["__version__"]
 
-__version__ = "0.9.4"
+__version__ = "0.9.5"

{ag2-0.9.4 → ag2-0.9.5}/website/docs/user-guide/models/openai.mdx

@@ -31,7 +31,8 @@ as `autogen` and `ag2` are aliases for the same PyPI package.
 
 See the [LLM Configuration](/docs/user-guide/basic-concepts/llm-configuration) for further details on setting an creating an LLM configuration.
 
-The below example of an `OAI_CONFIG_LIST` shows how the OpenAI client class is used by specifying the `api_type` as `openai`.
+The below example of an `OAI_CONFIG_LIST` shows how the OpenAI client class is used.
+By specifying the `api_type` as `openai`, the client will use the OpenAI ChatCompletion API.
 
 ```python
 [
@@ -41,12 +42,7 @@ The below example of an `OAI_CONFIG_LIST` shows how the OpenAI client class is u
         "api_key": "your OpenAI Key goes here",
     },
     {
-        "api_type": "openai",
-        "model": "gpt-4o-mini",
-        "api_key": "your OpenAI Key goes here",
-    },
-    {
-        "api_type": "openai",
+        "api_type": "openai", # use OpenAI ChatCompletion API
         "model": "gpt-4o-mini",
         "api_key": "your OpenAI Key goes here",
     }
@@ -65,6 +61,11 @@ Windows:
 set OPENAI_API_KEY=your_openai_api_key_here
 ```
 
+<Tip>
+Interested in trying out image generation with the new OpenAI Responses API? Check out the [OpenAPI Responses client](/docs/user-guide/models/openai_responses).
+</Tip>
+
+
 ## Examples
 
 See the [ConversableAgent example](/docs/user-guide/basic-concepts/conversable-agent) in our [Basic Concepts](/docs/user-guide/basic-concepts/installing-ag2) documentation to see OpenAI's LLMs in use.

ag2-0.9.5/website/docs/user-guide/models/openai_responses.mdx

@@ -0,0 +1,67 @@
+---
+title: OpenAI Responses API
+sidebarTitle: OpenAI Responses
+---
+
+[OpenAI](https://openai.com/)'s Responses API is a significant evolution from the Chat Completions and Assistants APIs, offering support for both stateless interactions and structured, stateful conversations.
+
+Additionally, it includes built-in tools for web search, file search, and computer use. The robust multimodal capabilities of the API also set it apart and will be utilized in our initial support for this API. [See their website for further details](https://platform.openai.com/docs/api-reference/responses).
+
+<Warning>
+This OpenAI Responses model provider is currently only supported in a two-agent chat using the agent's `initiate_chat`.
+
+Support for group chat and the `run` methods is planned for a future release.
+
+See the examples in the [Notebook section](/docs/use-cases/notebooks/Notebooks/?tags=responses) of the documentation for examples of using this model provider.
+</Warning>
+
+## Installation
+
+``` bash
+pip install ag2[openai]
+```
+
+<Tip>
+If you have been using `autogen` or `ag2`, all you need to do is upgrade it using:
+```bash
+pip install -U autogen[openai]
+```
+or
+```bash
+pip install -U ag2[openai]
+```
+as `autogen` and `ag2` are aliases for the same PyPI package.
+</Tip>
+
+## LLM Configurations
+
+See the [LLM Configuration](/docs/user-guide/basic-concepts/llm-configuration) for further details on setting an creating an LLM configuration.
+
+The below example of an `OAI_CONFIG_LIST` shows how the OpenAI client class is used.
+By specifying the `api_type` as `responses`, the client will use the OpenAI Responses API.
+
+```python
+[
+    {
+        "api_type": "responses", # use OpenAI Responses API
+        "model": "gpt-4o",
+        "api_key": "your OpenAI Key goes here",
+
+        # Optional: use image_generation and web_search built-in tools
+        # See https://platform.openai.com/docs/guides/images-vision?api-mode=responses
+        "built_in_tools": ["image_generation", "web_search"],
+    }
+]
+```
+
+As an alternative to the `api_key` key and value in the config, you can set the environment variable `OPENAI_API_KEY` to your OpenAI key.
+
+Linux/Mac:
+``` bash
+export OPENAI_API_KEY="your_openai_api_key_here"
+```
+
+Windows:
+``` bash
+set OPENAI_API_KEY=your_openai_api_key_here
+```

{ag2-0.9.4 → ag2-0.9.5}/website/mint-json-template.json.jinja

@@ -229,6 +229,7 @@
             "docs/user-guide/models/mistralai",
             "docs/user-guide/models/ollama",
             "docs/user-guide/models/openai",
+            "docs/user-guide/models/openai_responses",
             "docs/user-guide/models/togetherai",
             "docs/user-guide/models/vLLM"
           ]