meshagent-openai 0.5.18__tar.gz → 0.6.0__tar.gz

{meshagent_openai-0.5.18 → meshagent_openai-0.6.0}/CHANGELOG.md

@@ -1,3 +1,9 @@
+## [0.6.0]
+- Stability
+
+## [0.5.19]
+- Stability
+
 ## [0.5.18]
 - Stability
 

{meshagent_openai-0.5.18/meshagent_openai.egg-info → meshagent_openai-0.6.0}/PKG-INFO

@@ -1,21 +1,21 @@
 Metadata-Version: 2.4
 Name: meshagent-openai
-Version: 0.5.18
+Version: 0.6.0
 Summary: OpenAI Building Blocks for Meshagent
 License-Expression: Apache-2.0
 Project-URL: Documentation, https://docs.meshagent.com
 Project-URL: Website, https://www.meshagent.com
 Project-URL: Source, https://www.meshagent.com
-Requires-Python: >=3.12
+Requires-Python: >=3.13
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: pyjwt~=2.10
 Requires-Dist: pytest~=8.4
 Requires-Dist: pytest-asyncio~=0.26
-Requires-Dist: openai~=1.84
-Requires-Dist: meshagent-api~=0.5.18
-Requires-Dist: meshagent-agents~=0.5.18
-Requires-Dist: meshagent-tools~=0.5.18
+Requires-Dist: openai~=2.6.0
+Requires-Dist: meshagent-api~=0.6.0
+Requires-Dist: meshagent-agents~=0.6.0
+Requires-Dist: meshagent-tools~=0.6.0
 Dynamic: license-file
 
 # [Meshagent](https://www.meshagent.com)

{meshagent_openai-0.5.18 → meshagent_openai-0.6.0}/meshagent/openai/proxy/proxy.py

@@ -1,5 +1,8 @@
 from meshagent.api import RoomClient
 from openai import AsyncOpenAI
+import logging
+
+logger = logging.getLogger("openai.client")
 
 
 def get_client(*, room: RoomClient) -> AsyncOpenAI:
@@ -8,7 +11,14 @@ def get_client(*, room: RoomClient) -> AsyncOpenAI:
     # when running inside the room pod, the room.room_url currently points to the external url
     # so we need to use url off the protocol (if available).
     # TODO: room_url should be set properly, but may need a claim in the token to be set during call to say it is local
-    url: str = getattr(room.protocol, "url", room.room_url)
+    url = getattr(room.protocol, "url")
+    if url is None:
+        logger.debug(
+            f"protocol does not have url, openai client falling back to room url {room.room_url}"
+        )
+        url = room.room_url
+    else:
+        logger.debug(f"protocol had url, openai client will use {url}")
 
     room_proxy_url = f"{url}/v1"
 

{meshagent_openai-0.5.18 → meshagent_openai-0.6.0}/meshagent/openai/tools/completions_adapter.py

@@ -1,6 +1,5 @@
 from meshagent.agents.agent import AgentChatContext
-from meshagent.api import RoomClient, RoomException
-from meshagent.tools.blob import Blob, BlobStorage
+from meshagent.api import RoomClient, RoomException, RemoteParticipant
 from meshagent.tools import Toolkit, ToolContext
 from meshagent.api.messaging import (
     Response,
@@ -135,8 +134,7 @@ class CompletionsToolBundle:
 
 # Converts a tool response into a series of messages that can be inserted into the openai context
 class OpenAICompletionsToolResponseAdapter(ToolResponseAdapter):
-    def __init__(self, blob_storage: Optional[BlobStorage] = None):
-        self._blob_storage = blob_storage
+    def __init__(self):
         pass
 
     async def to_plain_text(self, *, room: RoomClient, response: Response) -> str:
@@ -155,10 +153,7 @@ class OpenAICompletionsToolResponseAdapter(ToolResponseAdapter):
             return response.text
 
         elif isinstance(response, FileResponse):
-            blob = Blob(mime_type=response.mime_type, data=response.data)
-            uri = self._blob_storage.store(blob=blob)
-
-            return f"The results have been written to a blob with the uri {uri} with the mime type {blob.mime_type}."
+            return f"{response.name}"
 
         elif isinstance(response, EmptyResponse):
             return "ok"
@@ -247,11 +242,13 @@ class OpenAICompletionsAdapter(LLMAdapter):
     async def next(
         self,
         *,
+        model: Optional[str] = None,
         context: AgentChatContext,
         room: RoomClient,
         toolkits: Toolkit,
         tool_adapter: Optional[ToolResponseAdapter] = None,
         output_schema: Optional[dict] = None,
+        on_behalf_of: Optional[RemoteParticipant] = None,
     ):
         if tool_adapter is None:
             tool_adapter = OpenAICompletionsToolResponseAdapter()

{meshagent_openai-0.5.18 → meshagent_openai-0.6.0}/meshagent/openai/tools/responses_adapter.py

@@ -1,6 +1,5 @@
 from meshagent.agents.agent import AgentChatContext
-from meshagent.api import RoomClient, RoomException
-from meshagent.tools.blob import Blob, BlobStorage
+from meshagent.api import RoomClient, RoomException, RemoteParticipant
 from meshagent.tools import Toolkit, ToolContext, Tool, BaseTool
 from meshagent.api.messaging import (
     Response,
@@ -12,7 +11,12 @@ from meshagent.api.messaging import (
     RawOutputs,
     ensure_response,
 )
-from meshagent.agents.adapter import ToolResponseAdapter, LLMAdapter
+from meshagent.agents.adapter import (
+    ToolResponseAdapter,
+    LLMAdapter,
+    ToolkitBuilder,
+    ToolkitConfig,
+)
 import json
 from typing import List, Literal
 from meshagent.openai.proxy import get_client
@@ -165,8 +169,7 @@ class ResponsesToolBundle:
 
 # Converts a tool response into a series of messages that can be inserted into the openai context
 class OpenAIResponsesToolResponseAdapter(ToolResponseAdapter):
-    def __init__(self, blob_storage: Optional[BlobStorage] = None):
-        self._blob_storage = blob_storage
+    def __init__(self):
         pass
 
     async def to_plain_text(self, *, room: RoomClient, response: Response) -> str:
@@ -185,10 +188,7 @@ class OpenAIResponsesToolResponseAdapter(ToolResponseAdapter):
             return response.text
 
         elif isinstance(response, FileResponse):
-            blob = Blob(mime_type=response.mime_type, data=response.data)
-            uri = self._blob_storage.store(blob=blob)
-
-            return f"The results have been written to a blob with the uri {uri} with the mime type {blob.mime_type}."
+            return f"{response.name}"
 
         elif isinstance(response, EmptyResponse):
             return "ok"
@@ -246,39 +246,88 @@ class OpenAIResponsesToolResponseAdapter(ToolResponseAdapter):
                     )
 
                 return response.outputs
+
             else:
                 span.set_attribute("kind", "text")
-                output = await self.to_plain_text(room=room, response=response)
-                span.set_attribute("output", output)
+                if isinstance(response, FileResponse):
+                    if response.mime_type.startswith("image/"):
+                        span.set_attribute(
+                            "output", f"image: {response.name}, {response.mime_type}"
+                        )
 
-                message = {
-                    "output": output,
-                    "call_id": tool_call.call_id,
-                    "type": "function_call_output",
-                }
+                        message = {
+                            "output": [
+                                {
+                                    "type": "input_image",
+                                    "image_url": f"data:{response.mime_type};base64,{base64.b64encode(response.data).decode()}",
+                                }
+                            ],
+                            "call_id": tool_call.call_id,
+                            "type": "function_call_output",
+                        }
+                    else:
+                        span.set_attribute(
+                            "output", f"file: {response.name}, {response.mime_type}"
+                        )
 
-                room.developer.log_nowait(
-                    type="llm.message",
-                    data={
-                        "context": context.id,
-                        "participant_id": room.local_participant.id,
-                        "participant_name": room.local_participant.get_attribute(
-                            "name"
-                        ),
-                        "message": message,
-                    },
-                )
+                        message = {
+                            "output": [
+                                {
+                                    "type": "input_file",
+                                    "filename": response.name,
+                                    "file_data": f"data:{response.mime_type};base64,{base64.b64encode(response.data).decode()}",
+                                }
+                            ],
+                            "call_id": tool_call.call_id,
+                            "type": "function_call_output",
+                        }
 
-                return [message]
+                    room.developer.log_nowait(
+                        type="llm.message",
+                        data={
+                            "context": context.id,
+                            "participant_id": room.local_participant.id,
+                            "participant_name": room.local_participant.get_attribute(
+                                "name"
+                            ),
+                            "message": message,
+                        },
+                    )
 
+                    return [message]
+                else:
+                    output = await self.to_plain_text(room=room, response=response)
+                    span.set_attribute("output", output)
 
-class OpenAIResponsesAdapter(LLMAdapter[ResponsesToolBundle]):
+                    message = {
+                        "output": output,
+                        "call_id": tool_call.call_id,
+                        "type": "function_call_output",
+                    }
+
+                    room.developer.log_nowait(
+                        type="llm.message",
+                        data={
+                            "context": context.id,
+                            "participant_id": room.local_participant.id,
+                            "participant_name": room.local_participant.get_attribute(
+                                "name"
+                            ),
+                            "message": message,
+                        },
+                    )
+
+                    return [message]
+
+
+class OpenAIResponsesAdapter(LLMAdapter[ResponseStreamEvent]):
     def __init__(
         self,
-        model: str = os.getenv("OPENAI_MODEL", "gpt-4.1"),
+        model: str = os.getenv("OPENAI_MODEL", "gpt-5"),
         parallel_tool_calls: Optional[bool] = None,
         client: Optional[AsyncOpenAI] = None,
         response_options: Optional[dict] = None,
+        reasoning_effort: Optional[str] = None,
         provider: str = "openai",
     ):
         self._model = model
@@ -286,6 +335,10 @@ class OpenAIResponsesAdapter(LLMAdapter[ResponsesToolBundle]):
         self._client = client
         self._response_options = response_options
         self._provider = provider
+        self._reasoning_effort = reasoning_effort
+
+    def default_model(self) -> str:
+        return self._model
 
     def create_chat_context(self):
         system_role = "system"
@@ -316,13 +369,18 @@ class OpenAIResponsesAdapter(LLMAdapter[ResponsesToolBundle]):
     async def next(
         self,
         *,
+        model: Optional[str] = None,
         context: AgentChatContext,
         room: RoomClient,
         toolkits: list[Toolkit],
         tool_adapter: Optional[ToolResponseAdapter] = None,
         output_schema: Optional[dict] = None,
         event_handler: Optional[Callable[[ResponseStreamEvent], None]] = None,
+        on_behalf_of: Optional[RemoteParticipant] = None,
     ):
+        if model is None:
+            model = self.default_model()
+
         with tracer.start_as_current_span("llm.turn") as span:
             span.set_attributes({"chat_context": context.id, "api": "responses"})
 
@@ -333,7 +391,7 @@ class OpenAIResponsesAdapter(LLMAdapter[ResponsesToolBundle]):
                 while True:
                     with tracer.start_as_current_span("llm.turn.iteration") as span:
                         span.set_attributes(
-                            {"model": self._model, "provider": self._provider}
+                            {"model": model, "provider": self._provider}
                         )
 
                         openai = (
@@ -359,7 +417,7 @@ class OpenAIResponsesAdapter(LLMAdapter[ResponsesToolBundle]):
 
                         ptc = self._parallel_tool_calls
                         extra = {}
-                        if ptc is not None and not self._model.startswith("o"):
+                        if ptc is not None and not model.startswith("o"):
                             extra["parallel_tool_calls"] = ptc
                             span.set_attribute("parallel_tool_calls", ptc)
                         else:
@@ -386,12 +444,30 @@ class OpenAIResponsesAdapter(LLMAdapter[ResponsesToolBundle]):
                         stream = event_handler is not None
 
                         with tracer.start_as_current_span("llm.invoke") as span:
-                            response_options = self._response_options
+                            response_options = copy.deepcopy(self._response_options)
                             if response_options is None:
                                 response_options = {}
+
+                            if self._reasoning_effort is not None:
+                                response_options["reasoning"] = {
+                                    "effort": self._reasoning_effort,
+                                    "summary": "detailed",
+                                }
+
+                            extra_headers = {}
+                            if on_behalf_of is not None:
+                                on_behalf_of_name = on_behalf_of.get_attribute("name")
+                                logger.info(
+                                    f"{room.local_participant.get_attribute('name')} making openai request on behalf of {on_behalf_of_name}"
+                                )
+                                extra_headers["Meshagent-On-Behalf-Of"] = (
+                                    on_behalf_of_name
+                                )
+
                             response: Response = await openai.responses.create(
+                                extra_headers=extra_headers,
                                 stream=stream,
-                                model=self._model,
+                                model=model,
                                 input=context.messages,
                                 tools=open_ai_tools,
                                 text=text,
@@ -727,7 +803,6 @@ class OpenAIResponsesAdapter(LLMAdapter[ResponsesToolBundle]):
                                                 "event": safe_model_dump(event),
                                             }
                                         )
-
                                         event_handler(event)
 
                                         if event.type == "response.completed":
@@ -815,32 +890,47 @@ class OpenAIResponsesTool(BaseTool):
         return {}
 
 
+class ImageGenerationConfig(ToolkitConfig):
+    name: Literal["image_generation"]
+    background: Literal["transparent", "opaque", "auto"] = None
+    input_image_mask_url: Optional[str] = None
+    model: Optional[str] = None
+    moderation: Optional[str] = None
+    output_compression: Optional[int] = None
+    output_format: Optional[Literal["png", "webp", "jpeg"]] = None
+    partial_images: Optional[int] = None
+    quality: Optional[Literal["auto", "low", "medium", "high"]] = None
+    size: Optional[Literal["1024x1024", "1024x1536", "1536x1024", "auto"]] = None
+
+
+class ImageGenerationToolkitBuilder(ToolkitBuilder):
+    def __init__(self):
+        super().__init__(name="image_generation", type=ImageGenerationConfig)
+
+    def make(self, *, model: str, config: ImageGenerationConfig):
+        return Toolkit(
+            name="image_generation", tools=[ImageGenerationTool(config=config)]
+        )
+
+
 class ImageGenerationTool(OpenAIResponsesTool):
     def __init__(
         self,
         *,
-        background: Literal["transparent", "opaque", "auto"] = None,
-        input_image_mask_url: Optional[str] = None,
-        model: Optional[str] = None,
-        moderation: Optional[str] = None,
-        output_compression: Optional[int] = None,
-        output_format: Optional[Literal["png", "webp", "jpeg"]] = None,
-        partial_images: Optional[int] = None,
-        quality: Optional[Literal["auto", "low", "medium", "high"]] = None,
-        size: Optional[Literal["1024x1024", "1024x1536", "1536x1024", "auto"]] = None,
+        config: ImageGenerationConfig,
     ):
         super().__init__(name="image_generation")
-        self.background = background
-        self.input_image_mask_url = input_image_mask_url
-        self.model = model
-        self.moderation = moderation
-        self.output_compression = output_compression
-        self.output_format = output_format
-        if partial_images is None:
-            partial_images = 1  # streaming wants non zero, and we stream by default
-        self.partial_images = partial_images
-        self.quality = quality
-        self.size = size
+        self.background = config.background
+        self.input_image_mask_url = config.input_image_mask_url
+        self.model = config.model
+        self.moderation = config.moderation
+        self.output_compression = config.output_compression
+        self.output_format = config.output_format
+        self.partial_images = (
+            config.partial_images if config.partial_images is not None else 1
+        )
+        self.quality = config.quality
+        self.size = config.size
 
     def get_open_ai_tool_definitions(self):
         opts = {"type": "image_generation"}
@@ -986,8 +1076,20 @@ class ImageGenerationTool(OpenAIResponsesTool):
             )
 
 
-class LocalShellTool(OpenAIResponsesTool):
+class LocalShellConfig(ToolkitConfig):
+    name: Literal["local_shell"]
+
+
+class LocalShellToolkitBuilder(ToolkitBuilder):
     def __init__(self):
+        super().__init__(name="local_shell", type=LocalShellConfig)
+
+    def make(self, *, model: str, config: LocalShellConfig):
+        return Toolkit(name="local_shell", tools=[LocalShellTool(config=config)])
+
+
+class LocalShellTool(OpenAIResponsesTool):
+    def __init__(self, *, config: LocalShellConfig):
         super().__init__(name="local_shell")
 
     def get_open_ai_tool_definitions(self):
@@ -1153,34 +1255,40 @@ class MCPToolDefinition:
         self.description = description
 
 
-class MCPServer:
-    def __init__(
-        self,
-        *,
-        server_label: str,
-        server_url: str,
-        allowed_tools: Optional[list[str]] = None,
-        headers: Optional[dict] = None,
-        # require approval for all tools
-        require_approval: Optional[Literal["always", "never"]] = None,
-        # list of tools that always require approval
-        always_require_approval: Optional[list[str]] = None,
-        # list of tools that never require approval
-        never_require_approval: Optional[list[str]] = None,
-    ):
-        self.server_label = server_label
-        self.server_url = server_url
-        self.allowed_tools = allowed_tools
-        self.headers = headers
-        self.require_approval = require_approval
-        self.always_require_approval = always_require_approval
-        self.never_require_approval = never_require_approval
+class MCPServer(BaseModel):
+    server_label: str
+    server_url: Optional[str] = None
+    allowed_tools: Optional[list[str]] = None
+    authorization: Optional[str] = None
+    headers: Optional[dict] = None
+
+    # require approval for all tools
+    require_approval: Optional[Literal["always", "never"]] = None
+    # list of tools that always require approval
+    always_require_approval: Optional[list[str]] = None
+    # list of tools that never require approval
+    never_require_approval: Optional[list[str]] = None
+
+    openai_connector_id: Optional[str] = None
+
+
+class MCPConfig(ToolkitConfig):
+    name: Literal["mcp"]
+    servers: list[MCPServer]
+
+
+class MCPToolkitBuilder(ToolkitBuilder):
+    def __init__(self):
+        super().__init__(name="mcp", type=MCPConfig)
+
+    def make(self, *, model: str, config: MCPConfig):
+        return Toolkit(name="mcp", tools=[MCPTool(config=config)])
 
 
 class MCPTool(OpenAIResponsesTool):
-    def __init__(self, *, servers: list[MCPServer]):
+    def __init__(self, *, config: MCPConfig):
         super().__init__(name="mcp")
-        self.servers = servers
+        self.servers = config.servers
 
     def get_open_ai_tool_definitions(self):
         defs = []
@@ -1188,12 +1296,20 @@ class MCPTool(OpenAIResponsesTool):
             opts = {
                 "type": "mcp",
                 "server_label": server.server_label,
-                "server_url": server.server_url,
             }
 
+            if server.server_url is not None:
+                opts["server_url"] = server.server_url
+
+            if server.openai_connector_id is not None:
+                opts["connector_id"] = server.openai_connector_id
+
             if server.allowed_tools is not None:
                 opts["allowed_tools"] = server.allowed_tools
 
+            if server.authorization is not None:
+                opts["authorization"] = server.authorization
+
             if server.headers is not None:
                 opts["headers"] = server.headers
 
@@ -1396,19 +1512,19 @@ class MCPTool(OpenAIResponsesTool):
         type: str,
         **extra,
     ):
-        logger.info("approval requested for MCP tool {server_label}.{name}")
+        logger.info(f"approval requested for MCP tool {server_label}.{name}")
         should_approve = await self.on_mcp_approval_request(
             context, arguments=arguments, name=name, server_label=server_label
         )
         if should_approve:
-            logger.info("approval granted for MCP tool {server_label}.{name}")
+            logger.info(f"approval granted for MCP tool {server_label}.{name}")
             return {
                 "type": "mcp_approval_response",
                 "approve": True,
                 "approval_request_id": id,
             }
         else:
-            logger.info("approval denied for MCP tool {server_label}.{name}")
+            logger.info(f"approval denied for MCP tool {server_label}.{name}")
             return {
                 "type": "mcp_approval_response",
                 "approve": False,
@@ -1442,7 +1558,6 @@ class ReasoningTool(OpenAIResponsesTool):
         part: dict,
         sequence_number: int,
         summary_index: int,
-        text: str,
         type: str,
         **extra,
     ):
@@ -1457,7 +1572,6 @@ class ReasoningTool(OpenAIResponsesTool):
         part: dict,
         sequence_number: int,
         summary_index: int,
-        text: str,
         type: str,
         **extra,
     ):
@@ -1471,7 +1585,6 @@ class ReasoningTool(OpenAIResponsesTool):
         output_index: int,
         sequence_number: int,
         summary_index: int,
-        text: str,
         type: str,
         **extra,
     ):
@@ -1485,7 +1598,6 @@ class ReasoningTool(OpenAIResponsesTool):
         output_index: int,
         sequence_number: int,
         summary_index: int,
-        text: str,
         type: str,
         **extra,
     ):
@@ -1495,7 +1607,8 @@ class ReasoningTool(OpenAIResponsesTool):
         self,
         context: ToolContext,
         *,
-        summary: str,
+        summary: list[str],
+        content: Optional[list[str]] = None,
         encrypted_content: str | None,
         status: Literal["in_progress", "completed", "incomplete"],
     ):
@@ -1506,22 +1619,39 @@ class ReasoningTool(OpenAIResponsesTool):
         context: ToolContext,
         *,
         id: str,
-        summary: str,
+        summary: list[dict],
         type: str,
+        content: Optional[list[dict]],
         encrypted_content: str | None,
         status: str,
         **extra,
     ):
         await self.on_reasoning(
-            context, summary=summary, encrypted_content=encrypted_content, status=status
+            context,
+            summary=summary,
+            content=content,
+            encrypted_content=encrypted_content,
+            status=status,
         )
 
 
 # TODO: computer tool call
 
 
-class WebSearchTool(OpenAIResponsesTool):
+class WebSearchConfig(ToolkitConfig):
+    name: Literal["web_search"]
+
+
+class WebSearchToolkitBuilder(ToolkitBuilder):
     def __init__(self):
+        super().__init__(name="web_search", type=WebSearchConfig)
+
+    def make(self, *, model: str, config: WebSearchConfig):
+        return Toolkit(name="web_search", tools=[WebSearchTool(config=config)])
+
+
+class WebSearchTool(OpenAIResponsesTool):
+    def __init__(self, *, config: WebSearchConfig):
         super().__init__(name="web_search")
 
     def get_open_ai_tool_definitions(self) -> list[dict]:

meshagent_openai-0.6.0/meshagent/openai/version.py

@@ -0,0 +1 @@
+__version__ = "0.6.0"

{meshagent_openai-0.5.18 → meshagent_openai-0.6.0/meshagent_openai.egg-info}/PKG-INFO

@@ -1,21 +1,21 @@
 Metadata-Version: 2.4
 Name: meshagent-openai
-Version: 0.5.18
+Version: 0.6.0
 Summary: OpenAI Building Blocks for Meshagent
 License-Expression: Apache-2.0
 Project-URL: Documentation, https://docs.meshagent.com
 Project-URL: Website, https://www.meshagent.com
 Project-URL: Source, https://www.meshagent.com
-Requires-Python: >=3.12
+Requires-Python: >=3.13
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: pyjwt~=2.10
 Requires-Dist: pytest~=8.4
 Requires-Dist: pytest-asyncio~=0.26
-Requires-Dist: openai~=1.84
-Requires-Dist: meshagent-api~=0.5.18
-Requires-Dist: meshagent-agents~=0.5.18
-Requires-Dist: meshagent-tools~=0.5.18
+Requires-Dist: openai~=2.6.0
+Requires-Dist: meshagent-api~=0.6.0
+Requires-Dist: meshagent-agents~=0.6.0
+Requires-Dist: meshagent-tools~=0.6.0
 Dynamic: license-file
 
 # [Meshagent](https://www.meshagent.com)

meshagent_openai-0.6.0/meshagent_openai.egg-info/requires.txt

@@ -0,0 +1,7 @@
+pyjwt~=2.10
+pytest~=8.4
+pytest-asyncio~=0.26
+openai~=2.6.0
+meshagent-api~=0.6.0
+meshagent-agents~=0.6.0
+meshagent-tools~=0.6.0

{meshagent_openai-0.5.18 → meshagent_openai-0.6.0}/pyproject.toml

@@ -6,17 +6,17 @@ build-backend = "setuptools.build_meta"
 name = "meshagent-openai"
 description = "OpenAI Building Blocks for Meshagent"
 dynamic = ["version", "readme"]
-requires-python = ">=3.12"
+requires-python = ">=3.13"
 license = "Apache-2.0"
 keywords = []
 dependencies = [
   "pyjwt~=2.10",
   "pytest~=8.4",
   "pytest-asyncio~=0.26",
-  "openai~=1.84",
-  "meshagent-api~=0.5.18",
-  "meshagent-agents~=0.5.18",
-  "meshagent-tools~=0.5.18"
+  "openai~=2.6.0",
+  "meshagent-api~=0.6.0",
+  "meshagent-agents~=0.6.0",
+  "meshagent-tools~=0.6.0"
 ]
 
 [project.urls]

meshagent_openai-0.5.18/meshagent/openai/version.py

@@ -1 +0,0 @@
-__version__ = "0.5.18"

meshagent_openai-0.5.18/meshagent_openai.egg-info/requires.txt

@@ -1,7 +0,0 @@
-pyjwt~=2.10
-pytest~=8.4
-pytest-asyncio~=0.26
-openai~=1.84
-meshagent-api~=0.5.18
-meshagent-agents~=0.5.18
-meshagent-tools~=0.5.18