agent-runtime-sdk 0.1.0__py3-none-any.whl

agent_runtime/smol/llm_models.py

@@ -0,0 +1,212 @@
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from openai import OpenAI
+from smolagents import ApiModel, ChatMessage, MessageRole, TokenUsage
+from smolagents.models import remove_content_after_stop_sequences
+from smolagents.tools import Tool
+
+from .models import (
+    OpenAIMessageAssistant,
+    OpenAIMessageSystem,
+    OpenAIMessageTool,
+    OpenAIMessageUser,
+    get_tool_json_schema,
+)
+
+
+class DeepSeekModel(ApiModel):
+    """Thin OpenAI-compatible wrapper based on the original agent-side DeepSeek model."""
+
+    def __init__(
+        self,
+        model_id: str,
+        api_base: str,
+        api_key: str | None = None,
+        organization: str | None = None,
+        project: str | None = None,
+        client_kwargs: dict[str, Any] | None = None,
+        custom_role_conversions: dict[str, str] | None = None,
+        flatten_messages_as_text: bool = False,
+        **kwargs,
+    ):
+        self.client_kwargs = {
+            **(client_kwargs or {}),
+            "api_key": api_key,
+            "base_url": api_base,
+            "organization": organization,
+            "project": project,
+            "timeout": 300,
+        }
+        super().__init__(
+            model_id=model_id,
+            custom_role_conversions=custom_role_conversions,
+            flatten_messages_as_text=flatten_messages_as_text,
+            retry=True,
+            **kwargs,
+        )
+
+    def create_client(self):
+        return OpenAI(**self.client_kwargs)
+
+    def generate(
+        self,
+        messages: list[ChatMessage | dict],
+        stop_sequences: list[str] | None = None,
+        response_format: dict[str, str] | None = None,
+        tools_to_call_from: list[Tool] | None = None,
+        **kwargs,
+    ) -> ChatMessage:
+        completion_kwargs = self._prepare_completion_kwargs(
+            messages=messages,
+            stop_sequences=stop_sequences,
+            response_format=response_format,
+            tools_to_call_from=tools_to_call_from,
+            model=self.model_id,
+            custom_role_conversions=self.custom_role_conversions,
+            convert_images_to_image_urls=True,
+            **kwargs,
+        )
+        self._apply_rate_limit()
+        response = self.retryer(self.client.chat.completions.create, **completion_kwargs)
+        content = response.choices[0].message.content
+        if stop_sequences is not None and not self.supports_stop_parameter:
+            content = remove_content_after_stop_sequences(content, stop_sequences)
+        return ChatMessage(
+            role=response.choices[0].message.role,
+            content=content,
+            tool_calls=response.choices[0].message.tool_calls,
+            raw=response,
+            token_usage=TokenUsage(
+                input_tokens=response.usage.prompt_tokens,
+                output_tokens=response.usage.completion_tokens,
+            ),
+        )
+
+    def _prepare_completion_kwargs(
+        self,
+        messages: list[ChatMessage],
+        stop_sequences: list[str] | None = None,
+        response_format: dict[str, str] | None = None,
+        tools_to_call_from: list[Tool] | None = None,
+        custom_role_conversions: dict[str, str] | None = None,
+        convert_images_to_image_urls: bool = False,
+        tool_choice: str | dict | None = "required",
+        **kwargs,
+    ) -> dict[str, Any]:
+        completion_kwargs = {
+            "messages": self.chat_messages2deepseek_messages(messages),
+        }
+
+        if stop_sequences is not None and self.supports_stop_parameter:
+            completion_kwargs["stop"] = stop_sequences
+        if response_format is not None:
+            completion_kwargs["response_format"] = response_format
+        if tools_to_call_from:
+            completion_kwargs["tools"] = [get_tool_json_schema(tool) for tool in tools_to_call_from]
+            if tool_choice is not None:
+                completion_kwargs["tool_choice"] = tool_choice
+
+        completion_kwargs.update(kwargs)
+        # Keep model-level defaults working the same way as the original agent model.
+        completion_kwargs.update(self.kwargs)
+        return completion_kwargs
+
+    @staticmethod
+    def chat_messages2deepseek_messages(messages: list[ChatMessage]) -> list[dict[str, Any]]:
+        message_list: list[
+            OpenAIMessageSystem | OpenAIMessageUser | OpenAIMessageAssistant | OpenAIMessageTool
+        ] = []
+
+        for chat_message in messages:
+            match chat_message.role:
+                case MessageRole.SYSTEM:
+                    message_list.append(OpenAIMessageSystem(content=_flatten_text_content(chat_message.content)))
+
+                case MessageRole.USER:
+                    message_list.append(OpenAIMessageUser(content=_flatten_text_content(chat_message.content)))
+
+                case MessageRole.ASSISTANT:
+                    content = _flatten_text_content(chat_message.content)
+                    tool_calls = _serialize_tool_calls(chat_message.tool_calls)
+                    if tool_calls:
+                        message_list.append(OpenAIMessageAssistant(content=content or "", tool_calls=tool_calls))
+                    elif content:
+                        message_list.append(OpenAIMessageAssistant(content=content))
+
+                case MessageRole.TOOL_CALL:
+                    tool_calls = _serialize_tool_calls(chat_message.tool_calls)
+                    if tool_calls:
+                        message_list.append(OpenAIMessageAssistant(content="", tool_calls=tool_calls))
+
+                case MessageRole.TOOL_RESPONSE:
+                    # Prefer an explicit call id in the observation text. If it is missing,
+                    # fall back to the most recent assistant tool call so OpenAI-compatible
+                    # servers still accept the tool response.
+                    tool_call_id = _extract_tool_call_id_from_history(message_list)
+                    for tool_response in chat_message.content or []:
+                        if tool_response.get("type") != "text":
+                            continue
+                        text = tool_response.get("text", "")
+                        message_list.append(
+                            OpenAIMessageTool(
+                                content=text,
+                                tool_call_id=_extract_tool_call_id(text) or tool_call_id,
+                            )
+                        )
+        return [message.to_dict() for message in message_list]
+
+
+def _flatten_text_content(content: Any) -> str:
+    if isinstance(content, str):
+        return content
+    if isinstance(content, list):
+        return "\n".join(item.get("text", "") for item in content if item.get("type") == "text")
+    return ""
+
+
+def _extract_tool_call_id(text: str) -> str:
+    prefix = "Call id: "
+    if text.startswith(prefix):
+        return text.splitlines()[0][len(prefix):].strip()
+    return ""
+
+
+def _extract_tool_call_id_from_history(message_list: list[Any]) -> str:
+    if not message_list:
+        return ""
+    assistant_message = message_list[-1]
+    if isinstance(assistant_message, OpenAIMessageAssistant) and assistant_message.tool_calls:
+        return assistant_message.tool_calls[-1].get("id", "")
+    return ""
+
+
+def _serialize_tool_calls(tool_calls: Any) -> list[dict[str, Any]]:
+    if not isinstance(tool_calls, list):
+        return []
+
+    serialized: list[dict[str, Any]] = []
+    for tool_call in tool_calls:
+        function = getattr(tool_call, "function", None)
+        if function is None:
+            continue
+        serialized.append(
+            {
+                "id": getattr(tool_call, "id", ""),
+                "type": getattr(tool_call, "type", "function"),
+                "function": {
+                    "name": getattr(function, "name", ""),
+                    # OpenAI-compatible tool calls require function.arguments to be a string.
+                    "arguments": _stringify_tool_arguments(getattr(function, "arguments", None)),
+                },
+            }
+        )
+    return serialized
+
+
+def _stringify_tool_arguments(value: Any) -> str:
+    if isinstance(value, str):
+        return value
+    return json.dumps(value, ensure_ascii=False)

agent_runtime/smol/memory.py

@@ -0,0 +1,111 @@
+from __future__ import annotations
+
+import inspect
+from collections.abc import Callable
+from dataclasses import dataclass
+
+from smolagents import (
+    ActionStep as BaseActionStep,
+    AgentError,
+    ChatMessage,
+    ChatMessageToolCall,
+    MessageRole,
+)
+
+from .models import ChatMessageToolCallFunction
+
+
+@dataclass
+class ActionStep(BaseActionStep):
+    def to_messages(self, summary_mode: bool = False) -> list[ChatMessage]:
+        messages = []
+        if self.model_output is not None and self.model_output and not summary_mode:
+            messages.append(
+                ChatMessage(
+                    role=MessageRole.ASSISTANT,
+                    content=[{"type": "text", "text": self.model_output.strip()}],
+                )
+            )
+
+        if self.tool_calls is not None:
+            messages.append(
+                ChatMessage(
+                    role=MessageRole.TOOL_CALL,
+                    content=[
+                        {
+                            "type": "text",
+                            "text": "Calling tools:\n" + str([tc.dict() for tc in self.tool_calls]),
+                        }
+                    ],
+                    tool_calls=self.tool_call2chat_message_tool_call(),
+                )
+            )
+
+        if self.observations_images:
+            messages.append(
+                ChatMessage(
+                    role=MessageRole.USER,
+                    content=[{"type": "image", "image": image} for image in self.observations_images],
+                )
+            )
+
+        if self.observations is not None:
+            observation_text = f"Observation:\n{self.observations}"
+            if self.tool_calls:
+                observation_text = f"Call id: {self.tool_calls[0].id}\n" + observation_text
+            messages.append(
+                ChatMessage(
+                    role=MessageRole.TOOL_RESPONSE,
+                    content=[{"type": "text", "text": observation_text}],
+                )
+            )
+
+        if self.error is not None:
+            error_message = (
+                "Error:\n"
+                + str(self.error)
+                + "\nNow let's retry: take care not to repeat previous errors! "
+                + "If you have retried several times, try a completely different approach.\n"
+            )
+            message_content = f"Call id: {self.tool_calls[0].id}\n" if self.tool_calls else ""
+            message_content += error_message
+            messages.append(
+                ChatMessage(role=MessageRole.TOOL_RESPONSE, content=[{"type": "text", "text": message_content}])
+            )
+
+        return messages
+
+    def tool_call2chat_message_tool_call(self) -> list[ChatMessageToolCall]:
+        chat_message_tool_call_list = []
+        for tool_call in self.tool_calls:
+            tool_call_dict = tool_call.dict()
+            chat_message_tool_call_list.append(
+                ChatMessageToolCall(
+                    id=tool_call_dict.get("id"),
+                    type=tool_call_dict.get("type"),
+                    function=ChatMessageToolCallFunction(
+                        name=tool_call_dict.get("function").get("name"),
+                        arguments=tool_call_dict.get("function").get("arguments"),
+                    ),
+                )
+            )
+        return chat_message_tool_call_list
+
+
+class ToolCallbackRegistry:
+    def __init__(self):
+        self._callbacks: dict[str, list[Callable]] = {}
+
+    def register(self, tool_name: str, callback: Callable):
+        if tool_name not in self._callbacks:
+            self._callbacks[tool_name] = []
+        self._callbacks[tool_name].append(callback)
+
+    def callback(self, chat_message: ChatMessage, **kwargs):
+        for tool_call in chat_message.tool_calls or []:
+            callbacks = self._callbacks.get(tool_call.function.name, [])
+            for callback in callbacks:
+                if len(inspect.signature(callback).parameters) == 1:
+                    callback(chat_message)
+                else:
+                    callback(chat_message, **kwargs)

agent_runtime/smol/models.py

@@ -0,0 +1,69 @@
+from __future__ import annotations
+
+from copy import deepcopy
+from dataclasses import asdict, dataclass
+from typing import Any, Literal
+
+from smolagents import Tool
+
+
+@dataclass
+class OpenAIMessageObject:
+    content: str
+
+    def to_dict(self):
+        return asdict(self)
+
+
+@dataclass
+class OpenAIMessageSystem(OpenAIMessageObject):
+    role: Literal["system"] = "system"
+
+
+@dataclass
+class OpenAIMessageUser(OpenAIMessageObject):
+    role: Literal["user"] = "user"
+
+
+@dataclass
+class OpenAIMessageAssistant(OpenAIMessageObject):
+    role: Literal["assistant"] = "assistant"
+    tool_calls: list[dict] | None = None
+
+    def to_dict(self):
+        return asdict(self)
+
+
+@dataclass
+class OpenAIMessageTool(OpenAIMessageObject):
+    tool_call_id: str
+    role: Literal["tool"] = "tool"
+
+
+@dataclass
+class ChatMessageToolCallFunction:
+    arguments: Any
+    name: str
+    description: str | None = None
+
+
+def get_tool_json_schema(tool: Tool) -> dict[str, Any]:
+    properties = deepcopy(tool.inputs)
+    required: list[str] = []
+    for key, value in properties.items():
+        if value["type"] == "any":
+            value["type"] = "string"
+        if not ("nullable" in value and value["nullable"]):
+            required.append(key)
+    return {
+        "type": "function",
+        "function": {
+            "name": tool.name,
+            "description": tool.description,
+            "parameters": {
+                "type": "object",
+                "properties": properties,
+                "required": required,
+            },
+        },
+    }

agent_runtime/standalone.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+"""单 agent 模式下的对外启动 facade。"""
+
+import logging
+from pathlib import Path
+
+from fastapi import FastAPI
+import uvicorn
+
+from .server.app_factory import build_app_from_runtime
+from .server.bootstrap import DEFAULT_DEFINITION_PATH, load_single_agent_runtime
+from .server.endpoint_utils import port_from_public_base_url
+
+
+logger = logging.getLogger(__name__)
+
+
+def build_single_agent_app(
+    definition_path: str | Path = DEFAULT_DEFINITION_PATH,
+    public_base_url: str | None = None,
+    bind_port: int | None = None,
+    discoverer=None,
+) -> FastAPI:
+    """从 definition 直接产出一个可运行的 FastAPI 应用。"""
+
+    runtime = load_single_agent_runtime(
+        definition_path=definition_path,
+        public_base_url=public_base_url,
+        bind_port=bind_port,
+        discoverer=discoverer,
+    )
+    return build_app_from_runtime(runtime, enable_management=False)
+
+
+def run_single_agent_app(
+    app: FastAPI,
+    *,
+    host: str = "0.0.0.0",
+    port: int | None = None,
+) -> None:
+    """按单 agent SDK 的默认约定启动 uvicorn。"""
+
+    bind_port = port if port is not None else port_from_public_base_url(app.state.runtime.public_url())
+    if bind_port is None or bind_port <= 0:
+        raise SystemExit(
+            "没有可用的默认监听端口；请在 agent_app/agent.yaml 配置带端口的 public_base_url，"
+            "或者在 main.py 里调用 run_single_agent_app(app, port=<port>)。"
+        )
+    logger.info(
+        "Starting uvicorn for agent_id=%s host=%s port=%s public_url=%s",
+        app.state.runtime.definition.agent.agent_id,
+        host,
+        bind_port,
+        app.state.runtime.public_url(),
+    )
+    uvicorn.run(app, host=host, port=bind_port)

agent_runtime/storage.py

@@ -0,0 +1,5 @@
+"""Public facade for definition storage."""
+
+from .config.storage import AgentDefinitionStore
+
+__all__ = ["AgentDefinitionStore"]

agent_runtime/tools.py

@@ -0,0 +1,5 @@
+"""对外暴露的运行时协议工具入口。"""
+
+from .runtime_engine.protocol_tools import AskAuthTool, AskUserTool, FinalAnswerTool
+
+__all__ = ["AskAuthTool", "AskUserTool", "FinalAnswerTool"]

agent_runtime_sdk-0.1.0.dist-info/METADATA

@@ -0,0 +1,125 @@
+Metadata-Version: 2.4
+Name: agent-runtime-sdk
+Version: 0.1.0
+Summary: Single-agent runtime SDK for A2A agents backed by MCP tools.
+Project-URL: Homepage, https://pypi.org/project/agent-runtime-sdk/
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: a2a-sdk==0.3.22
+Requires-Dist: smolagents[mcp]
+Requires-Dist: openai
+Requires-Dist: fastapi
+Requires-Dist: uvicorn
+Requires-Dist: httpx
+Requires-Dist: jinja2
+Requires-Dist: pyyaml
+Requires-Dist: loguru
+Requires-Dist: pydantic
+Requires-Dist: rich
+Provides-Extra: observability
+Requires-Dist: langfuse; extra == "observability"
+Requires-Dist: openinference-instrumentation-smolagents; extra == "observability"
+Provides-Extra: dev
+Requires-Dist: build; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+
+# agent-runtime-sdk
+
+Single-agent runtime SDK for exposing MCP tools as an A2A-compatible agent service.
+
+## Install
+
+```bash
+pip install agent-runtime-sdk
+```
+
+Install optional Langfuse/smolagents observability support:
+
+```bash
+pip install "agent-runtime-sdk[observability]"
+```
+
+## Basic Usage
+
+Create an agent project:
+
+```text
+my-agent/
+├── agent_app/
+│   ├── agent.yaml
+│   └── plugin.py
+└── main.py
+```
+
+Example `main.py`:
+
+```python
+from pathlib import Path
+
+from agent_runtime.standalone import build_single_agent_app, run_single_agent_app
+
+
+app = build_single_agent_app(
+    Path(__file__).resolve().parent / "agent_app" / "agent.yaml"
+)
+
+
+if __name__ == "__main__":
+    run_single_agent_app(app)
+```
+
+Example SDK import:
+
+```python
+from agent_runtime import AgentBuilder
+```
+
+## Minimal Configuration
+
+Example `agent_app/agent.yaml`:
+
+```yaml
+agent:
+  agent_id: example-agent
+  name: Example Agent
+  description: Example A2A agent backed by MCP tools.
+
+runtime:
+  public_base_url: ${AGENT_PUBLIC_BASE_URL:-http://127.0.0.1:10020}
+  model:
+    provider: openai_compatible
+    api_base: ${MODEL_SOURCE_API_BASE}
+    model_id: ${MODEL_SOURCE_MODEL_ID}
+    api_key_env: MODEL_SOURCE_API_KEY
+
+mcps:
+  - name: example
+    url: ${MCP_EXAMPLE_URL}
+    transport: streamable-http
+```
+
+Run:
+
+```bash
+export MODEL_SOURCE_API_BASE="https://your-model-api.example.com"
+export MODEL_SOURCE_MODEL_ID="your-model-id"
+export MODEL_SOURCE_API_KEY="your-api-key"
+export MCP_EXAMPLE_URL="http://127.0.0.1:8000/mcp"
+export AGENT_PUBLIC_BASE_URL="http://127.0.0.1:10020"
+
+python main.py
+```
+
+## Langfuse
+
+After installing `agent-runtime-sdk[observability]`, configure:
+
+```bash
+export MCP_AGENT_LANGFUSE_ENABLED=true
+export LANGFUSE_BASE_URL="http://your-langfuse-host:3000"
+export LANGFUSE_PUBLIC_KEY="pk-lf-..."
+export LANGFUSE_SECRET_KEY="sk-lf-..."
+```
+
+Set `MCP_AGENT_LANGFUSE_ENABLED=false` to disable instrumentation.

agent_runtime_sdk-0.1.0.dist-info/RECORD

@@ -0,0 +1,51 @@
+agent_runtime/__init__.py,sha256=vZfLvJTs7TGfotvY4Mn5yTguQflMX9IbRbQm7W5Sr-U,2155
+agent_runtime/builder.py,sha256=dluDyF5yg9RjUBySHFt782hNA6gtnXHBBoSnBnhe4fM,10541
+agent_runtime/context.py,sha256=5InRJd84fZj03e9I8xdqdlG94TbZICLyP4gy9-uTpXw,250
+agent_runtime/definitions.py,sha256=GGWReUrP2Y-fnojsUb2dxrSH36DQPjtC1vS2j6s9ft0,704
+agent_runtime/discovery.py,sha256=ie76iVQ7XlvqBF1q5UfDG92wuJ-wv9VTCCV6Xan9wSw,386
+agent_runtime/exceptions.py,sha256=NIjRcKM8r-ZnyB3f4wQa4IyeHy-3Fu6QaEBsh3pgNAw,2304
+agent_runtime/model_registry.py,sha256=pzLs3sF4GmEcJea1wKAm1Gt4g3fEMcHIkO6Q2bm2UvI,1008
+agent_runtime/policies.py,sha256=c0Ttz-0Wn1jz8mgmw_YJl4hIUEtBA_teifw_ql1XVhc,295
+agent_runtime/runtime.py,sha256=WMmNmAa5JBKCkjbl7TcLLwNssGdsGfYjYVNAU61fkuA,3721
+agent_runtime/sdk_agent.py,sha256=iUTI66ccgktu9zEgOPCVkQl4N3NT_ld7TNMimFUf7iw,17446
+agent_runtime/standalone.py,sha256=T3NwUJ7Uly-J9zssjB9HvqY6N-ZNThcy45saUE8dB2c,1775
+agent_runtime/storage.py,sha256=ug3oWJefD2fpBtFs7WU_XirW_Jz6AzvrKpv39zNBjM0,130
+agent_runtime/tools.py,sha256=w9rxqjXUNhCQFR2nUeTiGlkpDzJzjc4Baw2NvmbVF4c,199
+agent_runtime/config/__init__.py,sha256=rY1oFQFqqBG0Ih6Mt5TeCUZ9J_bkFSwjxvIokN3FM4g,552
+agent_runtime/config/definitions.py,sha256=i130Ojung9ShVkLKIR2qIgdnDobbNhRFSJUO8tbwy8o,4290
+agent_runtime/config/policies.py,sha256=shhoRQbUlPytOEG0pJCQ_DOkeDxyWi1ECnHA4uZAAGk,1966
+agent_runtime/config/storage.py,sha256=_xjwS1ItHVqtbjOkZnKmZ5dDwfU__5w8ddMKUtSCvVc,4691
+agent_runtime/mcp/__init__.py,sha256=EZSRhs4RxoHXRGSM4nv-4kbSZuAgtGR0VkqIUsyEVFc,721
+agent_runtime/mcp/discovery.py,sha256=nvLTdcdHpMqYrzdL7ymeIcXJclIAoI-buk8senXVnGs,4824
+agent_runtime/mcp/metadata.py,sha256=cGuMJjZWGeqP6Pn5r37uQHhYre_r14aDnGinWVhdew4,2135
+agent_runtime/mcp/utils.py,sha256=ZmaPV2y88XshC71GzBGWY0hpHRLvlW2R-dhZ2QgLSj8,1492
+agent_runtime/plugins/__init__.py,sha256=so756bRTF3SAZ-yrql5hxr3nX2QwWN88MpTzAA1aHE0,200
+agent_runtime/plugins/base.py,sha256=MJuDcH9yJVUGV1CpvaXk0RqWHkmUNNGsbZXRPMbCPJs,2690
+agent_runtime/plugins/default.py,sha256=uXxMqgKLwOqC673zERtE8eW72McxwLUGz64zviSomug,568
+agent_runtime/plugins/instructions.py,sha256=T8f7v7XMlBAY_s_6mDt5HkRC1fevLT9nCRK99eTzo4A,1295
+agent_runtime/plugins/loader.py,sha256=uM9yiK-rIzkU-4LBlXxuDDkh0s9Ci5v0xLE5Nd2kIDY,2131
+agent_runtime/runtime_engine/__init__.py,sha256=OeH5vZG_mHsqcWl0NnYV7A4Wf2Vf5vHdzjo_XtEtNQQ,949
+agent_runtime/runtime_engine/a2a_bridge.py,sha256=Qhq_H9BbqUzmlHOQNWwVl4YaaxrkLiny0QfpPmTA6rk,7089
+agent_runtime/runtime_engine/a2a_task_io.py,sha256=L3BmDPiRgF3yPw49znpRD-6IlPcLe83rRJeJVF3_IwE,5288
+agent_runtime/runtime_engine/agent_build.py,sha256=6IFCqnuha_84hP1nHtw3BiJx_uTVrinPSAU23714Tbw,11146
+agent_runtime/runtime_engine/context.py,sha256=gPG6U208heGO1-vMiaGL52hGUzKffsFSG-BL_hN5ak8,13405
+agent_runtime/runtime_engine/loading.py,sha256=XtmvdabFst1gcaQujG2nhO6UoQfVZU4hoHMJrBaaWkA,5767
+agent_runtime/runtime_engine/observability.py,sha256=L3oI9Y5Zw7ISXT0GMqTHZ-WXdb3hOFaGM1iphUw4gog,4418
+agent_runtime/runtime_engine/policy_registry.py,sha256=Ng7EswD-umdF4XjlVwnZlytwAbjf5ArU5hwSrOnNjSg,3715
+agent_runtime/runtime_engine/protocol_tools.py,sha256=SMtXcoT4JDXrQM0dGXzrXM6Ch8w4aLGRJOdZEv3TGKs,2333
+agent_runtime/runtime_engine/task_flow.py,sha256=94KmcGIlqozfqt0jkinCzyolVOy56JRAfRPv5cRWpo0,28016
+agent_runtime/runtime_engine/tool_flow.py,sha256=pBRwR76WtRDZTR4zOW_ertGZkQNPCdp8w5mOHDikWfc,11352
+agent_runtime/server/__init__.py,sha256=RWGoV_RAB_XoSipKhgK2vurJ22ZrJIALmR8M7wd_XAg,493
+agent_runtime/server/app_factory.py,sha256=AcMIDkIHfGoIhKaqyNTH8dUmUhclPukkPPqUxMT3m9U,1015
+agent_runtime/server/bootstrap.py,sha256=HRs7-XuyUVeqcz3W59S7IO4e3IUjZoUbzDfU3NxlI1s,1582
+agent_runtime/server/endpoint_utils.py,sha256=Y7zi61nFzbFY52IaEN1oWUUs7WEcW018PwK-2IhrSpI,1243
+agent_runtime/server/management.py,sha256=D7p8BKFGG-wYxbQuftjA-0ZyE5rwFV_gTY8rvcdDDQY,3800
+agent_runtime/smol/__init__.py,sha256=WeKTbvwrR8GzdTQsB4h-u35R1lCC1weFdzTvrifyTUc,134
+agent_runtime/smol/agents.py,sha256=rHdGiWGNcyIroKfJEddDts_LEWRJVqtjVnMcjQ4GyRU,16782
+agent_runtime/smol/llm_models.py,sha256=d8xXarHrrkw60GUZCMBF_vtef8qoJjb49WjC9z1d8dI,8172
+agent_runtime/smol/memory.py,sha256=2Cd29kXgqOx51yIHnXdKQhTqeneUn2y8JFDir40UBQM,4057
+agent_runtime/smol/models.py,sha256=0mMMuR50E4Ehs9vFIGliVaWjwKi4ghQTH1pV1uvOz4Y,1548
+agent_runtime_sdk-0.1.0.dist-info/METADATA,sha256=Z73KZZ92m04ySXOqbPi8ndphgf4QBe9f52DbVPhob2k,2760
+agent_runtime_sdk-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+agent_runtime_sdk-0.1.0.dist-info/top_level.txt,sha256=vDappP7R62mPBfF_Va17SkMnaUilueFJe_Fdyom03jw,14
+agent_runtime_sdk-0.1.0.dist-info/RECORD,,

agent_runtime_sdk-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

agent_runtime_sdk-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+agent_runtime