meshagent-agents 0.0.36__py3-none-any.whl → 0.0.38__py3-none-any.whl

meshagent/agents/prompt.py

@@ -1,4 +1,3 @@
-
 from .adapter import LLMAdapter, Toolkit, ToolResponseAdapter
 from meshagent.api.schema_util import prompt_schema
 from .agent import AgentCallContext
@@ -6,9 +5,11 @@ from typing import Optional
 from meshagent.agents import TaskRunner
 from meshagent.api import RequiredToolkit
 
+
 # An agent that takes a simple prompt and gets the result
 class PromptAgent(TaskRunner):
-    def __init__(self,
+    def __init__(
+        self,
         *,
         name: str,
         output_schema: dict,
@@ -20,19 +21,17 @@ class PromptAgent(TaskRunner):
         description: Optional[str] = None,
         requires: Optional[list[RequiredToolkit]] = None,
         supports_tools: Optional[bool] = None,
-        labels: Optional[list[str]] = None
+        labels: Optional[list[str]] = None,
     ):
         super().__init__(
             name=name,
             description=description,
             title=title,
-            input_schema=prompt_schema(
-                description=description
-            ),
+            input_schema=prompt_schema(description=description),
             output_schema=output_schema,
             requires=requires,
             supports_tools=supports_tools,
-            labels=labels
+            labels=labels,
         )
         self.rules = rules
         self.tools = tools
@@ -47,9 +46,12 @@ class PromptAgent(TaskRunner):
     async def ask(self, *, context: AgentCallContext, arguments: dict):
         context.chat.append_user_message(arguments["prompt"])
 
-        toolkits = [
-            *self.toolkits,
-            *context.toolkits
-        ]
+        toolkits = [*self.toolkits, *context.toolkits]
 
-        return await self.llm_adapter.next(context=context.chat, room=context.room, toolkits=toolkits, tool_adapter=self.tool_adapter, output_schema=self.output_schema)
+        return await self.llm_adapter.next(
+            context=context.chat,
+            room=context.room,
+            toolkits=toolkits,
+            tool_adapter=self.tool_adapter,
+            output_schema=self.output_schema,
+        )

meshagent/agents/pydantic.py

@@ -8,10 +8,10 @@ import logging
 from typing import Optional
 from meshagent.api import RoomClient
 
-from .agent import TaskRunner, RequiredToolkit, Requirement, RequiredSchema
+from .agent import TaskRunner, Requirement
 
-from .adapter import  ToolResponseAdapter
-from meshagent.tools.toolkit import Tool, Response, ToolContext
+from .adapter import ToolResponseAdapter
+from meshagent.tools.toolkit import Tool, ToolContext
 from meshagent.tools.pydantic import get_pydantic_ai_tool_definition
 
 from typing import Sequence
@@ -20,37 +20,48 @@ import pydantic_ai
 logger = logging.getLogger("pydantic_agent")
 
 
+def get_pydantic_ai_tool(
+    *, room: RoomClient, tool: Tool, response_adapter: ToolResponseAdapter
+) -> pydantic_ai.tools.Tool:
+    async def prepare(
+        ctx: pydantic_ai.RunContext, tool_def: pydantic_ai.tools.ToolDefinition
+    ):
+        return get_pydantic_ai_tool_definition(tool=tool)
 
-def get_pydantic_ai_tool(*, room: RoomClient, tool: Tool, response_adapter: ToolResponseAdapter) -> pydantic_ai.tools.Tool:
-     async def prepare(ctx: pydantic_ai.RunContext, tool_def: pydantic_ai.tools.ToolDefinition):
-         return get_pydantic_ai_tool_definition(tool=tool)
-     
-     async def execute(**kwargs):
-         response = await tool.execute(context=ToolContext(room=room, caller=room.local_participant), **kwargs)
-         return await response_adapter.to_plain_text(room=room, response=response)
+    async def execute(**kwargs):
+        response = await tool.execute(
+            context=ToolContext(room=room, caller=room.local_participant), **kwargs
+        )
+        return await response_adapter.to_plain_text(room=room, response=response)
 
-     return pydantic_ai.Tool(
+    return pydantic_ai.Tool(
         name=tool.name,
         takes_ctx=False,
         description=tool.description,
         prepare=prepare,
-        function=execute
+        function=execute,
     )
 
-def get_pydantic_ai_tools_from_context(*, context: AgentCallContext, response_adapter: ToolResponseAdapter) -> list[pydantic_ai.tools.Tool]:
 
+def get_pydantic_ai_tools_from_context(
+    *, context: AgentCallContext, response_adapter: ToolResponseAdapter
+) -> list[pydantic_ai.tools.Tool]:
     tools = list[pydantic_ai.tools.Tool]()
 
     for toolkit in context.toolkits:
-        
         for tool in toolkit.tools:
-
-            tools.append(get_pydantic_ai_tool(room=context.room, tool=tool, response_adapter=response_adapter))
+            tools.append(
+                get_pydantic_ai_tool(
+                    room=context.room, tool=tool, response_adapter=response_adapter
+                )
+            )
 
     return tools
 
-class PydanticAgent[TInput:BaseModel, TOutput:BaseModel](TaskRunner):
-    def __init__(self,
+
+class PydanticAgent[TInput: BaseModel, TOutput: BaseModel](TaskRunner):
+    def __init__(
+        self,
         *,
         name: str,
         input_model: TInput,
@@ -58,26 +69,26 @@ class PydanticAgent[TInput:BaseModel, TOutput:BaseModel](TaskRunner):
         title: Optional[str] = None,
         description: Optional[str] = None,
         requires: Optional[list[Requirement]] = None,
-        supports_tools : Optional[bool] = None,
+        supports_tools: Optional[bool] = None,
     ):
         self.input_model = input_model
         self.output_model = output_model
-        
+
         super().__init__(
-            name = name,
-            description = description,
-            title = title,
+            name=name,
+            description=description,
+            title=title,
             input_schema=input_model.model_json_schema(),
-            output_schema=output_model.model_json_schema(),   
+            output_schema=output_model.model_json_schema(),
             requires=requires,
-            supports_tools=supports_tools
+            supports_tools=supports_tools,
         )
-    
+
     async def ask(self, *, context: AgentCallContext, arguments: dict):
         try:
             input = self.input_model.model_validate(arguments)
             output = await self.ask_model(context=context, arguments=input)
-            return output.model_dump(mode='json')
+            return output.model_dump(mode="json")
         except Exception as e:
             logger.error("Unhandled exception in ask agent call", exc_info=e)
             raise
@@ -86,22 +97,23 @@ class PydanticAgent[TInput:BaseModel, TOutput:BaseModel](TaskRunner):
     async def ask_model(self, context: AgentCallContext, arguments: TInput) -> TOutput:
         pass
 
-class PydanticWriter[TInput:BaseModel, TOutput:BaseModel](Writer):
-    def __init__(self, 
+
+class PydanticWriter[TInput: BaseModel, TOutput: BaseModel](Writer):
+    def __init__(
+        self,
         name: str,
         input_model: TInput,
         output_model: TOutput,
         title: Optional[str] = None,
-        description: Optional[str] = None
+        description: Optional[str] = None,
     ):
-
         self.input_model = input_model
         self.output_model = output_model
 
-        super().__init__(           
+        super().__init__(
             name=name,
             description=description,
-            title=title, 
+            title=title,
             input_schema=input_model.model_json_schema(),
             output_schema=output_model.model_json_schema(),
         )
@@ -109,59 +121,84 @@ class PydanticWriter[TInput:BaseModel, TOutput:BaseModel](Writer):
     async def write(self, writer_context: WriterContext, arguments: dict):
         try:
             input = self.input_model.model_validate(arguments)
-            output = await self.write_model(writer_context=writer_context, arguments=input)
-            return output.model_dump(mode='json')
+            output = await self.write_model(
+                writer_context=writer_context, arguments=input
+            )
+            return output.model_dump(mode="json")
         except Exception as e:
             logger.error("Unhandled exception in write call", exc_info=e)
             raise
-    
+
     @abstractmethod
-    async def write_model(self, writer_context: WriterContext, arguments: TInput) -> TOutput:
+    async def write_model(
+        self, writer_context: WriterContext, arguments: TInput
+    ) -> TOutput:
         pass
 
 
-
-class PydanicAgentHost[TInput:BaseModel, TOutput:BaseModel](PydanticAgent[TInput, TOutput]):
-    
-    def __init__(self, *, 
-                model: pydantic_ai.models.KnownModelName, 
-                system_prompt: str | Sequence[str],
-                response_adapter: ToolResponseAdapter, 
-                tools: Optional[list[pydantic_ai.Tool]] = None,
-                name, input_model, output_model, title = None, description = None, requires = None, supports_tools = None):
+class PydanicAgentHost[TInput: BaseModel, TOutput: BaseModel](
+    PydanticAgent[TInput, TOutput]
+):
+    def __init__(
+        self,
+        *,
+        model: pydantic_ai.models.KnownModelName,
+        system_prompt: str | Sequence[str],
+        response_adapter: ToolResponseAdapter,
+        tools: Optional[list[pydantic_ai.Tool]] = None,
+        name,
+        input_model,
+        output_model,
+        title=None,
+        description=None,
+        requires=None,
+        supports_tools=None,
+    ):
         super().__init__(
-            name=name, input_model=input_model, output_model=output_model, title=title, description=description, requires=requires, supports_tools=supports_tools, 
-            
+            name=name,
+            input_model=input_model,
+            output_model=output_model,
+            title=title,
+            description=description,
+            requires=requires,
+            supports_tools=supports_tools,
         )
         self._model = model
         self._system_prompt = system_prompt
         self._response_adapter = response_adapter
-        if tools == None: 
+        if tools is None:
             tools = []
-            
+
         self._tools = tools
 
     def message_history(self, context: AgentCallContext) -> None | list:
         return None
-    
+
     def to_prompt(self, *, arguments: TInput) -> str:
         return str(arguments)
 
-    def create_agent(self, *, tools: list[pydantic_ai.Tool]) -> pydantic_ai.Agent[TInput,TOutput]:
-        return pydantic_ai.Agent( 
+    def create_agent(
+        self, *, tools: list[pydantic_ai.Tool]
+    ) -> pydantic_ai.Agent[TInput, TOutput]:
+        return pydantic_ai.Agent(
             model=self._model,
             system_prompt=self._system_prompt,
             deps_type=self.input_model,
             result_type=self.output_model,
-            tools=[
-                *self._tools,
-                *tools
-            ]
+            tools=[*self._tools, *tools],
         )
 
     @abstractmethod
     async def ask_model(self, context: AgentCallContext, arguments: TInput) -> TOutput:
-        
-        agent = self.create_agent(tools=get_pydantic_ai_tools_from_context(context=context, response_adapter=self._response_adapter))
-        result = await agent.run(self.to_prompt(arguments=arguments), message_history=self.message_history(context), result_type=self.output_model, deps=arguments)
-        return result.data
+        agent = self.create_agent(
+            tools=get_pydantic_ai_tools_from_context(
+                context=context, response_adapter=self._response_adapter
+            )
+        )
+        result = await agent.run(
+            self.to_prompt(arguments=arguments),
+            message_history=self.message_history(context),
+            result_type=self.output_model,
+            deps=arguments,
+        )
+        return result.data

meshagent/agents/schemas/__init__.py

@@ -0,0 +1,11 @@
+from document import document_schema
+from gallery import gallery_schema
+from presentation import presentation_schema
+from super_editor_document import super_editor_document_schema
+
+__all__ = [
+    document_schema,
+    gallery_schema,
+    presentation_schema,
+    super_editor_document_schema,
+]

meshagent/agents/schemas/document.py

@@ -1,38 +1,49 @@
-from meshagent.api.schema import MeshSchema, ElementType,  ChildProperty, ValueProperty
+from meshagent.api.schema import MeshSchema, ElementType, ChildProperty, ValueProperty
 
 document_schema = MeshSchema(
     root_tag_name="document",
-    elements=[      
+    elements=[
         ElementType(
-            tag_name="document", 
+            tag_name="document",
             description="a document",
             properties=[
-                ChildProperty(name="content", description="the content in the document", child_tag_names=[
-                    "heading", "body", "file"
-                ]),
-            ]
-        ),   
+                ChildProperty(
+                    name="content",
+                    description="the content in the document",
+                    child_tag_names=["heading", "body", "file"],
+                ),
+            ],
+        ),
         ElementType(
-            tag_name="heading", 
+            tag_name="heading",
             description="heading",
             properties=[
-                ValueProperty(name="text", description="the text of the heading", type="string"),
-            ]
-        ),          
+                ValueProperty(
+                    name="text", description="the text of the heading", type="string"
+                ),
+            ],
+        ),
         ElementType(
-            tag_name="body", 
+            tag_name="body",
             description="text",
-            properties=[                    
-                ValueProperty(name="text", description="body content in markdown format", type="string"),
-            ]
+            properties=[
+                ValueProperty(
+                    name="text",
+                    description="body content in markdown format",
+                    type="string",
+                ),
+            ],
         ),
         ElementType(
-            tag_name="file", 
+            tag_name="file",
             description="an image",
             properties=[
-                ValueProperty(name="name", description="reference a file that was output from one of the steps. use to display the content of a file or image.", type="string"),
-            ]
+                ValueProperty(
+                    name="name",
+                    description="reference a file that was output from one of the steps. use to display the content of a file or image.",
+                    type="string",
+                ),
+            ],
         ),
-    ]
+    ],
 )
-

meshagent/agents/schemas/gallery.py

@@ -1,25 +1,34 @@
-from meshagent.api.schema import MeshSchema, ElementType,  ChildProperty, ValueProperty
+from meshagent.api.schema import MeshSchema, ElementType, ChildProperty, ValueProperty
 
 gallery_schema = MeshSchema(
     root_tag_name="gallery",
-    elements=[      
+    elements=[
         ElementType(
-            tag_name="gallery", 
+            tag_name="gallery",
             description="a media gallery",
             properties=[
-                ChildProperty(name="content", description="the content in the gallery", child_tag_names=[
-                    "file"
-                ]),
-            ]
-        ),   
+                ChildProperty(
+                    name="content",
+                    description="the content in the gallery",
+                    child_tag_names=["file"],
+                ),
+            ],
+        ),
         ElementType(
-            tag_name="file", 
+            tag_name="file",
             description="an image",
             properties=[
-                ValueProperty(name="path", description="reference a file that was output from one of the steps. use to display the content of a file or image.", type="string"),
-                ValueProperty(name="description", description="a description of the image", type="string"),
-            ]
+                ValueProperty(
+                    name="path",
+                    description="reference a file that was output from one of the steps. use to display the content of a file or image.",
+                    type="string",
+                ),
+                ValueProperty(
+                    name="description",
+                    description="a description of the image",
+                    type="string",
+                ),
+            ],
         ),
-    ]
+    ],
 )
-

meshagent/agents/schemas/presentation.py

@@ -2,31 +2,47 @@ from meshagent.api.schema import MeshSchema, ElementType, ChildProperty, ValuePr
 
 presentation_schema = MeshSchema(
     root_tag_name="presentation",
-    elements=[  
+    elements=[
         ElementType(
-            tag_name="presentation", 
+            tag_name="presentation",
             description="a presentation",
             properties=[
-                ChildProperty(name="slides", description="the slides for the presentation", child_tag_names=["slide"]),
-                ]
+                ChildProperty(
+                    name="slides",
+                    description="the slides for the presentation",
+                    child_tag_names=["slide"],
+                ),
+            ],
         ),
         ElementType(
-            tag_name="slide", 
+            tag_name="slide",
             description="a slide",
             properties=[
-                ValueProperty(name="title", description="a title for the slide", type="string"),
-                ValueProperty(name="background", description="an file to use for an background of the slide, must be a filename output from a previous step", type="string"),
-                ChildProperty(name="lines", description="the slides for the presentation", child_tag_names=["line"]),
-                ]
+                ValueProperty(
+                    name="title", description="a title for the slide", type="string"
+                ),
+                ValueProperty(
+                    name="background",
+                    description="an file to use for an background of the slide, must be a filename output from a previous step",
+                    type="string",
+                ),
+                ChildProperty(
+                    name="lines",
+                    description="the slides for the presentation",
+                    child_tag_names=["line"],
+                ),
+            ],
         ),
-
-            ElementType(
-            tag_name="line", 
+        ElementType(
+            tag_name="line",
             description="a line of text",
             properties=[
-                ValueProperty(name="line", description="the text of a bullet point for the slide", type="string"),
-            ]
-            )
-            
-    ]
+                ValueProperty(
+                    name="line",
+                    description="the text of a bullet point for the slide",
+                    type="string",
+                ),
+            ],
+        ),
+    ],
 )