ailoy-py 0.0.1__cp311-cp311-manylinux_2_28_x86_64.whl → 0.0.2__cp311-cp311-manylinux_2_28_x86_64.whl

ailoy/__init__.py

@@ -1,3 +1,21 @@
+if __doc__ is None:
+    try:
+        import importlib.metadata
+
+        meta = importlib.metadata.metadata("ailoy-py")
+        __doc__ = meta.get("Description")
+    except importlib.metadata.PackageNotFoundError:
+        pass
+
+if __doc__ is None:
+    from pathlib import Path
+
+    readme = Path(__file__).parent.parent / "README.md"
+    if readme.exists():
+        __doc__ = readme.read_text()
+    else:  # fallback docstring
+        __doc__ = "# ailoy-py\n\nPython binding for Ailoy runtime APIs"
+
 from .agent import Agent  # noqa: F401
 from .runtime import AsyncRuntime, Runtime  # noqa: F401
 from .vector_store import VectorStore  # noqa: F401

ailoy/agent.py

@@ -1,8 +1,8 @@
 import json
-import subprocess
 import warnings
 from abc import ABC, abstractmethod
 from collections.abc import Awaitable, Callable, Generator
+from functools import partial
 from pathlib import Path
 from typing import (
     Any,
@@ -14,72 +14,75 @@ from typing import (
 from urllib.parse import urlencode, urlparse, urlunparse
 
 import jmespath
-import mcp
-import mcp.types as mcp_types
 from pydantic import BaseModel, ConfigDict, Field
 from rich.console import Console
 from rich.panel import Panel
 
 from ailoy.ailoy_py import generate_uuid
+from ailoy.mcp import MCPServer, MCPTool, StdioServerParameters
 from ailoy.runtime import Runtime
+from ailoy.tools import DocstringParsingException, TypeHintParsingException, get_json_schema
 
 __all__ = ["Agent"]
 
-## Types for OpenAI API-compatible data structures
+## Types for internal data structures
 
 
-class SystemMessage(BaseModel):
-    role: Literal["system"]
-    content: str
+class TextData(BaseModel):
+    type: Literal["text"]
+    text: str
 
 
-class UserMessage(BaseModel):
-    role: Literal["user"]
-    content: str
-
+class FunctionData(BaseModel):
+    class FunctionBody(BaseModel):
+        name: str
+        arguments: Any
 
-class AIOutputTextMessage(BaseModel):
-    role: Literal["assistant"]
-    content: str
-    reasoning: Optional[bool] = None
+    type: Literal["function"]
+    id: Optional[str] = None
+    function: FunctionBody
 
 
-class AIToolCallMessage(BaseModel):
-    role: Literal["assistant"]
-    content: None
-    tool_calls: list["ToolCall"]
+class SystemMessage(BaseModel):
+    role: Literal["system"]
+    content: list[TextData]
 
 
-class ToolCall(BaseModel):
-    id: str
-    type: Literal["function"] = "function"
-    function: "ToolCallFunction"
+class UserMessage(BaseModel):
+    role: Literal["user"]
+    content: list[TextData]
 
 
-class ToolCallFunction(BaseModel):
-    name: str
-    arguments: dict[str, Any]
+class AssistantMessage(BaseModel):
+    role: Literal["assistant"]
+    reasoning: Optional[list[TextData]] = None
+    content: Optional[list[TextData]] = None
+    tool_calls: Optional[list[FunctionData]] = None
 
 
-class ToolCallResultMessage(BaseModel):
+class ToolMessage(BaseModel):
     role: Literal["tool"]
     name: str
-    tool_call_id: str
-    content: str
+    content: list[TextData]
+    tool_call_id: Optional[str] = None
 
 
 Message = Union[
     SystemMessage,
     UserMessage,
-    AIOutputTextMessage,
-    AIToolCallMessage,
-    ToolCallResultMessage,
+    AssistantMessage,
+    ToolMessage,
 ]
 
 
-class MessageDelta(BaseModel):
-    finish_reason: Optional[Literal["stop", "tool_calls", "length", "error"]]
-    message: Message
+class MessageOutput(BaseModel):
+    class AssistantMessageDelta(BaseModel):
+        content: Optional[list[TextData]] = None
+        reasoning: Optional[list[TextData]] = None
+        tool_calls: Optional[list[FunctionData]] = None
+
+    message: AssistantMessageDelta
+    finish_reason: Optional[Literal["stop", "tool_calls", "invalid_tool_call", "length", "error"]] = None
 
 
 ## Types for LLM Model Definitions
@@ -141,71 +144,71 @@ class ComponentState(BaseModel):
 
 ## Types for agent's responses
 
-_console = Console(highlight=False)
+_console = Console(highlight=False, force_jupyter=False, force_terminal=True)
 
 
-class AgentResponseBase(BaseModel):
-    type: Literal["output_text", "tool_call", "tool_call_result", "reasoning", "error"]
-    end_of_turn: bool
-    role: Literal["assistant", "tool"]
-    content: Any
-
-    def print(self):
-        raise NotImplementedError
-
-
-class AgentResponseOutputText(AgentResponseBase):
+class AgentResponseOutputText(BaseModel):
     type: Literal["output_text", "reasoning"]
     role: Literal["assistant"]
+    is_type_switched: bool = False
     content: str
 
     def print(self):
+        if self.is_type_switched:
+            _console.print()  # add newline if type has been switched
         _console.print(self.content, end="", style=("yellow" if self.type == "reasoning" else None))
-        if self.end_of_turn:
-            _console.print()
 
 
-class AgentResponseToolCall(AgentResponseBase):
+class AgentResponseToolCall(BaseModel):
     type: Literal["tool_call"]
     role: Literal["assistant"]
-    content: ToolCall
+    is_type_switched: bool = False
+    content: FunctionData
 
     def print(self):
+        title = f"[magenta]Tool Call[/magenta]: [bold]{self.content.function.name}[/bold]"
+        if self.content.id is not None:
+            title += f" ({self.content.id})"
         panel = Panel(
             json.dumps(self.content.function.arguments, indent=2),
-            title=f"[magenta]Tool Call[/magenta]: [bold]{self.content.function.name}[/bold] ({self.content.id})",
+            title=title,
             title_align="left",
         )
         _console.print(panel)
 
 
-class AgentResponseToolCallResult(AgentResponseBase):
+class AgentResponseToolResult(BaseModel):
     type: Literal["tool_call_result"]
     role: Literal["tool"]
-    content: ToolCallResultMessage
+    is_type_switched: bool = False
+    content: ToolMessage
 
     def print(self):
         try:
             # Try to parse as json
-            content = json.dumps(json.loads(self.content.content), indent=2)
+            content = json.dumps(json.loads(self.content.content[0].text), indent=2)
         except json.JSONDecodeError:
             # Use original content if not json deserializable
-            content = self.content.content
+            content = self.content.content[0].text
         # Truncate long contents
         if len(content) > 500:
             content = content[:500] + "...(truncated)"
 
+        title = f"[green]Tool Result[/green]: [bold]{self.content.name}[/bold]"
+        if self.content.tool_call_id is not None:
+            title += f" ({self.content.tool_call_id})"
         panel = Panel(
             content,
-            title=f"[green]Tool Result[/green]: [bold]{self.content.name}[/bold] ({self.content.tool_call_id})",
+            title=title,
             title_align="left",
         )
         _console.print(panel)
 
 
-class AgentResponseError(AgentResponseBase):
+class AgentResponseError(BaseModel):
     type: Literal["error"]
     role: Literal["assistant"]
+    is_type_switched: bool = False
     content: str
 
     def print(self):
@@ -219,7 +222,7 @@ class AgentResponseError(AgentResponseBase):
 AgentResponse = Union[
     AgentResponseOutputText,
     AgentResponseToolCall,
-    AgentResponseToolCallResult,
+    AgentResponseToolResult,
     AgentResponseError,
 ]
 
@@ -337,7 +340,7 @@ class Agent:
         model_name: ModelName,
         system_message: Optional[str] = None,
         api_key: Optional[str] = None,
-        attrs: dict[str, Any] = dict(),
+        **attrs,
     ):
         """
         Create an instance.
@@ -359,14 +362,18 @@ class Agent:
 
         # Initialize messages
         self._messages: list[Message] = []
-        if system_message:
-            self._messages.append(SystemMessage(role="system", content=system_message))
+
+        # Initialize system message
+        self._system_message = system_message
 
         # Initialize tools
         self._tools: list[Tool] = []
 
+        # Initialize MCP servers
+        self._mcp_servers: list[MCPServer] = []
+
         # Define the component
-        self.define(model_name, api_key=api_key, attrs=attrs)
+        self.define(model_name, api_key=api_key, **attrs)
 
     def __del__(self):
         self.delete()
@@ -377,7 +384,7 @@ class Agent:
     def __exit__(self, type, value, traceback):
         self.delete()
 
-    def define(self, model_name: ModelName, api_key: Optional[str] = None, attrs: dict[str, Any] = dict()) -> None:
+    def define(self, model_name: ModelName, api_key: Optional[str] = None, **attrs) -> None:
         """
         Initializes the agent by defining its model in the runtime.
         This must be called before running the agent. If already initialized, this is a no-op.
@@ -388,6 +395,9 @@ class Agent:
         if self._component_state.valid:
             return
 
+        if not self._runtime.is_alive():
+            raise ValueError("Runtime is currently stopped.")
+
         if model_name not in model_descriptions:
             raise ValueError(f"Model `{model_name}` not supported")
 
@@ -397,9 +407,11 @@ class Agent:
         if "model" not in attrs:
             attrs["model"] = model_desc.model_id
 
-        # Set default system message
-        if len(self._messages) == 0 and model_desc.default_system_message:
-            self._messages.append(SystemMessage(role="system", content=model_desc.default_system_message))
+        # Set default system message if not given; still can be None
+        if self._system_message is None:
+            self._system_message = model_desc.default_system_message
+
+        self.clear_messages()
 
         # Add API key
         if api_key:
@@ -422,106 +434,164 @@ class Agent:
         """
         if not self._component_state.valid:
             return
-        self._runtime.delete(self._component_state.name)
-        if len(self._messages) > 0 and self._messages[0].role == "system":
-            self._messages = [self._messages[0]]
-        else:
-            self._messages = []
+
+        if self._runtime.is_alive():
+            self._runtime.delete(self._component_state.name)
+
+        self.clear_messages()
+
+        for mcp_server in self._mcp_servers:
+            mcp_server.cleanup()
+
         self._component_state.valid = False
 
     def query(
         self,
         message: str,
-        enable_reasoning: bool = False,
-        ignore_reasoning_messages: bool = False,
+        reasoning: bool = False,
     ) -> Generator[AgentResponse, None, None]:
         """
         Runs the agent with a new user message and yields streamed responses.
 
         :param message: The user message to send to the model.
-        :param enable_reasoning: If True, enables reasoning capabilities. (default: False)
-        :param ignore_reasoning_messages: If True, reasoning steps are not included in the response stream. (default: False)
-        :yield: AgentResponse output of the LLM inference or tool calls
+        :param reasoning: If True, enables reasoning capabilities. (Default: False)
+        :return: An iterator over the output, where each item represents either a generated token from the assistant or a tool call.
+        :rtype: Iterator[:class:`AgentResponse`]
         """  # noqa: E501
-        self._messages.append(UserMessage(role="user", content=message))
+        if not self._component_state.valid:
+            raise ValueError("Agent is not valid. Create one or define newly.")
+
+        if not self._runtime.is_alive():
+            raise ValueError("Runtime is currently stopped.")
+
+        self._messages.append(UserMessage(role="user", content=[{"type": "text", "text": message}]))
+
+        prev_resp_type = None
 
         while True:
             infer_args = {
-                "messages": [msg.model_dump() for msg in self._messages],
-                "tools": [{"type": "function", "function": t.desc.model_dump()} for t in self._tools],
+                "messages": [msg.model_dump(exclude_none=True) for msg in self._messages],
+                "tools": [{"type": "function", "function": t.desc.model_dump(exclude_none=True)} for t in self._tools],
             }
-            if enable_reasoning:
-                infer_args["enable_reasoning"] = enable_reasoning
-            if ignore_reasoning_messages:
-                infer_args["ignore_reasoning_messages"] = ignore_reasoning_messages
-
-            for resp in self._runtime.call_iter_method(self._component_state.name, "infer", infer_args):
-                delta = MessageDelta.model_validate(resp)
-
-                if delta.finish_reason is None:
-                    output_msg = AIOutputTextMessage.model_validate(delta.message)
-                    yield AgentResponseOutputText(
-                        type="reasoning" if output_msg.reasoning else "output_text",
-                        end_of_turn=False,
-                        role="assistant",
-                        content=output_msg.content,
-                    )
-                    continue
-
-                if delta.finish_reason == "tool_calls":
-                    tool_call_message = AIToolCallMessage.model_validate(delta.message)
-                    self._messages.append(tool_call_message)
-
-                    for tool_call in tool_call_message.tool_calls:
-                        yield AgentResponseToolCall(
-                            type="tool_call",
-                            end_of_turn=True,
+            if reasoning:
+                infer_args["reasoning"] = reasoning
+
+            assistant_reasoning = None
+            assistant_content = None
+            assistant_tool_calls = None
+            finish_reason = ""
+            for result in self._runtime.call_iter_method(self._component_state.name, "infer", infer_args):
+                msg = MessageOutput.model_validate(result)
+
+                if msg.message.reasoning:
+                    for v in msg.message.reasoning:
+                        if not assistant_reasoning:
+                            assistant_reasoning = [v]
+                        else:
+                            assistant_reasoning[0].text += v.text
+                        resp = AgentResponseOutputText(
+                            type="reasoning",
                             role="assistant",
-                            content=tool_call,
+                            is_type_switched=(prev_resp_type != "reasoning"),
+                            content=v.text,
                         )
-
-                    tool_call_results: list[ToolCallResultMessage] = []
-
-                    def run_tool(tool_call: ToolCall):
-                        tool_ = next(
-                            (t for t in self._tools if t.desc.name == tool_call.function.name),
-                            None,
+                        prev_resp_type = resp.type
+                        yield resp
+                if msg.message.content:
+                    for v in msg.message.content:
+                        if not assistant_content:
+                            assistant_content = [v]
+                        else:
+                            assistant_content[0].text += v.text
+                        resp = AgentResponseOutputText(
+                            type="output_text",
+                            role="assistant",
+                            is_type_switched=(prev_resp_type != "output_text"),
+                            content=v.text,
                         )
-                        if not tool_:
-                            raise RuntimeError("Tool not found")
-                        resp = tool_.call(**tool_call.function.arguments)
-                        return ToolCallResultMessage(
-                            role="tool",
-                            name=tool_call.function.name,
-                            tool_call_id=tool_call.id,
-                            content=json.dumps(resp),
+                        prev_resp_type = resp.type
+                        yield resp
+                if msg.message.tool_calls:
+                    for v in msg.message.tool_calls:
+                        if not assistant_tool_calls:
+                            assistant_tool_calls = [v]
+                        else:
+                            assistant_tool_calls.append(v)
+                        resp = AgentResponseToolCall(
+                            type="tool_call",
+                            role="assistant",
+                            is_type_switched=True,
+                            content=v,
                         )
+                        prev_resp_type = resp.type
+                        yield resp
+                if msg.finish_reason:
+                    finish_reason = msg.finish_reason
+                    break
+
+            # Append output
+            self._messages.append(
+                AssistantMessage(
+                    role="assistant",
+                    reasoning=assistant_reasoning,
+                    content=assistant_content,
+                    tool_calls=assistant_tool_calls,
+                )
+            )
+
+            if finish_reason == "tool_calls":
+
+                def run_tool(tool_call: FunctionData) -> ToolMessage:
+                    tool_ = next(
+                        (t for t in self._tools if t.desc.name == tool_call.function.name),
+                        None,
+                    )
+                    if not tool_:
+                        raise RuntimeError("Tool not found")
+                    tool_result = tool_.call(**tool_call.function.arguments)
+                    return ToolMessage(
+                        role="tool",
+                        name=tool_call.function.name,
+                        content=[TextData(type="text", text=json.dumps(tool_result))],
+                        tool_call_id=tool_call.id if tool_call.id else None,
+                    )
 
-                    tool_call_results = [run_tool(tc) for tc in tool_call_message.tool_calls]
+                tool_call_results = [run_tool(tc) for tc in assistant_tool_calls]
+                for result_msg in tool_call_results:
+                    self._messages.append(result_msg)
+                    resp = AgentResponseToolResult(
+                        type="tool_call_result",
+                        role="tool",
+                        is_type_switched=True,
+                        content=result_msg,
+                    )
+                    prev_resp_type = resp.type
+                    yield resp
+                # Infer again if tool calls happened
+                continue
 
-                    for result_msg in tool_call_results:
-                        self._messages.append(result_msg)
-                        yield AgentResponseToolCallResult(
-                            type="tool_call_result",
-                            end_of_turn=True,
-                            role="tool",
-                            content=result_msg,
-                        )
+            # Finish this generator
+            break
 
-                    # Run infer again with new messages
-                    break
+    def get_messages(self) -> list[Message]:
+        """
+        Get the current conversation history.
+        Each item in the list represents a message from either the user or the assistant.
 
-                if delta.finish_reason in ["stop", "length", "error"]:
-                    output_msg = AIOutputTextMessage.model_validate(delta.message)
-                    yield AgentResponseOutputText(
-                        type="reasoning" if output_msg.reasoning else "output_text",
-                        end_of_turn=True,
-                        role="assistant",
-                        content=output_msg.content,
-                    )
+        :return: The conversation history so far in the form of a list.
+        :rtype: list[Message]
+        """
+        return self._messages
 
-                    # finish this Generator
-                    return
+    def clear_messages(self):
+        """
+        Clear the history of conversation messages.
+        """
+        self._messages.clear()
+        if self._system_message is not None:
+            self._messages.append(
+                SystemMessage(role="system", content=[TextData(type="text", text=self._system_message)])
+            )
 
     def print(self, resp: AgentResponse):
         resp.print()
@@ -537,14 +607,29 @@ class Agent:
             return
         self._tools.append(tool)
 
-    def add_py_function_tool(self, desc: dict, f: Callable[..., Any]):
+    def add_py_function_tool(self, f: Callable[..., Any], desc: Optional[dict] = None):
         """
         Adds a Python function as a tool using callable.
 
-        :param desc: Tool descriotion.
         :param f: Function will be called when the tool invocation occured.
+        :param desc: Tool description to override. If not given, parsed from docstring of function `f`.
+
+        :raises ValueError: Docstring parsing is failed.
+        :raises ValidationError: Given or parsed description is not a valid `ToolDescription`.
         """
-        self.add_tool(Tool(desc=ToolDescription.model_validate(desc), call_fn=f))
+        tool_description = None
+        if desc is not None:
+            tool_description = ToolDescription.model_validate(desc)
+
+        if tool_description is None:
+            try:
+                json_schema = get_json_schema(f)
+            except (TypeHintParsingException, DocstringParsingException) as e:
+                raise ValueError("Failed to parse docstring", e)
+
+            tool_description = ToolDescription.model_validate(json_schema.get("function", {}))
+
+        self.add_tool(Tool(desc=tool_description, call_fn=f))
 
     def add_builtin_tool(self, tool_def: BuiltinToolDefinition) -> bool:
         """
@@ -669,61 +754,53 @@ class Agent:
             else:
                 warnings.warn(f'Tool type "{tool_type}" is not supported. Skip adding tool "{tool_name}".')
 
-    def add_mcp_tool(self, params: mcp.StdioServerParameters, tool: mcp_types.Tool):
+    def add_tools_from_mcp_server(
+        self, name: str, params: StdioServerParameters, tools_to_add: Optional[list[str]] = None
+    ):
         """
-        Adds a tool from an MCP (Model Context Protocol) server.
+        Create a MCP server and register its tools to agent.
 
+        :param name: The unique name of the MCP server.
+                     If there's already a MCP server with the same name, it raises RuntimeError.
         :param params: Parameters for connecting to the MCP stdio server.
-        :param tool: Tool metadata as defined by MCP.
-        :returns: True if the tool was successfully added.
+        :param tools_to_add: Optional list of tool names to add. If None, all tools are added.
         """
-        from mcp.client.stdio import stdio_client
+        if any([s.name == name for s in self._mcp_servers]):
+            raise RuntimeError(f"MCP server with name '{name}' is already registered")
 
-        def call(**inputs: dict[str, Any]) -> Any:
-            async def _inner():
-                async with stdio_client(params, errlog=subprocess.STDOUT) as streams:
-                    async with mcp.ClientSession(*streams) as session:
-                        await session.initialize()
-
-                        result = await session.call_tool(tool.name, inputs)
-                        contents: list[str] = []
-                        for item in result.content:
-                            if isinstance(item, mcp_types.TextContent):
-                                contents.append(item.text)
-                            elif isinstance(item, mcp_types.ImageContent):
-                                contents.append(item.data)
-                            elif isinstance(item, mcp_types.EmbeddedResource):
-                                if isinstance(item.resource, mcp_types.TextResourceContents):
-                                    contents.append(item.resource.text)
-                                else:
-                                    contents.append(item.resource.blob)
-
-                        return contents
-
-            return run_async(_inner())
-
-        desc = ToolDescription(name=tool.name, description=tool.description, parameters=tool.inputSchema)
-        return self.add_tool(Tool(desc=desc, call_fn=call))
-
-    def add_tools_from_mcp_server(self, params: mcp.StdioServerParameters, tools_to_add: Optional[list[str]] = None):
+        # Create and register MCP server
+        mcp_server = MCPServer(name, params)
+        self._mcp_servers.append(mcp_server)
+
+        # Register tools
+        for tool in mcp_server.list_tools():
+            # Skip if this tool is not in the whitelist
+            if tools_to_add is not None and tool.name not in tools_to_add:
+                continue
+
+            desc = ToolDescription(
+                name=f"{name}/{tool.name}", description=tool.description, parameters=tool.inputSchema
+            )
+
+            def call(tool: MCPTool, **inputs: dict[str, Any]) -> list[str]:
+                return mcp_server.call_tool(tool, inputs)
+
+            self.add_tool(Tool(desc=desc, call_fn=partial(call, tool)))
+
+    def remove_mcp_server(self, name: str):
         """
-        Fetches tools from an MCP stdio server and registers them with the agent.
+        Removes the MCP server and its tools from the agent, with terminating the MCP server process.
 
-        :param params: Parameters for connecting to the MCP stdio server.
-        :param tools_to_add: Optional list of tool names to add. If None, all tools are added.
-        :returns: list of all tools returned by the server.
+        :param name: The unique name of the MCP server.
+                     If there's no MCP server matches the name, it raises RuntimeError.
         """
-        from mcp.client.stdio import stdio_client
-
-        async def _inner():
-            async with stdio_client(params, errlog=subprocess.STDOUT) as streams:
-                async with mcp.ClientSession(*streams) as session:
-                    await session.initialize()
-                    resp = await session.list_tools()
-                    for tool in resp.tools:
-                        if tools_to_add is None or tool.name in tools_to_add:
-                            self.add_mcp_tool(params, tool)
-                    return resp.tools
-
-        tools = run_async(_inner())
-        return tools
+        if all([s.name != name for s in self._mcp_servers]):
+            raise RuntimeError(f"MCP server with name '{name}' does not exist")
+
+        # Remove the MCP server
+        mcp_server = next(filter(lambda s: s.name == name, self._mcp_servers))
+        self._mcp_servers.remove(mcp_server)
+        mcp_server.cleanup()
+
+        # Remove tools registered from the MCP server
+        self._tools = list(filter(lambda t: not t.desc.name.startswith(f"{mcp_server.name}/"), self._tools))

ailoy/mcp.py

@@ -0,0 +1,159 @@
+import asyncio
+import json
+import multiprocessing
+import platform
+import subprocess
+from multiprocessing.connection import Connection
+from typing import Annotated, Any, Literal, Union
+
+import mcp.types as mcp_types
+from mcp import Tool as MCPTool
+from mcp.client.session import ClientSession
+from mcp.client.stdio import (
+    StdioServerParameters,
+    stdio_client,
+)
+from pydantic import BaseModel, Field, TypeAdapter
+
+__all__ = ["MCPServer"]
+
+
+class ListToolsRequest(BaseModel):
+    type: Literal["list_tools"] = "list_tools"
+
+
+class CallToolRequest(BaseModel):
+    type: Literal["call_tool"] = "call_tool"
+    tool: MCPTool
+    arguments: dict[str, Any]
+
+
+class ShutdownRequest(BaseModel):
+    type: Literal["shutdown"] = "shutdown"
+
+
+# Requests (main -> subprocess)
+RequestMessage = Annotated[Union[ListToolsRequest, CallToolRequest, ShutdownRequest], Field(discriminator="type")]
+
+
+class ResultMessage(BaseModel):
+    type: Literal["result"] = "result"
+    result: Any
+
+
+class ErrorMessage(BaseModel):
+    type: Literal["error"] = "error"
+    error: str
+
+
+# Response (subprocess -> main)
+ResponseMessage = Annotated[Union[ResultMessage, ErrorMessage], Field(discriminator="type")]
+
+
+class MCPServer:
+    """
+    MCPServer manages a subprocess that acts as a bridge between an MCP stdio server and the main process.
+
+    - The subprocess communicates with the MCP stdio server using the official MCP Python SDK.
+    - Communication between the main process and the subprocess is handled through a multiprocessing Pipe.
+      Messages sent over this Pipe are serialized and deserialized using structured Pydantic models:
+        - `RequestMessage` for requests from the main process to the subprocess.
+        - `ResponseMessage` for responses from the subprocess to the main process.
+
+    This design ensures:
+    - Type-safe, structured inter-process communication.
+    - Synchronous interaction with an asynchronous MCP session (via message passing).
+    - Subprocess lifecycle control (including initialization and shutdown).
+    """
+
+    def __init__(self, name: str, params: StdioServerParameters):
+        self.name = name
+        self.params = params
+
+        self._parent_conn, self._child_conn = multiprocessing.Pipe()
+
+        ctx = multiprocessing.get_context("fork" if platform.system() != "Windows" else "spawn")
+        self._proc = ctx.Process(target=self._run_process, args=(self._child_conn,))
+        self._proc.start()
+
+        # Wait for subprocess to signal initialization complete
+        self._recv_response()
+
+    def __del__(self):
+        self.cleanup()
+
+    def _run_process(self, conn: Connection):
+        asyncio.run(self._process_main(conn))
+
+    async def _process_main(self, conn: Connection):
+        async with stdio_client(self.params, errlog=subprocess.PIPE) as (read, write):
+            async with ClientSession(read, write) as session:
+                # Notify to main process that the initialization has been finished and ready to receive requests
+                try:
+                    await session.initialize()
+                    conn.send(ResultMessage(result=True).model_dump())
+                except Exception as e:
+                    conn.send(ErrorMessage(error=f"Failed to initialize MCP subprocess: {e}").model_dump())
+
+                while True:
+                    if not conn.poll(0.1):
+                        await asyncio.sleep(0.1)
+                        continue
+
+                    try:
+                        raw = conn.recv()
+                        req = TypeAdapter(RequestMessage).validate_python(raw)
+
+                        if isinstance(req, ListToolsRequest):
+                            result = await session.list_tools()
+                            conn.send(ResultMessage(result=result.tools).model_dump())
+
+                        elif isinstance(req, CallToolRequest):
+                            result = await session.call_tool(req.tool.name, req.arguments)
+                            contents: list[str] = []
+                            for item in result.content:
+                                if isinstance(item, mcp_types.TextContent):
+                                    try:
+                                        content = json.loads(item.text)
+                                        contents.append(json.dumps(content))
+                                    except json.JSONDecodeError:
+                                        contents.append(item.text)
+                                elif isinstance(item, mcp_types.ImageContent):
+                                    contents.append(item.data)
+                                elif isinstance(item, mcp_types.EmbeddedResource):
+                                    if isinstance(item.resource, mcp_types.TextResourceContents):
+                                        contents.append(item.resource.text)
+                                    else:
+                                        contents.append(item.resource.blob)
+                            conn.send(ResultMessage(result=contents).model_dump())
+
+                        elif isinstance(req, ShutdownRequest):
+                            break
+
+                    except Exception as e:
+                        conn.send(ErrorMessage(error=str(e)).model_dump())
+
+    def _send_request(self, msg: RequestMessage):
+        self._parent_conn.send(msg.model_dump())
+
+    def _recv_response(self) -> ResultMessage:
+        raw = self._parent_conn.recv()
+        msg = TypeAdapter(ResponseMessage).validate_python(raw)
+        if isinstance(msg, ErrorMessage):
+            raise RuntimeError(msg.error)
+        return msg
+
+    def list_tools(self) -> list[MCPTool]:
+        self._send_request(ListToolsRequest())
+        msg = self._recv_response()
+        return [MCPTool.model_validate(tool) for tool in msg.result]
+
+    def call_tool(self, tool: MCPTool, arguments: dict[str, Any]) -> list[str]:
+        self._send_request(CallToolRequest(tool=tool, arguments=arguments))
+        msg = self._recv_response()
+        return msg.result
+
+    def cleanup(self) -> None:
+        if self._proc.is_alive():
+            self._send_request(ShutdownRequest())
+            self._proc.join()

ailoy/runtime.py

@@ -1,3 +1,4 @@
+import time
 from asyncio import Event, to_thread
 from collections import defaultdict
 from typing import Any, AsyncGenerator, Generator, Literal, Optional, TypedDict
@@ -15,21 +16,25 @@ class Packet(TypedDict):
 
 
 class RuntimeBase:
-    def __init__(self, address: str = "inproc://"):
-        self.address: str = address
+    __client_count: dict[str, int] = {}
+
+    def __init__(self, url: str = "inproc://"):
+        self.url: str = url
         self._responses: dict[str, Packet] = {}
         self._exec_responses: defaultdict[str, dict[int, Packet]] = defaultdict(dict)
         self._listen_lock: Optional[Event] = None
 
-        start_threads(self.address)
-        self._client: BrokerClient = BrokerClient(address)
+        if RuntimeBase.__client_count.get(self.url, 0) == 0:
+            start_threads(self.url)
+            RuntimeBase.__client_count[self.url] = 0
+
+        self._client: BrokerClient = BrokerClient(self.url)
         txid = self._send_type1("connect")
-        if not txid:
-            raise RuntimeError("Connection failed")
         self._sync_listen()
         if not self._responses[txid]["body"]["status"]:
             raise RuntimeError("Connection failed")
         del self._responses[txid]
+        RuntimeBase.__client_count[self.url] += 1
 
     def __del__(self):
         self.stop()
@@ -41,22 +46,32 @@ class RuntimeBase:
         self.stop()
 
     def stop(self):
-        if self._client:
+        if self.is_alive():
             txid = self._send_type1("disconnect")
-            if not txid:
-                raise RuntimeError("Disconnection failed")
             while txid not in self._responses:
                 self._sync_listen()
             if not self._responses[txid]["body"]["status"]:
                 raise RuntimeError("Disconnection failed")
             self._client = None
-            stop_threads(self.address)
+            RuntimeBase.__client_count[self.url] -= 1
+        if RuntimeBase.__client_count.get(self.url, 0) <= 0:
+            stop_threads(self.url)
+            RuntimeBase.__client_count.pop(self.url, 0)
 
-    def _send_type1(self, ptype: Literal["connect", "disconnect"]) -> Optional[str]:
+    def is_alive(self):
+        return self._client is not None
+
+    def _send_type1(self, ptype: Literal["connect", "disconnect"]) -> str:
         txid = generate_uuid()
-        if self._client.send_type1(txid, ptype):
-            return txid
-        raise RuntimeError("Failed to send packet")
+        retry_count = 0
+        # Since the broker thread might start slightly later than the runtime client,
+        # we retry sending the packat a few times to ensure delivery.
+        while retry_count < 3:
+            if self._client.send_type1(txid, ptype):
+                return txid
+            time.sleep(0.001)
+            retry_count += 1
+        raise RuntimeError(f'Failed to send packet "{ptype}"')
 
     def _send_type2(
         self,
@@ -76,7 +91,7 @@ class RuntimeBase:
         *args,
     ):
         txid = generate_uuid()
-        if self._client.send_type2(txid, ptype, status, *args):
+        if self._client.send_type3(txid, ptype, status, *args):
             return txid
         raise RuntimeError("Failed to send packet")
 
@@ -112,8 +127,8 @@ class RuntimeBase:
 
 
 class Runtime(RuntimeBase):
-    def __init__(self, address: str = "inproc://"):
-        super().__init__(address)
+    def __init__(self, url: str = "inproc://"):
+        super().__init__(url)
 
     def call(self, func_name: str, input: Any) -> Any:
         rv = [v for v in self.call_iter(func_name, input)]
@@ -193,8 +208,8 @@ class Runtime(RuntimeBase):
 
 
 class AsyncRuntime(RuntimeBase):
-    def __init__(self, address: str = "inproc://"):
-        super().__init__(address)
+    def __init__(self, url: str = "inproc://"):
+        super().__init__(url)
 
     async def call(self, func_name: str, input: Any) -> Any:
         rv = [v async for v in self.call_iter(func_name, input)]

ailoy/tools.py

@@ -0,0 +1,205 @@
+import inspect
+import json
+import re
+import types
+from typing import (
+    Any,
+    Callable,
+    Optional,
+    Union,
+    get_args,
+    get_origin,
+    get_type_hints,
+)
+
+description_re = re.compile(r"^(.*?)[\n\s]*(Args:|Returns:|Raises:|\Z)", re.DOTALL)
+# Extracts the Args: block from the docstring
+args_re = re.compile(r"\n\s*Args:\n\s*(.*?)[\n\s]*(Returns:|Raises:|\Z)", re.DOTALL)
+# Splits the Args: block into individual arguments
+args_split_re = re.compile(
+    r"""
+(?:^|\n)  # Match the start of the args block, or a newline
+\s*(\w+):\s*  # Capture the argument name and strip spacing
+(.*?)\s*  # Capture the argument description, which can span multiple lines, and strip trailing spacing
+(?=\n\s*\w+:|\Z)  # Stop when you hit the next argument or the end of the block
+""",
+    re.DOTALL | re.VERBOSE,
+)
+# Extracts the Returns: block from the docstring, if present. Note that most chat templates ignore the return type/doc!
+returns_re = re.compile(r"\n\s*Returns:\n\s*(.*?)[\n\s]*(Raises:|\Z)", re.DOTALL)
+
+
+class TypeHintParsingException(Exception):
+    """Exception raised for errors in parsing type hints to generate JSON schemas"""
+
+    pass
+
+
+class DocstringParsingException(Exception):
+    """Exception raised for errors in parsing docstrings to generate JSON schemas"""
+
+    pass
+
+
+def _get_json_schema_type(param_type: str) -> dict[str, str]:
+    type_mapping = {
+        int: {"type": "integer"},
+        float: {"type": "number"},
+        str: {"type": "string"},
+        bool: {"type": "boolean"},
+        type(None): {"type": "null"},
+        Any: {},
+    }
+    # if is_vision_available():
+    #     type_mapping[Image] = {"type": "image"}
+    # if is_torch_available():
+    #     type_mapping[Tensor] = {"type": "audio"}
+    return type_mapping.get(param_type, {"type": "object"})
+
+
+def _parse_type_hint(hint: str) -> dict:
+    origin = get_origin(hint)
+    args = get_args(hint)
+
+    if origin is None:
+        try:
+            return _get_json_schema_type(hint)
+        except KeyError:
+            raise TypeHintParsingException(
+                "Couldn't parse this type hint, likely due to a custom class or object: ", hint
+            )
+
+    elif origin is Union or (hasattr(types, "UnionType") and origin is types.UnionType):
+        # Recurse into each of the subtypes in the Union, except None, which is handled separately at the end
+        subtypes = [_parse_type_hint(t) for t in args if t is not type(None)]
+        if len(subtypes) == 1:
+            # A single non-null type can be expressed directly
+            return_dict = subtypes[0]
+        elif all(isinstance(subtype["type"], str) for subtype in subtypes):
+            # A union of basic types can be expressed as a list in the schema
+            return_dict = {"type": sorted([subtype["type"] for subtype in subtypes])}
+        else:
+            # A union of more complex types requires "anyOf"
+            return_dict = {"anyOf": subtypes}
+        if type(None) in args:
+            return_dict["nullable"] = True
+        return return_dict
+
+    elif origin is list:
+        if not args:
+            return {"type": "array"}
+        else:
+            # Lists can only have a single type argument, so recurse into it
+            return {"type": "array", "items": _parse_type_hint(args[0])}
+
+    elif origin is tuple:
+        if not args:
+            return {"type": "array"}
+        if len(args) == 1:
+            raise TypeHintParsingException(
+                f"The type hint {str(hint).replace('typing.', '')} is a Tuple with a single element, which "
+                "we do not automatically convert to JSON schema as it is rarely necessary. If this input can contain "
+                "more than one element, we recommend "
+                "using a List[] type instead, or if it really is a single element, remove the Tuple[] wrapper and just "
+                "pass the element directly."
+            )
+        if ... in args:
+            raise TypeHintParsingException(
+                "Conversion of '...' is not supported in Tuple type hints. "
+                "Use List[] types for variable-length"
+                " inputs instead."
+            )
+        return {"type": "array", "prefixItems": [_parse_type_hint(t) for t in args]}
+
+    elif origin is dict:
+        # The JSON equivalent to a dict is 'object', which mandates that all keys are strings
+        # However, we can specify the type of the dict values with "additionalProperties"
+        out = {"type": "object"}
+        if len(args) == 2:
+            out["additionalProperties"] = _parse_type_hint(args[1])
+        return out
+
+    raise TypeHintParsingException("Couldn't parse this type hint, likely due to a custom class or object: ", hint)
+
+
+def _convert_type_hints_to_json_schema(func: Callable) -> dict:
+    type_hints = get_type_hints(func)
+    signature = inspect.signature(func)
+    required = []
+    for param_name, param in signature.parameters.items():
+        if param.annotation == inspect.Parameter.empty:
+            raise TypeHintParsingException(f"Argument {param.name} is missing a type hint in function {func.__name__}")
+        if param.default == inspect.Parameter.empty:
+            required.append(param_name)
+
+    properties = {}
+    for param_name, param_type in type_hints.items():
+        properties[param_name] = _parse_type_hint(param_type)
+
+    schema = {"type": "object", "properties": properties}
+    if required:
+        schema["required"] = required
+
+    return schema
+
+
+def parse_google_format_docstring(docstring: str) -> tuple[Optional[str], Optional[dict], Optional[str]]:
+    """
+    Parses a Google-style docstring to extract the function description,
+    argument descriptions, and return description.
+
+    Args:
+        docstring (str): The docstring to parse.
+
+    Returns:
+        The function description, arguments, and return description.
+    """
+
+    # Extract the sections
+    description_match = description_re.search(docstring)
+    args_match = args_re.search(docstring)
+    returns_match = returns_re.search(docstring)
+
+    # Clean and store the sections
+    description = description_match.group(1).strip() if description_match else None
+    docstring_args = args_match.group(1).strip() if args_match else None
+    returns = returns_match.group(1).strip() if returns_match else None
+
+    # Parsing the arguments into a dictionary
+    if docstring_args is not None:
+        docstring_args = "\n".join([line for line in docstring_args.split("\n") if line.strip()])  # Remove blank lines
+        matches = args_split_re.findall(docstring_args)
+        args_dict = {match[0]: re.sub(r"\s*\n+\s*", " ", match[1].strip()) for match in matches}
+    else:
+        args_dict = {}
+
+    return description, args_dict, returns
+
+
+def get_json_schema(func: Callable) -> dict:
+    doc = inspect.getdoc(func)
+    if not doc:
+        raise DocstringParsingException(f"Cannot generate JSON schema for {func.__name__} because it has no docstring!")
+    doc = doc.strip()
+    main_doc, param_descriptions, return_doc = parse_google_format_docstring(doc)
+
+    json_schema = _convert_type_hints_to_json_schema(func)
+    if (return_dict := json_schema["properties"].pop("return", None)) is not None:
+        if return_doc is not None:  # We allow a missing return docstring since most templates ignore it
+            return_dict["description"] = return_doc
+    for arg, schema in json_schema["properties"].items():
+        if arg not in param_descriptions:
+            raise DocstringParsingException(
+                f"Cannot generate JSON schema for {func.__name__} because the docstring has no description for the argument '{arg}'"
+            )
+        desc = param_descriptions[arg]
+        enum_choices = re.search(r"\(choices:\s*(.*?)\)\s*$", desc, flags=re.IGNORECASE)
+        if enum_choices:
+            schema["enum"] = [c.strip() for c in json.loads(enum_choices.group(1))]
+            desc = enum_choices.string[: enum_choices.start()].strip()
+        schema["description"] = desc
+
+    output = {"name": func.__name__, "description": main_doc, "parameters": json_schema}
+    if return_dict is not None:
+        output["return"] = return_dict
+    return {"type": "function", "function": output}

ailoy/vector_store.py

@@ -46,8 +46,8 @@ class VectorStore:
         vector_store_name: Literal["faiss", "chromadb"],
         url: Optional[str] = None,
         collection: Optional[str] = None,
-        embedding_model_attrs: dict[str, Any] = dict(),
-        vector_store_attrs: dict[str, Any] = dict(),
+        embedding_model_attrs: Optional[dict[str, Any]] = None,
+        vector_store_attrs: Optional[dict[str, Any]] = None,
     ):
         """
         Creates an instance.
@@ -69,10 +69,10 @@ class VectorStore:
         self.define(
             embedding_model_name,
             vector_store_name,
-            url,
-            collection,
-            embedding_model_attrs,
-            vector_store_attrs,
+            url=url,
+            collection=collection,
+            embedding_model_attrs=embedding_model_attrs,
+            vector_store_attrs=vector_store_attrs,
         )
 
     def __del__(self):
@@ -90,8 +90,8 @@ class VectorStore:
         vector_store_name: Literal["faiss", "chromadb"],
         url: Optional[str] = None,
         collection: Optional[str] = None,
-        embedding_model_attrs: dict[str, Any] = dict(),
-        vector_store_attrs: dict[str, Any] = dict(),
+        embedding_model_attrs: Optional[dict[str, Any]] = None,
+        vector_store_attrs: Optional[dict[str, Any]] = None,
     ):
         """
         Defines the embedding model and vector store components to the runtime.
@@ -111,13 +111,14 @@ class VectorStore:
                 self._component_state.embedding_model_name,
                 {
                     "model": "BAAI/bge-m3",
-                    **embedding_model_attrs,
+                    **(embedding_model_attrs or {}),
                 },
             )
         else:
             raise NotImplementedError(f"Unsupprted embedding model: {embedding_model_name}")
 
         # Initialize vector store
+        vector_store_attrs = vector_store_attrs or {}
         if vector_store_name == "faiss":
             if "dimension" not in vector_store_attrs:
                 vector_store_attrs["dimension"] = dimension

{ailoy_py-0.0.1.dist-info → ailoy_py-0.0.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ailoy-py
-Version: 0.0.1
+Version: 0.0.2
 Summary: Python binding for Ailoy runtime APIs
 Author-Email: "Brekkylab Inc." <contact@brekkylab.com>
 License-Expression: Apache-2.0
@@ -65,7 +65,7 @@ rt.stop()
   - LLVM Clang >= 17
   - Apple Clang >= 15
   - MSVC >= 19.29
-- CMake >= 3.24.0
+- CMake >= 3.28.0
 - Git
 - OpenSSL
 - Rust & Cargo >= 1.82.0

ailoy_py-0.0.2.dist-info/RECORD

@@ -0,0 +1,20 @@
+ailoy/__init__.py,sha256=mzkLUc95OCc2okURWm9iA5xR8WZdxwvPgaanc9fwoH4,647
+ailoy/agent.py,sha256=uQ1o4CjQEO1vP7y0frGtVknN-A_iLNtkqt8h3vobgiM,27613
+ailoy/ailoy_py.cpython-311-x86_64-linux-gnu.so,sha256=HewPp-NrYxV9_Un38rrHZ8cn_63MKRn2OaWUJ1X0g9I,21245329
+ailoy/ailoy_py.pyi,sha256=Yf90FEXkslpCpr1r2eqQ3-_1jLo65zmG94bBXDRqinU,991
+ailoy/mcp.py,sha256=bC58tAWqhvMdZVCKHSdOVNUoAuYfZiou1hSH1oa_9Ag,6190
+ailoy/runtime.py,sha256=-75KawEMQSwxGvX5wtECVCWiTNdcHojsQ1e-OVB4IQ8,10545
+ailoy/tools.py,sha256=RnTfmWlqYY1q0V377CpAAyAK-yET7k45GgEhgM9G8eI,8207
+ailoy/vector_store.py,sha256=ZfIuGYKv2dQmjOuDlSKDc-BBPlQ8no_70mZwnPzbBzo,7515
+ailoy/cli/__main__.py,sha256=HnBVb2em1F2NLPeNX5r3xRndRrnGaXVCduo8WBULAI0,179
+ailoy/cli/model.py,sha256=cerCHE-VY9TOwqRcLBtmqnV-5vphpvyhtrfPFZiTKCM,2979
+ailoy/presets/tools/calculator.json,sha256=ePnZsjZChnvS08s9eVdIp4Bys_PlJBXPHCCjv6oMvzA,1040
+ailoy/presets/tools/frankfurter.json,sha256=bZ5vhszf_aR-B_QN4L2xrI5nR-f4AMZk41UUDq1dTXg,1152
+ailoy/presets/tools/nytimes.json,sha256=wrfe9bnAlSPzHladoGEX2oCAeE0wed3BvgXQ_Z2PdXg,918
+ailoy/presets/tools/tmdb.json,sha256=UGLN5uAJ2b-Hu3nLcW95WXDLB3mfC3rBYfQANp_e8Ps,7046
+ailoy_py.libs/libgomp-870cb1d0.so.1.0.0,sha256=Ta6ZPLbakQH8LP74JzBt0DuJIBHS4nicjkSCjKnyWDw,253289
+ailoy_py.libs/libtvm_runtime-2d14ca42.so,sha256=qPtn3HaKtxt-sL0wdu6Wqz7QsTmKY2ZWOPwO92TPfzU,5061889
+ailoy_py-0.0.2.dist-info/METADATA,sha256=B5RbxeITquJfdiw9bhA6w02q9OvLkuFH7jMRg6Lxc2A,2010
+ailoy_py-0.0.2.dist-info/WHEEL,sha256=pUMnbkEoOJH3JIiTuE-9tixQOeWRbAaVqA62Pyrra40,118
+ailoy_py-0.0.2.dist-info/entry_points.txt,sha256=gVG45uDE6kef0wm6SEMYSgZgRNNRhSAeP2n2lPR00dI,50
+ailoy_py-0.0.2.dist-info/RECORD,,

{ailoy_py-0.0.1.dist-info → ailoy_py-0.0.2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: scikit-build-core 0.11.3
+Generator: scikit-build-core 0.11.4
 Root-Is-Purelib: false
 Tag: cp311-cp311-manylinux_2_28_x86_64
 

ailoy_py-0.0.1.dist-info/RECORD

@@ -1,19 +0,0 @@
-ailoy/__init__.py,sha256=ArHu4OLbxU_re9cX-7zhshRqkn46gBcl-0SxDa5Wk00,148
-ailoy/agent.py,sha256=orrfgeH6Xo9nPkHqJJ1YqS_8-5-0_tkpKlF8YcdRIqU,24998
-ailoy/ailoy_py.cpython-311-x86_64-linux-gnu.so,sha256=IA5ayndZJMzsTlVcHMF7brPrZ2lSuMyZYv9qm_4uBf4,24729601
-ailoy/ailoy_py.pyi,sha256=Yf90FEXkslpCpr1r2eqQ3-_1jLo65zmG94bBXDRqinU,991
-ailoy/runtime.py,sha256=tVdUaqqx9NB-h4grRkW_R2XYW5ihFn95aUhnTZkl_Zg,9997
-ailoy/vector_store.py,sha256=Ojhr4bcSfKKuMaldfsjz_G41AGgz4vyvpkWn5WMFE2c,7365
-ailoy/cli/__main__.py,sha256=HnBVb2em1F2NLPeNX5r3xRndRrnGaXVCduo8WBULAI0,179
-ailoy/cli/model.py,sha256=cerCHE-VY9TOwqRcLBtmqnV-5vphpvyhtrfPFZiTKCM,2979
-ailoy/presets/tools/calculator.json,sha256=ePnZsjZChnvS08s9eVdIp4Bys_PlJBXPHCCjv6oMvzA,1040
-ailoy/presets/tools/frankfurter.json,sha256=bZ5vhszf_aR-B_QN4L2xrI5nR-f4AMZk41UUDq1dTXg,1152
-ailoy/presets/tools/nytimes.json,sha256=wrfe9bnAlSPzHladoGEX2oCAeE0wed3BvgXQ_Z2PdXg,918
-ailoy/presets/tools/tmdb.json,sha256=UGLN5uAJ2b-Hu3nLcW95WXDLB3mfC3rBYfQANp_e8Ps,7046
-ailoy_py.libs/libgomp-870cb1d0.so.1.0.0,sha256=Ta6ZPLbakQH8LP74JzBt0DuJIBHS4nicjkSCjKnyWDw,253289
-ailoy_py.libs/libmvec-2-8eb5c230.28.so,sha256=65kXCJhVuWfybQTtrbZvv-omg-x4rUlzPkkPhbZxa7o,181969
-ailoy_py.libs/libtvm_runtime-7067e461.so,sha256=Slb0RS5igenySBg490s7LPCKYmrZl10He1j2QsemmWM,4759545
-ailoy_py-0.0.1.dist-info/METADATA,sha256=FAyzKTteIMgZse5H99IVQ5q2ScjU9hlTuOggBNrgTF0,2010
-ailoy_py-0.0.1.dist-info/WHEEL,sha256=ynEJWBsXE4ohY630UToGhqtzU95gVdbtKm3DQK0bASo,118
-ailoy_py-0.0.1.dist-info/entry_points.txt,sha256=gVG45uDE6kef0wm6SEMYSgZgRNNRhSAeP2n2lPR00dI,50
-ailoy_py-0.0.1.dist-info/RECORD,,