meshagent-tools 0.9.3__py3-none-any.whl → 0.19.5__py3-none-any.whl

meshagent/tools/database.py

@@ -0,0 +1,361 @@
+from .config import ToolkitConfig
+from .tool import Tool
+from .toolkit import ToolContext, ToolkitBuilder
+from .hosting import RemoteToolkit, Toolkit
+from typing import Literal, Optional
+from meshagent.api.room_server_client import DataType, RoomClient
+
+
+class ListTablesTool(Tool):
+    def __init__(self):
+        input_schema = {
+            "type": "object",
+            "required": [],
+            "additionalProperties": False,
+            "properties": {},
+        }
+
+        super().__init__(
+            name="list_tables",
+            title="list tables",
+            description="list the tables in the room",
+            input_schema=input_schema,
+        )
+
+    async def execute(self, context: ToolContext):
+        return {"tables": await context.room.database.list_tables()}
+
+
+class InsertRowsTool(Tool):
+    def __init__(
+        self,
+        *,
+        table: str,
+        schema: dict[str, DataType],
+        namespace: Optional[list[str]] = None,
+    ):
+        self.table = table
+        self.namespace = namespace
+
+        input_schema = {
+            "type": "object",
+            "required": [],
+            "additionalProperties": False,
+            "properties": {},
+        }
+
+        for k, v in schema.items():
+            input_schema["required"].append(k)
+            input_schema["properties"][k] = v.to_json_schema()
+
+        super().__init__(
+            name=f"insert_{table}_rows",
+            title=f"insert {table} rows",
+            description=f"insert rows into the {table} table",
+            input_schema={
+                "type": "object",
+                "required": ["rows"],
+                "additionalProperties": False,
+                "properties": {"rows": {"type": "array", "items": input_schema}},
+            },
+        )
+
+    async def execute(self, context: ToolContext, *, rows):
+        await context.room.database.insert(
+            table=self.table, records=rows, namespace=self.namespace
+        )
+
+
+class DeleteRowsTool(Tool):
+    def __init__(
+        self,
+        *,
+        table: str,
+        schema: dict[str, DataType],
+        namespace: Optional[list[str]] = None,
+    ):
+        self.table = table
+        self.namespace = namespace
+
+        input_schema = {
+            "type": "object",
+            "required": [],
+            "additionalProperties": False,
+            "properties": {},
+        }
+
+        for k, v in schema.items():
+            input_schema["required"].append(k)
+            input_schema["properties"][k] = v.to_json_schema()
+
+        super().__init__(
+            name=f"delete_{table}_rows",
+            title=f"delete {table} rows",
+            description=f"search {table} table for rows with the specified values (specify null for a column to exclude it from the search) and then delete them",
+            input_schema=input_schema,
+        )
+
+    async def execute(self, context: ToolContext, **values):
+        search = {}
+
+        for k, v in values.items():
+            if v is not None:
+                search[k] = v
+
+        await context.room.database.delete(
+            table=self.table,
+            where=search if len(search) > 0 else None,
+            namespace=self.namespace,
+        )
+        return {"ok": True}
+
+
+class UpdateTool(Tool):
+    def __init__(
+        self,
+        *,
+        table: str,
+        schema: dict[str, DataType],
+        namespace: Optional[list[str]] = None,
+    ):
+        self.table = table
+        self.namespace = namespace
+
+        columns = ""
+
+        for k, v in schema.items():
+            columns += f"column {k} => {v.to_json()}"
+
+        values_schema = {
+            "type": "object",
+            "required": [],
+            "additionalProperties": False,
+            "properties": {},
+        }
+
+        for k, v in schema.items():
+            values_schema["required"].append(k)
+            values_schema["properties"][k] = v.to_json_schema()
+
+        input_schema = {
+            "type": "object",
+            "required": [
+                "where",
+                "values",
+            ],
+            "additionalProperties": False,
+            "properties": {
+                "where": {
+                    "type": "string",
+                    "description": f"a lance db compatible filter, columns are: {columns}",
+                },
+                "values": values_schema,
+            },
+        }
+
+        super().__init__(
+            name=f"update_{table}_rows",
+            title=f"update {table} rows",
+            description=f"update {table} table where rows match the specified filter (with a lancedb compatible filter)",
+            input_schema=input_schema,
+        )
+
+    async def execute(self, context: ToolContext, *, where: str, values: dict):
+        await context.room.database.update(
+            table=self.table, where=where, values=values, namespace=self.namespace
+        )
+
+        return {"ok": True}
+
+
+class SearchTool(Tool):
+    def __init__(
+        self,
+        *,
+        table: str,
+        schema: dict[str, DataType],
+        namespace: Optional[list[str]] = None,
+    ):
+        self.table = table
+        self.namespace = namespace
+
+        input_schema = {
+            "type": "object",
+            "required": [],
+            "additionalProperties": False,
+            "properties": {},
+        }
+
+        for k, v in schema.items():
+            input_schema["required"].append(k)
+            input_schema["properties"][k] = v.to_json_schema()
+
+        super().__init__(
+            name=f"search_{table}",
+            title=f"search {table}",
+            description=f"search {table} table for rows with the specified values (specify null for a column to exclude it from the search)",
+            input_schema=input_schema,
+        )
+
+    async def execute(self, context: ToolContext, **values):
+        search = {}
+
+        for k, v in values.items():
+            if v is not None:
+                search[k] = v
+
+        return {
+            "rows": await context.room.database.search(
+                table=self.table,
+                where=search if len(search) > 0 else None,
+                namespace=self.namespace,
+            )
+        }
+
+
+class AdvancedSearchTool(Tool):
+    def __init__(
+        self,
+        *,
+        table: str,
+        schema: dict[str, DataType],
+        namespace: Optional[list[str]] = None,
+    ):
+        self.table = table
+        self.namespace = namespace
+
+        columns = ""
+
+        for k, v in schema.items():
+            columns += f"column {k} => {v.to_json()}"
+
+        input_schema = {
+            "type": "object",
+            "required": ["where"],
+            "additionalProperties": False,
+            "properties": {
+                "where": {
+                    "type": "string",
+                    "description": f"a lance db compatible filter, columns are: {columns}",
+                }
+            },
+        }
+
+        super().__init__(
+            name=f"advanced_search_{table}",
+            title=f"advanced search {table}",
+            description=f"advanced search {table} table with a lancedb compatible filter",
+            input_schema=input_schema,
+        )
+
+    async def execute(self, context: ToolContext, *, where: str):
+        return {
+            "rows": await context.room.database.search(
+                table=self.table, where=where, namespace=self.namespace
+            )
+        }
+
+
+class AdvancedDeleteRowsTool(Tool):
+    def __init__(
+        self,
+        *,
+        table: str,
+        schema: dict[str, DataType],
+        namespace: Optional[list[str]] = None,
+    ):
+        self.table = table
+        self.namespace = namespace
+        columns = ""
+
+        for k, v in schema.items():
+            columns += f"column {k} => {v.to_json()}"
+
+        input_schema = {
+            "type": "object",
+            "required": ["where"],
+            "additionalProperties": False,
+            "properties": {
+                "where": {
+                    "type": "string",
+                    "description": f"a lance db compatible filter, columns are: {columns}",
+                }
+            },
+        }
+
+        super().__init__(
+            name=f"advanced_delete_{table}",
+            title=f"advanced delete {table}",
+            description=f"advanced search {table} table with a lancedb compatible filter and delete the matching rows",
+            input_schema=input_schema,
+        )
+
+    async def execute(self, context: ToolContext, *, where: str):
+        await context.room.database.delete(
+            table=self.table, where=where, namespace=self.namespace
+        )
+        return {"ok": True}
+
+
+class DatabaseToolkit(RemoteToolkit):
+    def __init__(
+        self,
+        *,
+        tables: dict[str, dict[str, DataType]],
+        read_only: bool = False,
+        namespace: Optional[list[str]] = None,
+    ):
+        tools = [
+            # ListTablesTool()
+        ]
+
+        for table, schema in tables.items():
+            if not read_only:
+                tools.append(
+                    InsertRowsTool(table=table, schema=schema, namespace=namespace)
+                )
+                tools.append(
+                    UpdateTool(table=table, schema=schema, namespace=namespace)
+                )
+                tools.append(
+                    DeleteRowsTool(table=table, schema=schema, namespace=namespace)
+                )
+                tools.append(
+                    AdvancedDeleteRowsTool(
+                        table=table, schema=schema, namespace=namespace
+                    )
+                )
+
+            tools.append(SearchTool(table=table, schema=schema, namespace=namespace))
+            tools.append(
+                AdvancedSearchTool(table=table, schema=schema, namespace=namespace)
+            )
+
+        super().__init__(
+            name="database",
+            title="database",
+            description="tools for interacting with meshagent databases",
+            tools=tools,
+        )
+
+
+class DatabaseToolkitConfig(ToolkitConfig):
+    name: Literal["database"] = "database"
+    tables: list[str]
+    namespace: Optional[list[str]] = None
+    read_only: bool
+
+
+class DatabaseToolkitBuilder(ToolkitBuilder):
+    def __init__(self):
+        super().__init__(name="database", type=DatabaseToolkitConfig)
+
+    async def make(
+        self, *, room: RoomClient, model: str, config: DatabaseToolkitConfig
+    ) -> Toolkit:
+        tables = {}
+        for t in config.tables:
+            tables[t] = await room.database.inspect(table=t, namespace=config.namespace)
+        return DatabaseToolkit(
+            tables=tables, read_only=config.read_only, namespace=config.namespace
+        )

meshagent/tools/storage.py

@@ -1,4 +1,5 @@
 from meshagent.api.messaging import JsonResponse, LinkResponse, FileResponse
+from meshagent.api import RoomClient
 from .config import ToolkitConfig
 from .tool import Tool
 from .toolkit import ToolContext, ToolkitBuilder
@@ -196,12 +197,14 @@ class StorageToolkit(RemoteToolkit):
 
 
 class StorageToolkitConfig(ToolkitConfig):
-    name: str = Literal["storage"]
+    name: Literal["storage"] = "storage"
 
 
 class StorageToolkitBuilder(ToolkitBuilder):
     def __init__(self):
         super().__init__(name="storage", type=StorageToolkitConfig)
 
-    def make(self, *, model: str, config: ToolkitConfig) -> Toolkit:
+    async def make(
+        self, *, room: RoomClient, model: str, config: ToolkitConfig
+    ) -> Toolkit:
         return StorageToolkit()

meshagent/tools/toolkit.py

@@ -1,5 +1,6 @@
 from meshagent.api.room_server_client import RoomException
 from meshagent.api.messaging import ensure_response
+from meshagent.api import RoomClient
 from jsonschema import validate
 import logging
 
@@ -23,7 +24,7 @@ class ToolkitConfig(ToolkitConfig):
 
 def make_basic_toolkit_config_cls(toolkit: "Toolkit"):
     class CustomToolkitConfig:
-        name: Literal[toolkit.name]
+        name: Literal[toolkit.name] = toolkit.name
 
     return CustomToolkitConfig
 
@@ -33,7 +34,9 @@ class ToolkitBuilder:
         self.name = name
         self.type = type
 
-    def make(self, *, model: str, config: ToolkitConfig) -> "Toolkit": ...
+    async def make(
+        self, *, room: RoomClient, model: str, config: ToolkitConfig
+    ) -> "Toolkit": ...
 
 
 class Toolkit(ToolkitBuilder):
@@ -94,12 +97,16 @@ class Toolkit(ToolkitBuilder):
             span.set_attribute("response_type", response.to_json()["type"])
             return response
 
-    def make(self, *, model: str, config: ToolkitConfig):
+    async def make(self, *, room: RoomClient, model: str, config: ToolkitConfig):
         return self
 
 
-def make_toolkits(
-    *, model: str, providers: list[ToolkitBuilder], tools: list[ToolkitConfig]
+async def make_toolkits(
+    *,
+    room: RoomClient,
+    model: str,
+    providers: list[ToolkitBuilder],
+    tools: list[ToolkitConfig],
 ) -> list[Toolkit]:
     result = []
     if tools is not None:
@@ -109,14 +116,18 @@ def make_toolkits(
                 for t in providers:
                     if t.name == config["name"]:
                         config = t.type.model_validate(config)
-                        result.append(t.make(model=model, config=config))
+                        result.append(
+                            await t.make(room=room, model=model, config=config)
+                        )
                         found = True
                         break
 
             else:
                 for t in providers:
                     if t.type is type(config):
-                        result.append(t.make(model=model, config=config))
+                        result.append(
+                            await t.make(room=room, model=model, config=config)
+                        )
                         found = True
                         break
 

meshagent/tools/version.py

@@ -1 +1 @@
-__version__ = "0.9.3"
+__version__ = "0.19.5"

{meshagent_tools-0.9.3.dist-info → meshagent_tools-0.19.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshagent-tools
-Version: 0.9.3
+Version: 0.19.5
 Summary: Tools for Meshagent
 License-Expression: Apache-2.0
 Project-URL: Documentation, https://docs.meshagent.com
@@ -12,7 +12,7 @@ License-File: LICENSE
 Requires-Dist: pyjwt~=2.10
 Requires-Dist: pytest~=8.4
 Requires-Dist: pytest-asyncio~=0.26
-Requires-Dist: meshagent-api~=0.9.3
+Requires-Dist: meshagent-api~=0.19.5
 Requires-Dist: aiohttp~=3.10
 Requires-Dist: opentelemetry-distro~=0.54b1
 Dynamic: license-file

{meshagent_tools-0.9.3.dist-info → meshagent_tools-0.19.5.dist-info}/RECORD

@@ -1,19 +1,20 @@
 meshagent/tools/__init__.py,sha256=1zgD5OvAJP10eERoE72VbDu9hFVfAqCWUXw3SiCYFTE,1285
 meshagent/tools/blob.py,sha256=aDW_z8R4HrmrYzAWoWm13Ypqcxcl4rL1Dc0ESnQETLM,1473
 meshagent/tools/config.py,sha256=zH2xGxg28K7Tg-aYor6LXdzf0LRxS9iE0679H1FuWhE,79
+meshagent/tools/database.py,sha256=UMH0_qNZsWqHvI7NFXwWJUADbiOM5AnMYyi0gJtwM7U,10631
 meshagent/tools/discovery.py,sha256=GZcC4XCgk0ftcYCBxuWlaIsLV5vU4-gXiu0HhlDUlwY,1861
 meshagent/tools/document_tools.py,sha256=LMULXOSBjsvhKjqzxUxe8586t0Vol0v1Btu5v6ofm7A,11755
 meshagent/tools/hosting.py,sha256=l1BCgnSrCJQsWU9Kycq3hEI4ZlYxffDfde6QeJUfko0,10678
 meshagent/tools/multi_tool.py,sha256=hmWZO18Y2tuFG_7rvUed9er29aXleAC-r3YpXBCZWUY,4040
 meshagent/tools/pydantic.py,sha256=n-MD0gC-oRtHSTUDD5IV2dP-xIk-zjcDgHfgjqMgiqM,1161
-meshagent/tools/storage.py,sha256=WoOZEo63gOQH5QnjD1tGiIvI5AWYNXuMeK96qhp_tOs,7131
+meshagent/tools/storage.py,sha256=Y79G__Mp4swJ3tnm-zXtD-SqDeKU9kqHEVoUQH_QedA,7212
 meshagent/tools/strict_schema.py,sha256=IytdAANa6lsfrsg5FsJuqYrxH9D_fayl-Lc9EwgLJSM,6277
 meshagent/tools/tool.py,sha256=9OAlbfaHqfgJnCDBSW-8PS0Z1K1KjWGD3JBUyiHOxAk,3131
-meshagent/tools/toolkit.py,sha256=5-s7kddpZHYYltYWYYvb8-v7WANA1M2DeCZ-Qh-ZLOs,3546
-meshagent/tools/version.py,sha256=xKd3pzbczuMsdB08eLAOqZDUd_q1IRxwZ_ccAFL4c4A,22
+meshagent/tools/toolkit.py,sha256=rCCkpQBoSkmmhjnRGA4jx0QP-ds6WTJ0PkQVnf1Ls7s,3843
+meshagent/tools/version.py,sha256=HAeF5puNS6GWsF0P-GNaplZ6BOBhTmjj6k6KsmvJoyE,23
 meshagent/tools/web_toolkit.py,sha256=IoOYjOBmcbQsqWT14xYg02jjWpWmGOkDSxt2U-LQoaA,1258
-meshagent_tools-0.9.3.dist-info/licenses/LICENSE,sha256=eTt0SPW-sVNdkZe9PS_S8WfCIyLjRXRl7sUBWdlteFg,10254
-meshagent_tools-0.9.3.dist-info/METADATA,sha256=Ureg01Gpg03Oh8OTKF60uq58MoD5U36lOfgtI8x69bw,2876
-meshagent_tools-0.9.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-meshagent_tools-0.9.3.dist-info/top_level.txt,sha256=GlcXnHtRP6m7zlG3Df04M35OsHtNXy_DY09oFwWrH74,10
-meshagent_tools-0.9.3.dist-info/RECORD,,
+meshagent_tools-0.19.5.dist-info/licenses/LICENSE,sha256=eTt0SPW-sVNdkZe9PS_S8WfCIyLjRXRl7sUBWdlteFg,10254
+meshagent_tools-0.19.5.dist-info/METADATA,sha256=MPXlgC_FoRzHShCUW_EuGEAaThrTQLcFZcHG_GRbJqU,2878
+meshagent_tools-0.19.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+meshagent_tools-0.19.5.dist-info/top_level.txt,sha256=GlcXnHtRP6m7zlG3Df04M35OsHtNXy_DY09oFwWrH74,10
+meshagent_tools-0.19.5.dist-info/RECORD,,