meshagent-openai 0.5.15__py3-none-any.whl → 0.6.0__py3-none-any.whl

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/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,17 +242,19 @@ 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()
 
         try:
-            openai = get_client(room=room)
+            openai = self._client if self._client is not None else get_client(room=room)
 
             tool_bundle = CompletionsToolBundle(
                 toolkits=[

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",
+                        }
+
+                    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)
+
+                    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]
+                    return [message]
 
 
-class OpenAIResponsesAdapter(LLMAdapter[ResponsesToolBundle]):
+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,10 +391,14 @@ 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 = get_client(room=room)
+                        openai = (
+                            self._client
+                            if self._client is not None
+                            else get_client(room=room)
+                        )
 
                         response_schema = output_schema
                         response_name = "response"
@@ -355,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:
@@ -382,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,
@@ -723,7 +803,6 @@ class OpenAIResponsesAdapter(LLMAdapter[ResponsesToolBundle]):
                                                 "event": safe_model_dump(event),
                                             }
                                         )
-
                                         event_handler(event)
 
                                         if event.type == "response.completed":
@@ -811,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"}
@@ -982,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):
@@ -1149,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 = []
@@ -1184,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
 
@@ -1392,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,
@@ -1438,7 +1558,6 @@ class ReasoningTool(OpenAIResponsesTool):
         part: dict,
         sequence_number: int,
         summary_index: int,
-        text: str,
         type: str,
         **extra,
     ):
@@ -1453,7 +1572,6 @@ class ReasoningTool(OpenAIResponsesTool):
         part: dict,
         sequence_number: int,
         summary_index: int,
-        text: str,
         type: str,
         **extra,
     ):
@@ -1467,7 +1585,6 @@ class ReasoningTool(OpenAIResponsesTool):
         output_index: int,
         sequence_number: int,
         summary_index: int,
-        text: str,
         type: str,
         **extra,
     ):
@@ -1481,7 +1598,6 @@ class ReasoningTool(OpenAIResponsesTool):
         output_index: int,
         sequence_number: int,
         summary_index: int,
-        text: str,
         type: str,
         **extra,
     ):
@@ -1491,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"],
     ):
@@ -1502,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/version.py

@@ -1 +1 @@
-__version__ = "0.5.15"
+__version__ = "0.6.0"

{meshagent_openai-0.5.15.dist-info → meshagent_openai-0.6.0.dist-info}/METADATA

@@ -1,21 +1,21 @@
 Metadata-Version: 2.4
 Name: meshagent-openai
-Version: 0.5.15
+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.15
-Requires-Dist: meshagent-agents~=0.5.15
-Requires-Dist: meshagent-tools~=0.5.15
+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.dist-info/RECORD

@@ -0,0 +1,15 @@
+meshagent/openai/__init__.py,sha256=g4RSQWfL2El6HQ8i2Aw8wwBEJVC861Z61S0GqkFnBys,369
+meshagent/openai/version.py,sha256=cID1jLnC_vj48GgMN6Yb1FA3JsQ95zNmCHmRYE8TFhY,22
+meshagent/openai/proxy/__init__.py,sha256=PkOCHmUptsbuX5sNlWJk5bMxnSzyg5AZhPtooEPV7XE,54
+meshagent/openai/proxy/proxy.py,sha256=1TX8DdFp7p1N3zoIgS-1u0JZgf9-5i1XpqnvHlmNX90,1145
+meshagent/openai/tools/__init__.py,sha256=cLXoB9CBqKbCGhZMAJTIX6-yv_UO8AxpaH8vQQ1e8VY,467
+meshagent/openai/tools/completions_adapter.py,sha256=dBRXuWxc2LiWaTpA8agMhwxhRvbxbMnggvv_9QtK-HA,15946
+meshagent/openai/tools/responses_adapter.py,sha256=V5UheGWDT1VZsk1xERlq8Vm7HUrEEb1WphkI24zqvz4,69152
+meshagent/openai/tools/schema.py,sha256=YaP0iEL9Lf2qS4xZy8VILjr1IS52XS9LEcn_cskNreo,10079
+meshagent/openai/tools/stt.py,sha256=H3YusIjigJwxfEdkrK5qZ6DHbjQagaLNj7q_-fTfwy4,3845
+meshagent/openai/tools/stt_test.py,sha256=XE4qZBlNeEWdJW5NjBGyaJmuCKN0ZLlJ2b_GBp7MzVk,2651
+meshagent_openai-0.6.0.dist-info/licenses/LICENSE,sha256=eTt0SPW-sVNdkZe9PS_S8WfCIyLjRXRl7sUBWdlteFg,10254
+meshagent_openai-0.6.0.dist-info/METADATA,sha256=jnQ2bKYKgb20hzC6Sjee2l_VvekxEZsUVFazJFw19pw,2104
+meshagent_openai-0.6.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+meshagent_openai-0.6.0.dist-info/top_level.txt,sha256=GlcXnHtRP6m7zlG3Df04M35OsHtNXy_DY09oFwWrH74,10
+meshagent_openai-0.6.0.dist-info/RECORD,,

meshagent_openai-0.5.15.dist-info/RECORD

@@ -1,15 +0,0 @@
-meshagent/openai/__init__.py,sha256=g4RSQWfL2El6HQ8i2Aw8wwBEJVC861Z61S0GqkFnBys,369
-meshagent/openai/version.py,sha256=L6LoKMlJx-n68Agaz17S4PydD7S5Z4lwW3o79dy3l1c,23
-meshagent/openai/proxy/__init__.py,sha256=PkOCHmUptsbuX5sNlWJk5bMxnSzyg5AZhPtooEPV7XE,54
-meshagent/openai/proxy/proxy.py,sha256=EC9LMQ6iv8bWnoGVFx78Sx7C_oaCi8Oq4bcMagleTiY,845
-meshagent/openai/tools/__init__.py,sha256=cLXoB9CBqKbCGhZMAJTIX6-yv_UO8AxpaH8vQQ1e8VY,467
-meshagent/openai/tools/completions_adapter.py,sha256=uW1sNK9RZ1jCUq0z17zjGJ8XPh97ugXpoIGF-PGH-mY,16132
-meshagent/openai/tools/responses_adapter.py,sha256=-zdbBIV63fBsfnzEU-lFFzILw64Ui5LsBnDftSytgHo,64248
-meshagent/openai/tools/schema.py,sha256=YaP0iEL9Lf2qS4xZy8VILjr1IS52XS9LEcn_cskNreo,10079
-meshagent/openai/tools/stt.py,sha256=H3YusIjigJwxfEdkrK5qZ6DHbjQagaLNj7q_-fTfwy4,3845
-meshagent/openai/tools/stt_test.py,sha256=XE4qZBlNeEWdJW5NjBGyaJmuCKN0ZLlJ2b_GBp7MzVk,2651
-meshagent_openai-0.5.15.dist-info/licenses/LICENSE,sha256=eTt0SPW-sVNdkZe9PS_S8WfCIyLjRXRl7sUBWdlteFg,10254
-meshagent_openai-0.5.15.dist-info/METADATA,sha256=RoWfhJpqE_bsOLWNcncxRrFI5HpksF-gcvuAvQ23W9g,2107
-meshagent_openai-0.5.15.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-meshagent_openai-0.5.15.dist-info/top_level.txt,sha256=GlcXnHtRP6m7zlG3Df04M35OsHtNXy_DY09oFwWrH74,10
-meshagent_openai-0.5.15.dist-info/RECORD,,