meshagent-agents 0.5.18__py3-none-any.whl → 0.6.1__py3-none-any.whl

meshagent/agents/__init__.py

@@ -8,7 +8,6 @@ from .agent import (
 )
 from .development import connect_development_agent
 from .listener import Listener, ListenerContext
-from .hosting import RemoteTaskRunnerServer
 from .adapter import ToolResponseAdapter, LLMAdapter
 from .thread_schema import thread_schema
 from .version import __version__
@@ -24,7 +23,6 @@ __all__ = [
     connect_development_agent,
     Listener,
     ListenerContext,
-    RemoteTaskRunnerServer,
     ToolResponseAdapter,
     LLMAdapter,
     thread_schema,

meshagent/agents/adapter.py

@@ -1,11 +1,11 @@
 from abc import ABC, abstractmethod
 from .agent import AgentChatContext
 from jsonschema import validate
-from meshagent.tools.toolkit import Response, Toolkit
-from meshagent.api import RoomClient
+from meshagent.tools import Response, Toolkit, ToolkitBuilder, ToolkitConfig
+from meshagent.api import RoomClient, RoomException, RemoteParticipant
 from typing import Any, Optional, Callable, TypeVar, Generic
 
-T = TypeVar("T")
+TEvent = TypeVar("T")
 
 
 class ToolResponseAdapter(ABC):
@@ -28,7 +28,10 @@ class ToolResponseAdapter(ABC):
         pass
 
 
-class LLMAdapter(Generic[T]):
+class LLMAdapter(Generic[TEvent]):
+    @abstractmethod
+    def default_model(self) -> str: ...
+
     def create_chat_context(self) -> AgentChatContext:
         return AgentChatContext()
 
@@ -38,6 +41,18 @@ class LLMAdapter(Generic[T]):
     ):
         return True
 
+    def tool_providers(self, *, model: str) -> list[ToolkitBuilder]:
+        return []
+
+    def make_toolkit(self, *, model: str, config: ToolkitConfig) -> Toolkit:
+        for tool in self.tool_providers(model=model):
+            if tool.name == config.name:
+                return Toolkit(
+                    name=config.name, tools=[tool.make(model=model, config=config)]
+                )
+
+        raise RoomException(f"Unexpected tool: {config.name} for model {model}")
+
     @abstractmethod
     async def next(
         self,
@@ -47,7 +62,9 @@ class LLMAdapter(Generic[T]):
         toolkits: list[Toolkit],
         tool_adapter: Optional[ToolResponseAdapter] = None,
         output_schema: Optional[dict] = None,
-        event_handler: Optional[Callable[[T], None]] = None,
+        event_handler: Optional[Callable[[TEvent], None]] = None,
+        model: Optional[str] = None,
+        on_behalf_of: Optional[RemoteParticipant] = None,
     ) -> Any:
         pass
 

meshagent/agents/agent.py

@@ -12,16 +12,13 @@ from meshagent.api import (
     ToolkitDescription,
     Participant,
     RemoteParticipant,
-    meshagent_base_url,
     StorageEntry,
 )
 from meshagent.api.protocol import Protocol
-from meshagent.tools.toolkit import (
+from meshagent.tools import (
     Toolkit,
     Tool,
     ToolContext,
-    toolkit_factory,
-    register_toolkit_factory,
 )
 from meshagent.api.room_server_client import RoomClient
 from jsonschema import validate
@@ -194,12 +191,10 @@ class SingleRoomAgent(Agent):
 
         installed = False
 
+        builtin_agents_url = "http://localhost:8080"
+
         for requirement in self.requires:
             if isinstance(requirement, RequiredToolkit):
-                if toolkit_factory(requirement.name) is not None:
-                    # no need to install something we can create from a factory
-                    continue
-
                 if requirement.name == "ui":
                     # TODO: maybe requirements can be marked as non installable?
                     continue
@@ -207,12 +202,14 @@ class SingleRoomAgent(Agent):
                 if requirement.name not in toolkits_by_name:
                     installed = True
 
-                    logger.info(f"Installing required tool {requirement.name}")
+                    logger.info(f"calling required tool into room {requirement.name}")
 
-                    if requirement.name.startswith("https://"):
+                    if requirement.name.startswith(
+                        "https://"
+                    ) or requirement.name.startswith("http://"):
                         url = requirement.name
                     else:
-                        url = f"{meshagent_base_url()}/toolkits/{requirement.name}"
+                        url = f"{builtin_agents_url}/toolkits/{requirement.name}"
 
                     await self._room.agents.make_call(
                         url=url, name=requirement.name, arguments={}
@@ -224,10 +221,12 @@ class SingleRoomAgent(Agent):
 
                     logger.info(f"Installing required schema {requirement.name}")
 
-                    if requirement.name.startswith("https://"):
+                    if requirement.name.startswith(
+                        "https://"
+                    ) or requirement.name.startswith("http://"):
                         url = requirement.name
                     else:
-                        url = f"{meshagent_base_url()}/schemas/{requirement.name}"
+                        url = f"{builtin_agents_url}/schemas/{requirement.name}"
 
                     await self._room.agents.make_call(
                         url=url, name=requirement.name, arguments={}
@@ -239,7 +238,9 @@ class SingleRoomAgent(Agent):
         if installed:
             await asyncio.sleep(5)
 
-    async def get_required_toolkits(self, context: ToolContext) -> list[Toolkit]:
+    async def get_toolkits(
+        self, context: ToolContext, remote_toolkits: list[RequiredToolkit]
+    ):
         tool_target = context.caller
         if context.on_behalf_of is not None:
             tool_target = context.on_behalf_of
@@ -255,20 +256,18 @@ class SingleRoomAgent(Agent):
         for toolkit_description in visible_tools:
             toolkits_by_name[toolkit_description.name] = toolkit_description
 
-        for required_toolkit in self.requires:
+        for required_toolkit in remote_toolkits:
             if isinstance(required_toolkit, RequiredToolkit):
-                if toolkit_factory(required_toolkit.name) is not None:
-                    toolkit = await toolkit_factory(required_toolkit.name)(
-                        context, required_toolkit
-                    )
-                    toolkits.append(toolkit)
-                    continue
-
                 toolkit = toolkits_by_name.get(required_toolkit.name, None)
                 if toolkit is None:
-                    raise RoomException(
-                        f"unable to locate required toolkit {required_toolkit.name}"
-                    )
+                    if context.on_behalf_of is not None:
+                        raise RoomException(
+                            f"unable to get toolkit {required_toolkit.name} on behalf of {context.on_behalf_of}"
+                        )
+                    else:
+                        raise RoomException(
+                            f"unable to get toolkit {required_toolkit.name} for caller {context.caller.id}"
+                        )
 
                 room_tools = list[RoomTool]()
 
@@ -296,7 +295,7 @@ class SingleRoomAgent(Agent):
                         tool_description = tools_by_name.get(required_tool, None)
                         if tool_description is None:
                             raise RoomException(
-                                f"unable to locate required tool {required_tool}"
+                                f"unable to locate required tool {required_tool} in toolkit {required_toolkit.name}"
                             )
 
                         tool = RoomTool(
@@ -324,6 +323,9 @@ class SingleRoomAgent(Agent):
 
         return toolkits
 
+    async def get_required_toolkits(self, context: ToolContext) -> list[Toolkit]:
+        return await self.get_toolkits(context, self.requires)
+
 
 class TaskRunner(SingleRoomAgent):
     def __init__(
@@ -624,6 +626,3 @@ async def make_run_task_tool(context: ToolContext, toolkit: RequiredToolkit):
         )
 
     return Toolkit(name="agents", tools=tools)
-
-
-register_toolkit_factory("agents", make_run_task_tool)