meshagent-cli 0.22.2__py3-none-any.whl

meshagent/cli/helpers.py

@@ -0,0 +1,185 @@
+from meshagent.cli import async_typer
+
+from meshagent.api import SchemaRegistry, SchemaRegistration
+
+
+import logging
+
+app = async_typer.AsyncTyper(help="Developer helper services")
+
+
+@app.async_command("service", help="Run local helper HTTP services")
+async def helpers_service():
+    """Run local helper services (agents, schemas, toolkits)."""
+    from meshagent.agents.llmrunner import LLMTaskRunner, DynamicLLMTaskRunner
+    from meshagent.openai.tools import OpenAIResponsesAdapter
+    from meshagent.tools.storage import StorageToolkit
+    from meshagent.tools.database import DatabaseToolkitBuilder
+    from meshagent.api.services import ServiceHost
+
+    from meshagent.agents.schemas.gallery import gallery_schema
+    from meshagent.agents.schemas.document import document_schema
+    from meshagent.agents.schemas.transcript import transcript_schema
+    from meshagent.agents.schemas.super_editor_document import (
+        super_editor_document_schema,
+    )
+    from meshagent.agents.schemas.presentation import presentation_schema
+    from meshagent.agents import thread_schema
+    from meshagent.agents.widget_schema import widget_schema
+
+    logging.getLogger("openai").setLevel(logging.ERROR)
+    logging.getLogger("httpx").setLevel(logging.ERROR)
+
+    service = ServiceHost(port=9000)
+
+    @service.path("/runner")
+    class Runner(LLMTaskRunner):
+        def __init__(self, **kwargs):
+            super().__init__(
+                title="Generic Task Runner",
+                description="an agent that will perform a task with the selected tools",
+                llm_adapter=OpenAIResponsesAdapter(model="gpt-5.2"),
+                supports_tools=True,
+                input_prompt=True,
+                output_schema={
+                    "type": "object",
+                    "required": ["result"],
+                    "additionalProperties": False,
+                    "properties": {"result": {"type": "string"}},
+                },
+                annotations={"meshagent.task-runner.attachment-format": "tar"},
+            )
+
+        def get_toolkit_builders(self):
+            from meshagent.tools.storage import StorageToolkitBuilder
+            from meshagent.openai.tools.responses_adapter import WebSearchToolkitBuilder
+
+            providers = [
+                WebSearchToolkitBuilder(),
+                StorageToolkitBuilder(),
+                DatabaseToolkitBuilder(),
+                *super().get_toolkit_builders(),
+            ]
+
+            return providers
+
+    @service.path("/planner")
+    class Planner(LLMTaskRunner):
+        def __init__(self, **kwargs):
+            super().__init__(
+                title="Generic Task Runner (Legacy)",
+                description="an agent that will perform a task with the selected tools",
+                llm_adapter=OpenAIResponsesAdapter(model="gpt-5.2"),
+                supports_tools=True,
+                input_prompt=True,
+                output_schema={
+                    "type": "object",
+                    "required": ["result"],
+                    "additionalProperties": False,
+                    "properties": {"result": {"type": "string"}},
+                },
+            )
+
+    @service.path("/schema_planner")
+    class DynamicPlanner(DynamicLLMTaskRunner):
+        def __init__(self, **kwargs):
+            super().__init__(
+                title="Schema Task Runner",
+                description="an agent that can produces output that matches a schema",
+                llm_adapter=OpenAIResponsesAdapter(model="gpt-5.2"),
+            )
+
+        def get_toolkit_builders(self):
+            from meshagent.tools.storage import StorageToolkitBuilder
+            from meshagent.openai.tools.responses_adapter import WebSearchToolkitBuilder
+
+            providers = [
+                WebSearchToolkitBuilder(),
+                StorageToolkitBuilder(),
+                *super().get_toolkit_builders(),
+            ]
+
+            return providers
+
+    @service.path("/schemas/document")
+    class DocumentSchemaRegistry(SchemaRegistry):
+        def __init__(self):
+            name = "document"
+            schema = document_schema
+            super().__init__(
+                name=f"meshagent.schema.{name}",
+                validate_webhook_secret=False,
+                schemas=[SchemaRegistration(name=name, schema=schema)],
+            )
+
+    @service.path("/schemas/superdoc")
+    class SuperdocDocumentSchemaRegistry(SchemaRegistry):
+        def __init__(self):
+            name = "superdoc"
+            schema = super_editor_document_schema
+            super().__init__(
+                name=f"meshagent.schema.{name}",
+                validate_webhook_secret=False,
+                schemas=[SchemaRegistration(name=name, schema=schema)],
+            )
+
+    @service.path("/schemas/gallery")
+    class GalleryDocumentSchemaRegistry(SchemaRegistry):
+        def __init__(self):
+            name = "gallery"
+            schema = gallery_schema
+            super().__init__(
+                name=f"meshagent.schema.{name}",
+                validate_webhook_secret=False,
+                schemas=[SchemaRegistration(name=name, schema=schema)],
+            )
+
+    @service.path("/schemas/thread")
+    class ThreadDocumentSchemaRegistry(SchemaRegistry):
+        def __init__(self):
+            name = "thread"
+            schema = thread_schema
+            super().__init__(
+                name=f"meshagent.schema.{name}",
+                validate_webhook_secret=False,
+                schemas=[SchemaRegistration(name=name, schema=schema)],
+            )
+
+    @service.path("/schemas/widget")
+    class WidgetDocumentSchemaRegistry(SchemaRegistry):
+        def __init__(self):
+            name = "widget"
+            schema = widget_schema
+            super().__init__(
+                name=f"meshagent.schema.{name}",
+                validate_webhook_secret=False,
+                schemas=[SchemaRegistration(name=name, schema=schema)],
+            )
+
+    @service.path("/schemas/presentation")
+    class PresentationDocumentSchemaRegistry(SchemaRegistry):
+        def __init__(presentation):
+            name = "presentation"
+            schema = presentation_schema
+            super().__init__(
+                name=f"meshagent.schema.{name}",
+                validate_webhook_secret=False,
+                schemas=[SchemaRegistration(name=name, schema=schema)],
+            )
+
+    @service.path("/schemas/transcript")
+    class TranscriptRegistry(SchemaRegistry):
+        def __init__(self):
+            name = "transcript"
+            schema = transcript_schema
+            super().__init__(
+                name=f"meshagent.schema.{name}",
+                validate_webhook_secret=False,
+                schemas=[SchemaRegistration(name=name, schema=schema)],
+            )
+
+    @service.path("/toolkits/storage")
+    class HostedStorageToolkit(StorageToolkit):
+        pass
+
+    await service.run()

meshagent/cli/host.py

@@ -0,0 +1,41 @@
+from meshagent.api.services import ServiceHost
+from meshagent.api.specs.service import ServiceSpec
+import asyncio
+from meshagent.agents import Agent
+
+
+options = {"deferred": False}
+services = {}
+
+
+agents: list[tuple[Agent, str]] = []
+
+
+def set_deferred(deferred: bool):
+    options["deferred"] = deferred
+
+
+def get_deferred() -> bool:
+    return options["deferred"]
+
+
+def get_service(port: int, host: str) -> ServiceHost:
+    if port not in services:
+        services[port] = ServiceHost(host=host, port=port)
+
+    return services[port]
+
+
+def service_specs() -> list[ServiceSpec]:
+    specs = []
+    for port, s in services.items():
+        specs.append(s.get_service_spec(image=""))
+    return specs
+
+
+async def run_services():
+    tasks = []
+    for port, s in services.items():
+        tasks.append(s.run())
+
+    await asyncio.gather(*tasks)