meshagent-openai 0.0.1__tar.gz

meshagent_openai-0.0.1/LICENSE

@@ -0,0 +1,201 @@
+Apache License
+Version 2.0, January 2004
+http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+"License" shall mean the terms and conditions for use, reproduction,
+and distribution as defined by Sections 1 through 9 of this document.
+
+"Licensor" shall mean the copyright owner or entity authorized by
+the copyright owner that is granting the License.
+
+"Legal Entity" shall mean the union of the acting entity and all
+other entities that control, are controlled by, or are under common
+control with that entity. For the purposes of this definition,
+"control" means (i) the power, direct or indirect, to cause the
+direction or management of such entity, whether by contract or
+otherwise, or (ii) ownership of fifty percent (50%) or more of the
+outstanding shares, or (iii) beneficial ownership of such entity.
+
+"You" (or "Your") shall mean an individual or Legal Entity
+exercising permissions granted by this License.
+
+"Source" form shall mean the preferred form for making modifications,
+including but not limited to software source code, documentation
+source, and configuration files.
+
+"Object" form shall mean any form resulting from mechanical
+transformation or translation of a Source form, including but
+not limited to compiled object code, generated documentation,
+and conversions to other media types.
+
+"Work" shall mean the work of authorship, whether in Source or
+Object form, made available under the License, as indicated by a
+copyright notice that is included in or attached to the work
+(an example is provided in the Appendix below).
+
+"Derivative Works" shall mean any work, whether in Source or Object
+form, that is based on (or derived from) the Work and for which the
+editorial revisions, annotations, elaborations, or other modifications
+represent, as a whole, an original work of authorship. For the purposes
+of this License, Derivative Works shall not include works that remain
+separable from, or merely link (or bind by name) to the interfaces of,
+the Work and Derivative Works thereof.
+
+"Contribution" shall mean any work of authorship, including
+the original version of the Work and any modifications or additions
+to that Work or Derivative Works thereof, that is intentionally
+submitted to Licensor for inclusion in the Work by the copyright owner
+or by an individual or Legal Entity authorized to submit on behalf of
+the copyright owner. For the purposes of this definition, "submitted"
+means any form of electronic, verbal, or written communication sent
+to the Licensor or its representatives, including but not limited to
+communication on electronic mailing lists, source code control systems,
+and issue tracking systems that are managed by, or on behalf of, the
+Licensor for the purpose of discussing and improving the Work, but
+excluding communication that is conspicuously marked or otherwise
+designated in writing by the copyright owner as "Not a Contribution."
+
+"Contributor" shall mean Licensor and any individual or Legal Entity
+on behalf of whom a Contribution has been received by Licensor and
+subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+this License, each Contributor hereby grants to You a perpetual,
+worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+copyright license to reproduce, prepare Derivative Works of,
+publicly display, publicly perform, sublicense, and distribute the
+Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+this License, each Contributor hereby grants to You a perpetual,
+worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+(except as stated in this section) patent license to make, have made,
+use, offer to sell, sell, import, and otherwise transfer the Work,
+where such license applies only to those patent claims licensable
+by such Contributor that are necessarily infringed by their
+Contribution(s) alone or by combination of their Contribution(s)
+with the Work to which such Contribution(s) was submitted. If You
+institute patent litigation against any entity (including a
+cross-claim or counterclaim in a lawsuit) alleging that the Work
+or a Contribution incorporated within the Work constitutes direct
+or contributory patent infringement, then any patent licenses
+granted to You under this License for that Work shall terminate
+as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+Work or Derivative Works thereof in any medium, with or without
+modifications, and in Source or Object form, provided that You
+meet the following conditions:
+
+(a) You must give any other recipients of the Work or
+Derivative Works a copy of this License; and
+
+(b) You must cause any modified files to carry prominent notices
+stating that You changed the files; and
+
+(c) You must retain, in the Source form of any Derivative Works
+that You distribute, all copyright, patent, trademark, and
+attribution notices from the Source form of the Work,
+excluding those notices that do not pertain to any part of
+the Derivative Works; and
+
+(d) If the Work includes a "NOTICE" text file as part of its
+distribution, then any Derivative Works that You distribute must
+include a readable copy of the attribution notices contained
+within such NOTICE file, excluding those notices that do not
+pertain to any part of the Derivative Works, in at least one
+of the following places: within a NOTICE text file distributed
+as part of the Derivative Works; within the Source form or
+documentation, if provided along with the Derivative Works; or,
+within a display generated by the Derivative Works, if and
+wherever such third-party notices normally appear. The contents
+of the NOTICE file are for informational purposes only and
+do not modify the License. You may add Your own attribution
+notices within Derivative Works that You distribute, alongside
+or as an addendum to the NOTICE text from the Work, provided
+that such additional attribution notices cannot be construed
+as modifying the License.
+
+You may add Your own copyright statement to Your modifications and
+may provide additional or different license terms and conditions
+for use, reproduction, or distribution of Your modifications, or
+for any such Derivative Works as a whole, provided Your use,
+reproduction, and distribution of the Work otherwise complies with
+the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+any Contribution intentionally submitted for inclusion in the Work
+by You to the Licensor shall be under the terms and conditions of
+this License, without any additional terms or conditions.
+Notwithstanding the above, nothing herein shall supersede or modify
+the terms of any separate license agreement you may have executed
+with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+names, trademarks, service marks, or product names of the Licensor,
+except as required for reasonable and customary use in describing the
+origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+agreed to in writing, Licensor provides the Work (and each
+Contributor provides its Contributions) on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+implied, including, without limitation, any warranties or conditions
+of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+PARTICULAR PURPOSE. You are solely responsible for determining the
+appropriateness of using or redistributing the Work and assume any
+risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+whether in tort (including negligence), contract, or otherwise,
+unless required by applicable law (such as deliberate and grossly
+negligent acts) or agreed to in writing, shall any Contributor be
+liable to You for damages, including any direct, indirect, special,
+incidental, or consequential damages of any character arising as a
+result of this License or out of the use or inability to use the
+Work (including but not limited to damages for loss of goodwill,
+work stoppage, computer failure or malfunction, or any and all
+other commercial damages or losses), even if such Contributor
+has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+the Work or Derivative Works thereof, You may choose to offer,
+and charge a fee for, acceptance of support, warranty, indemnity,
+or other liability obligations and/or rights consistent with this
+License. However, in accepting such obligations, You may act only
+on Your own behalf and on Your sole responsibility, not on behalf
+of any other Contributor, and only if You agree to indemnify,
+defend, and hold each Contributor harmless for any liability
+incurred by, or claims asserted against, such Contributor by reason
+of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+To apply the Apache License to your work, attach the following
+boilerplate notice, with the fields enclosed by brackets "[]"
+replaced with your own identifying information. (Don't include
+the brackets!)  The text should be enclosed in the appropriate
+comment syntax for the file format. We also recommend that a
+file or class name and description of purpose be included on the
+same "printed page" as the copyright notice for easier
+identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+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.

meshagent_openai-0.0.1/MANIFEST.in

@@ -0,0 +1 @@
+include version.py

meshagent_openai-0.0.1/PKG-INFO

@@ -0,0 +1,25 @@
+Metadata-Version: 2.2
+Name: meshagent-openai
+Version: 0.0.1
+Summary: OpenAI Building Blocks for Meshagent
+Home-page: 
+License: Apache License 2.0
+Project-URL: Documentation, https://meshagent.com
+Project-URL: Website, https://meshagent.com
+Project-URL: Source, https://github.com/meshagent
+Requires-Python: >=3.9.0
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pyjwt>=2.0.0
+Requires-Dist: pytest>=8.3.4
+Requires-Dist: pytest-asyncio>=0.24.0
+Requires-Dist: openai>=1.66.2
+Requires-Dist: meshagent-api>=0.0.1
+Requires-Dist: meshagent-agents>=0.0.1
+Requires-Dist: meshagent-tools>=0.0.1
+Dynamic: description-content-type
+Dynamic: license
+Dynamic: project-url
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

meshagent_openai-0.0.1/meshagent/openai/__init__.py

@@ -0,0 +1 @@
+from .tools import OpenAICompletionsAdapter, OpenAIResponsesAdapter, OpenAICompletionsToolResponseAdapter, OpenAIResponsesToolResponseAdapter

meshagent_openai-0.0.1/meshagent/openai/tools/__init__.py

@@ -0,0 +1,2 @@
+from .responses_adapter import OpenAIResponsesAdapter, OpenAIResponsesToolResponseAdapter
+from .completions_adapter import OpenAICompletionsAdapter, OpenAICompletionsToolResponseAdapter

meshagent_openai-0.0.1/meshagent/openai/tools/completions_adapter.py

@@ -0,0 +1,390 @@
+
+from meshagent.agents.agent import Agent, AgentChatContext, AgentCallContext
+from meshagent.api import WebSocketClientProtocol, RoomClient, RoomException
+from meshagent.tools.blob import Blob, BlobStorage
+from meshagent.tools import Toolkit, ToolContext, Tool
+from meshagent.api.messaging import Response, LinkResponse, FileResponse, JsonResponse, TextResponse, EmptyResponse
+from meshagent.agents.schema import prompt_schema
+from meshagent.agents.adapter import ToolResponseAdapter, LLMAdapter
+from uuid import uuid4
+import json
+from jsonschema import validate
+from typing import List, Dict
+
+from openai import AsyncOpenAI, APIStatusError
+from openai.types.chat import ChatCompletion, ChatCompletionMessage, ChatCompletionMessageToolCall
+
+from copy import deepcopy
+from abc import abstractmethod, ABC
+import os
+import jsonschema
+from typing import Optional, Any
+
+import logging
+import re
+import asyncio
+
+logging.basicConfig()
+logger = logging.getLogger("openai_agent")
+logger.setLevel(logging.INFO)
+
+
+
+
+def _replace_non_matching(text: str, allowed_chars: str, replacement: str) -> str:
+    """
+    Replaces every character in `text` that does not match the given
+    `allowed_chars` regex set with `replacement`.
+    
+    Parameters:
+    -----------
+    text : str
+        The input string on which the replacement is to be done.
+    allowed_chars : str
+        A string defining the set of allowed characters (part of a character set).
+        For example, "a-zA-Z0-9" will keep only letters and digits.
+    replacement : str
+        The string to replace non-matching characters with.
+        
+    Returns:
+    --------
+    str
+        A new string where all characters not in `allowed_chars` are replaced.
+    """
+    # Build a regex that matches any character NOT in allowed_chars
+    pattern = rf"[^{allowed_chars}]"
+    return re.sub(pattern, replacement, text)
+
+def safe_tool_name(name: str):
+    return _replace_non_matching(name, "a-zA-Z0-9_-", "_")
+
+# Collects a group of tool proxies and manages execution of openai tool calls
+class CompletionsToolBundle:
+    def __init__(self, toolkits: List[Toolkit]):
+        self._toolkits = toolkits
+        self._executors = dict[str, Toolkit]()
+        self._safe_names = {}
+
+        open_ai_tools = []
+        
+        for toolkit in toolkits:                
+            for v in toolkit.tools:
+
+                k = v.name
+
+                name = safe_tool_name(k)
+
+                if k in self._executors:
+                    raise Exception(f"duplicate in bundle '{k}', tool names must be unique.")
+
+                self._executors[k] = toolkit
+
+                self._safe_names[name] = k
+
+                fn = {
+                    "name" : name,
+                    "parameters" : {
+                        **v.input_schema,
+                    },
+                    "strict": True,
+                }
+
+
+                if v.defs != None:
+                    fn["parameters"]["$defs"] = v.defs
+          
+
+                schema = {
+                    "type" : "function",       
+                    "function" : fn,
+                }
+
+
+                open_ai_tools.append(schema)
+
+        if len(open_ai_tools) == 0:
+            open_ai_tools = None
+
+        self._open_ai_tools = open_ai_tools
+
+    async def execute(self, *, context: ToolContext, tool_call: ChatCompletionMessageToolCall) -> Response:
+        try:
+            
+            function = tool_call.function
+            name = function.name
+            arguments = json.loads(function.arguments)
+
+            if name not in self._safe_names:
+                raise RoomException(f"Invalid tool name {name}, check the name of the tool")
+            
+            name = self._safe_names[name]
+
+            if name not in self._executors:
+                raise Exception(f"Unregistered tool name {name}")
+
+            logger.info("executing %s %s %s", tool_call.id, name, arguments)
+
+            proxy = self._executors[name]
+            result = await proxy.execute(context=context, name=name, arguments=arguments)
+            logger.info("success calling %s %s %s", tool_call.id, name, result)        
+            return result
+
+        except Exception as e:
+            logger.error("failed calling %s %s", tool_call.id, name, exc_info=e)
+            raise
+
+    def contains(self, name: str) -> bool:
+        return name in self._open_ai_tools
+
+    def to_json(self) -> List[dict] | None:
+        if self._open_ai_tools == None:
+            return None
+        return self._open_ai_tools.copy()
+    
+
+# 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
+        pass
+
+    async def to_plain_text(self, *, room: RoomClient, response: Response) -> str:
+        if isinstance(response, LinkResponse):                                            
+           return json.dumps({
+                "name" : response.name,
+                "url" : response.url,
+            })
+           
+        elif isinstance(response, JsonResponse):                                            
+            return json.dumps(response.json)
+        
+        elif isinstance(response, TextResponse):
+            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}."
+        
+        elif isinstance(response, EmptyResponse):
+            return "ok"
+        
+       #elif isinstance(response, ImageResponse):
+       #     context.messages.append({
+       #         "role" : "tool",
+       #         "content" : "the user will upload the image",
+       #         "tool_call_id" : tool_call.id,
+       #     })                                                
+       #     context.messages.append({
+       #         "role" : "user", 
+       #         "content" : [
+       #             { "type" : "text", "text": "this is the image from tool call id {tool_call.id}" },
+       #             { "type" : "image_url", "image_url": {"url": response.url, "detail": "auto"} } 
+       #         ]
+       #     })
+        
+
+        elif isinstance(response, dict):                        
+            return json.dumps(response)
+    
+        elif isinstance(response, str):                        
+            return response
+
+        elif response == None:
+            return "ok"
+        
+        else:
+            raise Exception("unexpected return type: {type}".format(type=type(response)))
+
+    async def append_messages(self, *, context: AgentChatContext, tool_call: Any, room: RoomClient, response: Response) -> list:
+
+        message = {
+            "role" : "tool",
+            "content" : await self.to_plain_text(room=room, response=response),
+            "tool_call_id" : tool_call.id,
+        }                                 
+      
+
+        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 })
+                            
+        context.messages.append(message) 
+        
+
+
+
+class OpenAICompletionsAdapter(LLMAdapter):
+    def __init__(self,      
+        model: str = os.getenv("OPENAI_MODEL"),
+        parallel_tool_calls : Optional[bool] = None,
+        client: Optional[AsyncOpenAI] = None,
+        reasoning_effort: Optional[str] = None,
+    ):
+        self._model = model
+        self._parallel_tool_calls = parallel_tool_calls
+        self._client = client
+        self._reasoning_effort = reasoning_effort
+
+
+    def create_chat_context(self):
+        system_role = "system"
+        if self._model.startswith("o1"):
+            system_role = "developer"
+        elif self._model.startswith("o3"):
+            system_role = "developer"
+
+        context = AgentChatContext(
+            system_role=system_role
+        )
+
+        return context
+    
+    # Takes the current chat context, executes a completion request and processes the response.
+    # If a tool calls are requested, invokes the tools, processes the tool calls results, and appends the tool call results to the context
+    async def next(self,
+        *,
+        context: AgentChatContext,
+        room: RoomClient,
+        toolkits: Toolkit,
+        tool_adapter: Optional[ToolResponseAdapter] = None,
+        output_schema: Optional[dict] = None,
+    ):
+        if tool_adapter == None:
+            tool_adapter = OpenAICompletionsToolResponseAdapter()
+
+        try:
+            if self._client != None:
+                openai = self._client
+            else:
+                
+               
+                token : str = room.protocol.token
+                url : str = room.room_url
+                
+                room_proxy_url = f"{url}/v1"
+            
+                openai=AsyncOpenAI(
+                    api_key=token,
+                    base_url=room_proxy_url,
+                    default_headers={
+                        "Meshagent-Session" : room.session_id
+                    }
+                )
+
+            tool_bundle = CompletionsToolBundle(toolkits=[
+                *toolkits,
+            ])
+            open_ai_tools = tool_bundle.to_json()
+
+            if open_ai_tools != None:
+                logger.info("OpenAI Tools: %s", json.dumps(open_ai_tools))
+            else:
+                logger.info("OpenAI Tools: Empty")
+            
+            response_schema = output_schema
+            response_name = "response"
+            
+        
+            while(True):
+                logger.info("model: %s, context: %s, output_schema: %s", self._model, context.messages, output_schema)
+                ptc = self._parallel_tool_calls
+                extra = {}
+                if ptc != None and self._model.startswith("o") == False:
+                    extra["parallel_tool_calls"] = ptc 
+
+                if output_schema != None:
+                    extra["response_format"] = {
+                        "type" : "json_schema",
+                        "json_schema": {
+                            "name" : response_name,
+                            "schema" :  response_schema,
+                            "strict" : True,
+                        }
+                    }
+
+                if self._reasoning_effort != None:
+                    extra["reasoning_effort"] = self._reasoning_effort
+
+                response : ChatCompletion = await openai.chat.completions.create(
+                    n=1,
+                    model = self._model,
+                    messages = context.messages,
+                    tools = open_ai_tools,                
+                    **extra
+                )
+                message = response.choices[0].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.to_dict() })
+                context.messages.append(message)
+            
+                if message.tool_calls != None:
+                
+                            
+                    tasks = []
+
+                    async def do_tool_call(tool_call: ChatCompletionMessageToolCall):
+                        try:
+                            tool_context = ToolContext(
+                                room=room,
+                                caller=room.local_participant,
+                            )
+                            tool_response = await tool_bundle.execute(context=tool_context, tool_call=tool_call)
+                            logger.info(f"tool response {tool_response}")
+                            await tool_adapter.append_messages(context=context, tool_call=tool_call, room=room, response=tool_response)
+                        except Exception as e:
+                            logger.error(f"unable to complete tool call {tool_call}", exc_info=e)
+                            room.developer.log_nowait(type="llm.error", data={ "participant_id" : room.local_participant.id, "participant_name" : room.local_participant.get_attribute("name"), "error" : f"{e}" })
+                
+                            return {
+                                "role" : "tool",
+                                "content" : json.dumps({"error":f"unable to complete tool call: {e}"}),
+                                "tool_call_id" : tool_call.id,
+                            }
+
+
+                    for tool_call in message.tool_calls:
+                        tasks.append(asyncio.create_task(do_tool_call(tool_call)))
+
+                    results = await asyncio.gather(*tasks)
+
+                    for result in results:
+                        if result != None:
+                            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" : result })
+                            context.messages.append(result)
+                       
+                      
+        
+                elif message.content != None:
+                    content = message.content
+                    
+                    logger.info("RESPONSE FROM OPENAI %s", content)
+                    if response_schema == None:
+                        return content
+                    
+                    # First try to parse the result
+                    try:
+                        full_response = json.loads(content)
+                    # sometimes open ai packs two JSON chunks seperated by newline, check if that's why we couldn't parse
+                    except json.decoder.JSONDecodeError as e:
+                        for part in content.splitlines():
+                            if len(part.strip()) > 0:
+                                full_response = json.loads(part)
+                                
+                                try:
+                                    self.validate(response=full_response, output_schema=response_schema)
+                                except Exception as e:
+                                    logger.error("recieved invalid response, retrying", exc_info=e)
+                                    error = { "role" : "user", "content" : "encountered a validation error with the output: {error}".format(error=e)}
+                                    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" : error })
+                                    context.messages.append(error)
+                                    continue
+                        
+                    return full_response
+                else:
+                    raise RoomException("Unexpected response from OpenAI {response}".format(response=message))
+        except APIStatusError as e:
+            raise RoomException(f"Error from OpenAI: {e}")
+            
+
+
+  

meshagent_openai-0.0.1/meshagent/openai/tools/responses_adapter.py

@@ -0,0 +1,388 @@
+
+from meshagent.agents.agent import Agent, AgentChatContext, AgentCallContext
+from meshagent.api import WebSocketClientProtocol, RoomClient, RoomException
+from meshagent.tools.blob import Blob, BlobStorage
+from meshagent.tools import Toolkit, ToolContext, Tool
+from meshagent.api.messaging import Response, LinkResponse, FileResponse, JsonResponse, TextResponse, EmptyResponse
+from meshagent.agents.schema import prompt_schema
+from meshagent.agents.adapter import ToolResponseAdapter, LLMAdapter
+from uuid import uuid4
+import json
+from jsonschema import validate
+from typing import List, Dict
+
+from openai import AsyncOpenAI, APIStatusError, NOT_GIVEN
+from openai.types.chat import ChatCompletionMessageToolCall
+from openai.types.responses import ResponseFunctionToolCall
+
+from copy import deepcopy
+from abc import abstractmethod, ABC
+import os
+import jsonschema
+from typing import Optional, Any
+
+import logging
+import re
+import asyncio
+
+logging.basicConfig()
+logger = logging.getLogger("openai_agent")
+logger.setLevel(logging.INFO)
+
+
+
+
+def _replace_non_matching(text: str, allowed_chars: str, replacement: str) -> str:
+    """
+    Replaces every character in `text` that does not match the given
+    `allowed_chars` regex set with `replacement`.
+    
+    Parameters:
+    -----------
+    text : str
+        The input string on which the replacement is to be done.
+    allowed_chars : str
+        A string defining the set of allowed characters (part of a character set).
+        For example, "a-zA-Z0-9" will keep only letters and digits.
+    replacement : str
+        The string to replace non-matching characters with.
+        
+    Returns:
+    --------
+    str
+        A new string where all characters not in `allowed_chars` are replaced.
+    """
+    # Build a regex that matches any character NOT in allowed_chars
+    pattern = rf"[^{allowed_chars}]"
+    return re.sub(pattern, replacement, text)
+
+def safe_tool_name(name: str):
+    return _replace_non_matching(name, "a-zA-Z0-9_-", "_")
+
+# Collects a group of tool proxies and manages execution of openai tool calls
+class ResponsesToolBundle:
+    def __init__(self, toolkits: List[Toolkit]):
+        self._toolkits = toolkits
+        self._executors = dict[str, Toolkit]()
+        self._safe_names = {}
+
+        open_ai_tools = []
+        
+        for toolkit in toolkits:                
+            for v in toolkit.tools:
+
+                k = v.name
+
+                name = safe_tool_name(k)
+
+                if k in self._executors:
+                    raise Exception(f"duplicate in bundle '{k}', tool names must be unique.")
+
+                self._executors[k] = toolkit
+
+                self._safe_names[name] = k
+
+                fn = {
+                    "type" : "function",
+                    "name" : name,
+                    "description" : v.description,
+                    "parameters" : {
+                        **v.input_schema,
+                    },
+                    "strict": True,
+                }
+
+
+                if v.defs != None:
+                    fn["parameters"]["$defs"] = v.defs
+          
+                open_ai_tools.append(fn)
+
+        if len(open_ai_tools) == 0:
+            open_ai_tools = None
+
+        self._open_ai_tools = open_ai_tools
+
+    async def execute(self, *, context: ToolContext, tool_call: ResponseFunctionToolCall) -> Response:
+        try:
+            
+            name = tool_call.name
+            arguments = json.loads(tool_call.arguments)
+
+            if name not in self._safe_names:
+                raise RoomException(f"Invalid tool name {name}, check the name of the tool")
+            
+            name = self._safe_names[name]
+
+            if name not in self._executors:
+                raise Exception(f"Unregistered tool name {name}")
+
+            logger.info("executing %s %s %s", tool_call.id, name, arguments)
+
+            proxy = self._executors[name]
+            result = await proxy.execute(context=context, name=name, arguments=arguments)
+            logger.info("success calling %s %s %s", tool_call.id, name, result)        
+            return result
+
+        except Exception as e:
+            logger.error("failed calling %s %s", tool_call.id, name, exc_info=e)
+            raise
+
+    def contains(self, name: str) -> bool:
+        return name in self._open_ai_tools
+
+    def to_json(self) -> List[dict] | None:
+        if self._open_ai_tools == None:
+            return None
+        return self._open_ai_tools.copy()
+    
+
+# 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
+        pass
+
+    async def to_plain_text(self, *, room: RoomClient, response: Response) -> str:
+        if isinstance(response, LinkResponse):                                            
+           return json.dumps({
+                "name" : response.name,
+                "url" : response.url,
+            })
+           
+        elif isinstance(response, JsonResponse):                                            
+            return json.dumps(response.json)
+        
+        elif isinstance(response, TextResponse):
+            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}."
+        
+        elif isinstance(response, EmptyResponse):
+            return "ok"
+        
+       #elif isinstance(response, ImageResponse):
+       #     context.messages.append({
+       #         "role" : "assistant",
+       #         "content" : "the user will upload the image",
+       #         "tool_call_id" : tool_call.id,
+       #     })                                                
+       #     context.messages.append({
+       #         "role" : "user", 
+       #         "content" : [
+       #             { "type" : "text", "text": "this is the image from tool call id {tool_call.id}" },
+       #             { "type" : "image_url", "image_url": {"url": response.url, "detail": "auto"} } 
+       #         ]
+       #     })
+        
+
+        elif isinstance(response, dict):                        
+            return json.dumps(response)
+    
+        elif isinstance(response, str):                        
+            return response
+
+        elif response == None:
+            return "ok"
+        
+        else:
+            raise Exception("unexpected return type: {type}".format(type=type(response)))
+
+    async def append_messages(self, *, context: AgentChatContext, tool_call: ResponseFunctionToolCall, room: RoomClient, response: Response) -> list:
+
+        message = {
+            "output" : await self.to_plain_text(room=room, response=response),
+            "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 })
+                            
+        context.messages.append(message) 
+        
+
+
+
+class OpenAIResponsesAdapter(LLMAdapter):
+    def __init__(self,      
+        model: str = os.getenv("OPENAI_MODEL"),
+        parallel_tool_calls : Optional[bool] = None,
+        client: Optional[AsyncOpenAI] = None,
+        reasoning_effort: Optional[str] = None,
+    ):
+        self._model = model
+        self._parallel_tool_calls = parallel_tool_calls
+        self._client = client
+        self._reasoning_effort = reasoning_effort
+
+
+    def create_chat_context(self):
+        system_role = "system"
+        if self._model.startswith("o1"):
+            system_role = "developer"
+        elif self._model.startswith("o3"):
+            system_role = "developer"
+
+        context = AgentChatContext(
+            system_role=system_role
+        )
+
+        return context
+    
+    # Takes the current chat context, executes a completion request and processes the response.
+    # If a tool calls are requested, invokes the tools, processes the tool calls results, and appends the tool call results to the context
+    async def next(self,
+        *,
+        context: AgentChatContext,
+        room: RoomClient,
+        toolkits: Toolkit,
+        tool_adapter: Optional[ToolResponseAdapter] = None,
+        output_schema: Optional[dict] = None,
+    ):  
+        if tool_adapter == None:
+            tool_adapter = OpenAIResponsesToolResponseAdapter()
+            
+        try:
+            if self._client != None:
+                openai = self._client
+            else:
+                
+               
+                token : str = room.protocol.token
+                url : str = room.room_url
+                
+                room_proxy_url = f"{url}/v1"
+            
+                openai=AsyncOpenAI(
+                    api_key=token,
+                    base_url=room_proxy_url,
+                    default_headers={
+                        "Meshagent-Session" : room.session_id
+                    }
+                )
+
+            tool_bundle = ResponsesToolBundle(toolkits=[
+                *toolkits,
+            ])
+            open_ai_tools = tool_bundle.to_json()
+
+            if open_ai_tools != None:
+                logger.info("OpenAI Tools: %s", json.dumps(open_ai_tools))
+            else:
+                logger.info("OpenAI Tools: Empty")
+            
+            response_schema = output_schema
+            response_name = "response"
+            
+        
+            while context.messages[-1].get("role") != "assistant" if context.messages else True:
+                logger.info("model: %s, context: %s, output_schema: %s", self._model, context.messages, output_schema)
+                ptc = self._parallel_tool_calls
+                extra = {}
+                if ptc != None and self._model.startswith("o") == False:
+                    extra["parallel_tool_calls"] = ptc 
+
+                text = NOT_GIVEN
+                if output_schema != None:
+                    text = {
+                        "format" : {
+                            "type" : "json_schema",
+                            "name" : response_name,
+                            "schema" :  response_schema,
+                            "strict" : True,
+                        }
+                    }
+
+                reasoning = NOT_GIVEN
+                if self._reasoning_effort != None:
+                    reasoning = {
+                        "effort" : self._reasoning_effort
+                    }
+
+                response = await openai.responses.create(
+                    model = self._model,
+                    input = context.messages,
+                    tools = open_ai_tools,
+                    text = text,
+                    reasoning=reasoning,
+                )
+                
+                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"), "response" : response.to_dict() })
+                
+                for message in response.output:
+                    context.messages.append(message)
+                
+                    if message.type == "function_call":
+                    
+                        tasks = []
+
+                        async def do_tool_call(tool_call: ResponseFunctionToolCall):
+                            try:
+                                tool_context = ToolContext(
+                                    room=room,
+                                    caller=room.local_participant,
+                                )
+                                tool_response = await tool_bundle.execute(context=tool_context, tool_call=tool_call)
+                                logger.info(f"tool response {tool_response}")
+                                await tool_adapter.append_messages(context=context, tool_call=tool_call, room=room, response=tool_response)
+                            except Exception as e:
+                                logger.error(f"unable to complete tool call {tool_call}", exc_info=e)
+                                room.developer.log_nowait(type="llm.error", data={ "participant_id" : room.local_participant.id, "participant_name" : room.local_participant.get_attribute("name"), "error" : f"{e}" })
+                    
+                                return {
+                                    "output" : json.dumps({"error":f"unable to complete tool call: {e}"}),
+                                    "call_id" : tool_call.call_id,
+                                    "type" : "function_call_output"
+                                }
+
+
+                        tasks.append(asyncio.create_task(do_tool_call(message)))
+
+                        results = await asyncio.gather(*tasks)
+
+                        for result in results:
+                            if result != None:
+                                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" : result })
+                                context.messages.append(result)
+                        
+                    elif response.output_text != None:
+
+                        content = response.output_text
+                        
+                        logger.info("RESPONSE FROM OPENAI %s", content)
+                        if response_schema == None:
+                            return content
+                        
+                        # First try to parse the result
+                        try:
+                            full_response = json.loads(content)
+                        # sometimes open ai packs two JSON chunks seperated by newline, check if that's why we couldn't parse
+                        except json.decoder.JSONDecodeError as e:
+                            for part in content.splitlines():
+                                if len(part.strip()) > 0:
+                                    full_response = json.loads(part)
+                                    
+                                    try:
+                                        self.validate(response=full_response, output_schema=response_schema)
+                                    except Exception as e:
+                                        logger.error("recieved invalid response, retrying", exc_info=e)
+                                        error = { "role" : "user", "content" : "encountered a validation error with the output: {error}".format(error=e)}
+                                        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" : error })
+                                        context.messages.append(error)
+                                        continue
+                            
+                        return full_response
+                    else:
+                        raise RoomException("Unexpected response from OpenAI {response}".format(response=message))
+        except APIStatusError as e:
+            raise RoomException(f"Error from OpenAI: {e}")
+            
+
+
+  

meshagent_openai-0.0.1/meshagent_openai.egg-info/PKG-INFO

@@ -0,0 +1,25 @@
+Metadata-Version: 2.2
+Name: meshagent-openai
+Version: 0.0.1
+Summary: OpenAI Building Blocks for Meshagent
+Home-page: 
+License: Apache License 2.0
+Project-URL: Documentation, https://meshagent.com
+Project-URL: Website, https://meshagent.com
+Project-URL: Source, https://github.com/meshagent
+Requires-Python: >=3.9.0
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pyjwt>=2.0.0
+Requires-Dist: pytest>=8.3.4
+Requires-Dist: pytest-asyncio>=0.24.0
+Requires-Dist: openai>=1.66.2
+Requires-Dist: meshagent-api>=0.0.1
+Requires-Dist: meshagent-agents>=0.0.1
+Requires-Dist: meshagent-tools>=0.0.1
+Dynamic: description-content-type
+Dynamic: license
+Dynamic: project-url
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

meshagent_openai-0.0.1/meshagent_openai.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+setup.py
+version.py
+meshagent/openai/__init__.py
+meshagent/openai/tools/__init__.py
+meshagent/openai/tools/completions_adapter.py
+meshagent/openai/tools/responses_adapter.py
+meshagent_openai.egg-info/PKG-INFO
+meshagent_openai.egg-info/SOURCES.txt
+meshagent_openai.egg-info/dependency_links.txt
+meshagent_openai.egg-info/requires.txt
+meshagent_openai.egg-info/top_level.txt

meshagent_openai-0.0.1/meshagent_openai.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,7 @@
+pyjwt>=2.0.0
+pytest>=8.3.4
+pytest-asyncio>=0.24.0
+openai>=1.66.2
+meshagent-api>=0.0.1
+meshagent-agents>=0.0.1
+meshagent-tools>=0.0.1

meshagent_openai-0.0.1/meshagent_openai.egg-info/top_level.txt

@@ -0,0 +1 @@
+meshagent

meshagent_openai-0.0.1/pyproject.toml

@@ -0,0 +1,5 @@
+[build-system]
+requires = [
+    "setuptools>=42",
+]
+build-backend = "setuptools.build_meta"

meshagent_openai-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

meshagent_openai-0.0.1/setup.py

@@ -0,0 +1,44 @@
+import os
+import pathlib
+from typing import Any, Dict
+
+import setuptools  # type: ignore
+
+here = pathlib.Path(__file__).parent.resolve()
+about: Dict[Any, Any] = {}
+with open(os.path.join(here, "version.py"), "r") as f:
+    exec(f.read(), about)
+
+setuptools.setup(
+    name="meshagent-openai",
+    version=about["__version__"],
+    description="OpenAI Building Blocks for Meshagent",
+    long_description=(here / "README.md").read_text(encoding="utf-8"),
+    long_description_content_type="text/markdown",
+    url="",
+    classifiers=[       
+    ],
+    keywords=[],
+    license="Apache License 2.0",
+    packages=setuptools.find_namespace_packages(include=[
+        "meshagent.*",
+    ]),
+    python_requires=">=3.9.0",
+    install_requires=[
+        "pyjwt>=2.0.0",
+        "pytest>=8.3.4",
+        "pytest-asyncio>=0.24.0",
+        "openai>=1.66.2",
+        "meshagent-api>=0.0.1",
+        "meshagent-agents>=0.0.1",
+        "meshagent-tools>=0.0.1"
+    ],
+    package_data={        
+        "meshagent.openai": ["py.typed", "*.pyi", "**/*.pyi",  "**/*.js"],
+    },
+    project_urls={
+        "Documentation": "https://meshagent.com",
+        "Website": "https://meshagent.com",
+        "Source": "https://github.com/meshagent",
+    },
+)

meshagent_openai-0.0.1/version.py

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