ya-agent-platform 0.58.3__py3-none-any.whl

ya_agent_platform/__init__.py

@@ -0,0 +1,4 @@
+from ya_agent_platform.app import create_app
+from ya_agent_platform.config import PlatformSettings, get_settings
+
+__all__ = ["PlatformSettings", "create_app", "get_settings"]

ya_agent_platform/__main__.py

@@ -0,0 +1,3 @@
+from ya_agent_platform.cli import cli
+
+cli()

ya_agent_platform/alembic/env.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+from logging.config import fileConfig
+from typing import Any
+
+from alembic import context
+from sqlalchemy import create_engine, pool
+from ya_agent_platform.config import PlatformSettings
+from ya_agent_platform.db import tables as _tables  # noqa: F401
+from ya_agent_platform.db.engine import to_sync_database_url
+from ya_agent_platform.db.tables import Base
+
+config = context.config
+if config.config_file_name is not None:
+    fileConfig(config.config_file_name)
+
+target_metadata = Base.metadata
+
+settings = PlatformSettings()
+if not settings.database_url:
+    msg = "YA_PLATFORM_DATABASE_URL is not set. Cannot run migrations."
+    raise RuntimeError(msg)
+
+
+def get_url() -> str:
+    database_url = settings.database_url
+    if database_url is None:
+        msg = "database_url is None"
+        raise RuntimeError(msg)
+    return to_sync_database_url(database_url)
+
+
+def include_object(obj: Any, name: str | None, type_: str, reflected: bool, compare_to: Any) -> bool:
+    return not (type_ == "table" and reflected and compare_to is None)
+
+
+def run_migrations_offline() -> None:
+    context.configure(
+        url=get_url(),
+        target_metadata=target_metadata,
+        include_object=include_object,
+        literal_binds=True,
+        dialect_opts={"paramstyle": "named"},
+        compare_type=True,
+        compare_server_default=True,
+    )
+
+    with context.begin_transaction():
+        context.run_migrations()
+
+
+def run_migrations_online() -> None:
+    connectable = create_engine(get_url(), poolclass=pool.NullPool)
+
+    with connectable.connect() as connection:
+        context.configure(
+            connection=connection,
+            target_metadata=target_metadata,
+            include_object=include_object,
+            compare_type=True,
+            compare_server_default=True,
+        )
+
+        with context.begin_transaction():
+            context.run_migrations()
+
+
+if context.is_offline_mode():
+    run_migrations_offline()
+else:
+    run_migrations_online()

ya_agent_platform/alembic/script.py.mako

@@ -0,0 +1,27 @@
+"""${message}
+
+Revision ID: ${up_revision}
+Revises: ${down_revision | comma,n}
+Create Date: ${create_date}
+
+"""
+from __future__ import annotations
+
+from alembic import op
+import sqlalchemy as sa
+
+${imports if imports else ""}
+
+# revision identifiers, used by Alembic.
+revision = ${repr(up_revision)}
+down_revision = ${repr(down_revision)}
+branch_labels = ${repr(branch_labels)}
+depends_on = ${repr(depends_on)}
+
+
+def upgrade() -> None:
+    ${upgrades if upgrades else "pass"}
+
+
+def downgrade() -> None:
+    ${downgrades if downgrades else "pass"}

ya_agent_platform/alembic/versions/__init__.py

@@ -0,0 +1 @@
+"""Alembic migration versions for ya-agent-platform."""

ya_agent_platform/alembic.ini

@@ -0,0 +1,44 @@
+# Alembic configuration file.
+# Production use: `ya-agent-platform migrate` or `ya-agent-platform db upgrade`.
+
+[alembic]
+script_location = %(here)s/alembic
+file_template = %%(year)d%%(month).2d%%(day).2d_%%(rev)s_%%(slug)s
+prepend_sys_path = .
+path_separator = os
+
+# Database URL is read from YA_PLATFORM_DATABASE_URL in env.py.
+# Do not set sqlalchemy.url here.
+
+[loggers]
+keys = root,sqlalchemy,alembic
+
+[handlers]
+keys = console
+
+[formatters]
+keys = generic
+
+[logger_root]
+level = WARNING
+handlers = console
+
+[logger_sqlalchemy]
+level = WARNING
+handlers =
+qualname = sqlalchemy.engine
+
+[logger_alembic]
+level = INFO
+handlers =
+qualname = alembic
+
+[handler_console]
+class = StreamHandler
+args = (sys.stderr,)
+level = NOTSET
+formatter = generic
+
+[formatter_generic]
+format = %(levelname)-5.5s [%(name)s] %(message)s
+datefmt = %H:%M:%S

ya_agent_platform/api/__init__.py

@@ -0,0 +1 @@
+__all__ = []

ya_agent_platform/api/health.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+from fastapi import APIRouter, Request
+from pydantic import BaseModel
+from sqlalchemy import text
+
+router = APIRouter(tags=["health"])
+
+
+class HealthStatus(BaseModel):
+    status: str
+    postgres: str
+    redis: str
+
+
+@router.get("/healthz", response_model=HealthStatus)
+async def healthz(request: Request) -> HealthStatus:
+    postgres = "unavailable"
+    redis = "unavailable"
+
+    db_engine = getattr(request.app.state, "db_engine", None)
+    if db_engine is not None:
+        try:
+            async with db_engine.connect() as connection:
+                await connection.execute(text("SELECT 1"))
+            postgres = "ok"
+        except Exception:
+            postgres = "error"
+
+    redis_client = getattr(request.app.state, "redis", None)
+    if redis_client is not None:
+        try:
+            await redis_client.ping()
+            redis = "ok"
+        except Exception:
+            redis = "error"
+
+    status = "degraded" if "error" in {postgres, redis} else "ok"
+    return HealthStatus(status=status, postgres=postgres, redis=redis)

ya_agent_platform/api/platform.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+from ya_agent_platform.config import get_settings
+
+router = APIRouter(prefix="/api/v1/platform", tags=["platform"])
+
+
+class PlatformInfo(BaseModel):
+    name: str
+    environment: str
+    public_base_url: str
+    surfaces: list[str]
+    bridge_model: str
+    runtime_model: str
+
+
+class PlatformTopology(BaseModel):
+    nodes: list[str]
+    edges: list[str]
+
+
+@router.get("/info", response_model=PlatformInfo)
+async def platform_info() -> PlatformInfo:
+    settings = get_settings()
+    return PlatformInfo(
+        name=settings.app_name,
+        environment=settings.environment,
+        public_base_url=settings.public_base_url,
+        surfaces=["management-api", "chat-api", "bridge-api", "chat-ui"],
+        bridge_model="bridge adapters connect external IM systems to normalized platform events",
+        runtime_model="agent sessions run through ya-agent-sdk based runtimes and workers",
+    )
+
+
+@router.get("/topology", response_model=PlatformTopology)
+async def platform_topology() -> PlatformTopology:
+    return PlatformTopology(
+        nodes=[
+            "chat-ui",
+            "management-api",
+            "chat-api",
+            "bridge-api",
+            "runtime-control",
+            "runtime-workers",
+            "postgres",
+            "redis-or-message-bus",
+        ],
+        edges=[
+            "chat-ui -> management-api",
+            "chat-ui -> chat-api",
+            "bridge adapters -> bridge-api",
+            "management-api -> runtime-control",
+            "chat-api -> runtime-control",
+            "runtime-control -> runtime-workers",
+            "runtime-control -> postgres",
+            "runtime-control -> redis-or-message-bus",
+        ],
+    )

ya_agent_platform/app.py

@@ -0,0 +1,136 @@
+from __future__ import annotations
+
+from collections.abc import AsyncIterator
+from contextlib import asynccontextmanager
+from pathlib import Path
+
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import FileResponse
+
+from ya_agent_platform.api.health import router as health_router
+from ya_agent_platform.api.platform import router as platform_router
+from ya_agent_platform.config import PlatformSettings, get_settings
+from ya_agent_platform.db.engine import create_engine
+from ya_agent_platform.redis import create_redis_client
+
+_RESERVED_FRONTEND_PATHS = ("api", "docs", "redoc", "openapi.json", "healthz")
+
+
+@asynccontextmanager
+async def _lifespan(app: FastAPI) -> AsyncIterator[None]:
+    settings = get_settings()
+
+    app.state.db_engine = None
+    app.state.redis = None
+
+    if settings.database_url:
+        app.state.db_engine = create_engine(
+            settings.database_url,
+            echo=settings.database_echo,
+            pool_size=settings.database_pool_size,
+            max_overflow=settings.database_max_overflow,
+            pool_recycle=settings.database_pool_recycle_seconds,
+        )
+
+    if settings.redis_url:
+        app.state.redis = create_redis_client(settings.redis_url)
+
+    try:
+        yield
+    finally:
+        redis_client = app.state.redis
+        if redis_client is not None:
+            await redis_client.aclose()
+
+        db_engine = app.state.db_engine
+        if db_engine is not None:
+            await db_engine.dispose()
+
+
+def _resolve_frontend_target(web_dist_dir: Path, requested_path: str) -> Path:
+    relative_path = requested_path.strip("/")
+    if relative_path == "":
+        return web_dist_dir / "index.html"
+
+    candidate = (web_dist_dir / relative_path).resolve()
+    web_root = web_dist_dir.resolve()
+
+    try:
+        candidate.relative_to(web_root)
+    except ValueError as exc:
+        raise HTTPException(status_code=404, detail="Invalid frontend asset path.") from exc
+
+    if candidate.is_file():
+        return candidate
+
+    return web_dist_dir / "index.html"
+
+
+def _register_frontend(app: FastAPI, settings: PlatformSettings) -> bool:
+    web_dist_dir = settings.web_dist_dir
+    if web_dist_dir is None:
+        return False
+
+    index_file = web_dist_dir / "index.html"
+    if not web_dist_dir.exists() or not index_file.exists():
+        return False
+
+    @app.get("/", include_in_schema=False)
+    async def frontend_index() -> FileResponse:
+        return FileResponse(index_file)
+
+    @app.get("/{full_path:path}", include_in_schema=False)
+    async def frontend_route(full_path: str) -> FileResponse:
+        normalized_path = full_path.strip("/")
+        if normalized_path in _RESERVED_FRONTEND_PATHS or any(
+            normalized_path.startswith(f"{prefix}/") for prefix in _RESERVED_FRONTEND_PATHS if "/" not in prefix
+        ):
+            raise HTTPException(status_code=404, detail="Route not found.")
+
+        return FileResponse(_resolve_frontend_target(web_dist_dir, normalized_path))
+
+    return True
+
+
+def create_app() -> FastAPI:
+    settings = get_settings()
+
+    app = FastAPI(
+        title=settings.app_name,
+        version="0.1.0",
+        description="Cloud-ready agent platform backend built on top of ya-agent-sdk.",
+        lifespan=_lifespan,
+    )
+    app.state.settings = settings
+
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=settings.allow_origins,
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+
+    app.include_router(health_router)
+    app.include_router(platform_router)
+
+    frontend_registered = _register_frontend(app, settings)
+
+    if not frontend_registered:
+
+        @app.get("/")
+        async def index() -> dict[str, object]:
+            return {
+                "name": settings.app_name,
+                "environment": settings.environment,
+                "docs_url": "/docs",
+                "spec_path": "packages/ya-agent-platform/spec",
+                "surfaces": {
+                    "admin": settings.admin_mount_path,
+                    "chat": settings.chat_mount_path,
+                    "bridges": settings.bridge_mount_path,
+                },
+            }
+
+    return app

ya_agent_platform/cli.py

@@ -0,0 +1,117 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import click
+import uvicorn
+
+from ya_agent_platform.config import get_settings
+
+
+@click.group()
+def cli() -> None:
+    """YA Agent Platform management CLI."""
+
+
+def _alembic_config():
+    """Build an Alembic Config from the package's alembic.ini."""
+    from alembic.config import Config
+
+    ini_path = Path(__file__).parent / "alembic.ini"
+    return Config(str(ini_path))
+
+
+def _ensure_database_url() -> str:
+    settings = get_settings()
+    if settings.database_url:
+        return settings.database_url
+
+    click.echo("Error: YA_PLATFORM_DATABASE_URL is required.", err=True)
+    raise SystemExit(1)
+
+
+def _apply_database_migrations(revision: str = "head") -> None:
+    from alembic import command
+
+    _ensure_database_url()
+    command.upgrade(_alembic_config(), revision)
+
+
+@cli.command("serve")
+@click.option("--host", default=None, help="Bind host for the HTTP server.")
+@click.option("--port", default=None, type=int, help="Bind port for the HTTP server.")
+@click.option("--reload/--no-reload", default=None, help="Enable or disable code reload.")
+@click.option("--migrate/--no-migrate", default=None, help="Run database migrations before starting the server.")
+def serve(host: str | None, port: int | None, reload: bool | None, migrate: bool | None) -> None:
+    settings = get_settings()
+    resolved_host = host or settings.host
+    resolved_port = port or settings.port
+    resolved_reload = settings.reload if reload is None else reload
+    resolved_migrate = settings.auto_migrate if migrate is None else migrate
+
+    if resolved_migrate and settings.database_url:
+        _apply_database_migrations()
+        click.echo("Database migrations applied.")
+
+    uvicorn.run(
+        "ya_agent_platform.app:create_app",
+        factory=True,
+        host=resolved_host,
+        port=resolved_port,
+        reload=resolved_reload,
+    )
+
+
+@cli.command("migrate")
+@click.option("--revision", default="head", help="Target revision for the migration run.")
+def migrate_command(revision: str) -> None:
+    _apply_database_migrations(revision)
+    click.echo(f"Database upgraded to {revision}.")
+
+
+@cli.group()
+def db() -> None:
+    """Database migration and management commands."""
+
+
+@db.command()
+@click.option("--revision", default="head", help="Target revision (default: head).")
+def upgrade(revision: str) -> None:
+    _apply_database_migrations(revision)
+    click.echo(f"Database upgraded to {revision}.")
+
+
+@db.command()
+@click.option("--revision", default="-1", help="Target revision (default: -1, one step back).")
+def downgrade(revision: str) -> None:
+    from alembic import command
+
+    _ensure_database_url()
+    command.downgrade(_alembic_config(), revision)
+    click.echo(f"Database downgraded to {revision}.")
+
+
+@db.command("migrate")
+@click.argument("message")
+def create_migration(message: str) -> None:
+    from alembic import command
+
+    _ensure_database_url()
+    command.revision(_alembic_config(), message=message, autogenerate=True)
+    click.echo(f"Migration generated: {message}")
+
+
+@db.command()
+def current() -> None:
+    from alembic import command
+
+    _ensure_database_url()
+    command.current(_alembic_config(), verbose=True)
+
+
+@db.command()
+def history() -> None:
+    from alembic import command
+
+    _ensure_database_url()
+    command.history(_alembic_config(), verbose=True)

ya_agent_platform/config.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+from functools import lru_cache
+from pathlib import Path
+
+from pydantic import Field
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+class PlatformSettings(BaseSettings):
+    model_config = SettingsConfigDict(
+        env_prefix="YA_PLATFORM_",
+        env_file=".env",
+        env_file_encoding="utf-8",
+        extra="ignore",
+    )
+
+    app_name: str = "YA Agent Platform"
+    environment: str = "development"
+    host: str = "127.0.0.1"
+    port: int = 9042
+    reload: bool = False
+    public_base_url: str = "http://127.0.0.1:9042"
+    admin_mount_path: str = "/admin"
+    chat_mount_path: str = "/chat"
+    bridge_mount_path: str = "/bridges"
+    web_dist_dir: Path | None = None
+    allow_origins: list[str] = Field(default_factory=lambda: ["http://127.0.0.1:5173", "http://localhost:5173"])
+
+    database_url: str | None = None
+    database_echo: bool = False
+    database_pool_size: int = 5
+    database_max_overflow: int = 10
+    database_pool_recycle_seconds: int = 3600
+
+    redis_url: str | None = None
+
+    auto_migrate: bool = True
+
+
+@lru_cache(maxsize=1)
+def get_settings() -> PlatformSettings:
+    return PlatformSettings()

ya_agent_platform/db/__init__.py

@@ -0,0 +1,4 @@
+from ya_agent_platform.db.base import Base
+from ya_agent_platform.db.engine import create_engine, create_session_factory, to_sync_database_url
+
+__all__ = ["Base", "create_engine", "create_session_factory", "to_sync_database_url"]

ya_agent_platform/db/base.py

@@ -0,0 +1,7 @@
+from __future__ import annotations
+
+from sqlalchemy.orm import DeclarativeBase
+
+
+class Base(DeclarativeBase):
+    pass

ya_agent_platform/db/engine.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+from sqlalchemy.ext.asyncio import AsyncEngine, AsyncSession, async_sessionmaker, create_async_engine
+
+
+def create_engine(database_url: str, **kwargs: object) -> AsyncEngine:
+    defaults: dict[str, object] = {
+        "echo": False,
+        "pool_size": 5,
+        "max_overflow": 10,
+        "pool_pre_ping": True,
+        "pool_recycle": 3600,
+    }
+    defaults.update(kwargs)
+    return create_async_engine(database_url, **defaults)
+
+
+def create_session_factory(engine: AsyncEngine) -> async_sessionmaker[AsyncSession]:
+    return async_sessionmaker(engine, expire_on_commit=False)
+
+
+def to_sync_database_url(database_url: str) -> str:
+    return database_url.replace("postgresql+asyncpg://", "postgresql+psycopg://").replace(
+        "postgresql+psycopg_async://", "postgresql+psycopg://"
+    )

ya_agent_platform/db/tables.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+from ya_agent_platform.db.base import Base
+
+# Import ORM models here so Alembic autogenerate can discover them.
+# Example:
+# from ya_agent_platform.db.workspace import Workspace
+
+__all__ = ["Base"]

ya_agent_platform/redis.py

@@ -0,0 +1,7 @@
+from __future__ import annotations
+
+from redis.asyncio import Redis
+
+
+def create_redis_client(redis_url: str, *, health_check_interval: int = 30) -> Redis:
+    return Redis.from_url(redis_url, health_check_interval=health_check_interval)

ya_agent_platform-0.58.3.dist-info/METADATA

@@ -0,0 +1,163 @@
+Metadata-Version: 2.4
+Name: ya-agent-platform
+Version: 0.58.3
+Summary: Cloud-ready agent platform built on top of ya-agent-sdk
+Project-URL: Repository, https://github.com/wh1isper/ya-mono
+Author-email: wh1isper <jizhongsheng957@gmail.com>
+Keywords: agent-platform,ai-agent,fastapi,python
+Classifier: Framework :: FastAPI
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: <3.14,>=3.11
+Requires-Dist: alembic>=1.16.0
+Requires-Dist: click>=8.0
+Requires-Dist: fastapi>=0.116.0
+Requires-Dist: psycopg[binary]>=3.2.0
+Requires-Dist: pydantic-settings>=2.0.0
+Requires-Dist: pydantic>=2.12.0
+Requires-Dist: redis[hiredis]>=6.0.0
+Requires-Dist: sqlalchemy>=2.0.0
+Requires-Dist: sse-starlette>=3.0.0
+Requires-Dist: uvicorn[standard]>=0.35.0
+Requires-Dist: ya-agent-sdk[all]==0.58.3
+Description-Content-Type: text/markdown
+
+# YA Agent Platform
+
+Cloud-ready agent platform package for the `ya-mono` workspace.
+
+## Scope
+
+This package initializes the backend service for a complete agent platform:
+
+- management API for platform and workspace administration
+- chat-facing API for first-party Chat UI
+- bridge-facing API surface for IM connectors
+- runtime integration points for `ya-agent-sdk`
+- persistence scaffold with PostgreSQL, Redis, packaged Alembic migrations, and startup auto-migration
+- specification documents that define the target architecture before full implementation
+
+## Current Layout
+
+```text
+packages/ya-agent-platform/
+├── README.md
+├── infra/
+│   ├── dev.env
+│   └── docker-compose.dev.yml
+├── pyproject.toml
+├── spec/
+├── start.sh
+├── tests/
+└── ya_agent_platform/
+    ├── alembic/
+    ├── alembic.ini
+    ├── api/
+    ├── app.py
+    ├── cli.py
+    ├── config.py
+    ├── db/
+    └── redis.py
+```
+
+## Quick Start
+
+From the workspace root:
+
+```bash
+uv sync --all-packages
+make platform-infra-up
+set -a && source packages/ya-agent-platform/infra/dev.env && set +a
+uv run --package ya-agent-platform ya-agent-platform serve --reload
+```
+
+The development server listens on `http://127.0.0.1:9042` by default.
+
+## Database and Redis Commands
+
+Use the package CLI directly:
+
+```bash
+uv run --package ya-agent-platform ya-agent-platform migrate
+uv run --package ya-agent-platform ya-agent-platform db current
+uv run --package ya-agent-platform ya-agent-platform db history
+uv run --package ya-agent-platform ya-agent-platform db migrate "add workspace tables"
+```
+
+Use the workspace Makefile wrappers:
+
+```bash
+make platform-db-upgrade
+make platform-db-current
+make platform-db-history
+make platform-db-migrate MSG="add workspace tables"
+```
+
+## Auto Migration
+
+`YA_PLATFORM_AUTO_MIGRATE=true` is the default behavior.
+
+- `ya-agent-platform serve` applies migrations before boot when `YA_PLATFORM_DATABASE_URL` is configured
+- `ya-agent-platform migrate` runs migrations separately
+- `start.sh` applies migrations before starting the server in container environments
+
+## Development Infrastructure
+
+The dev compose file starts PostgreSQL and Redis:
+
+```bash
+make platform-infra-up
+make platform-infra-status
+make platform-infra-down
+```
+
+Default development URLs live in `packages/ya-agent-platform/infra/dev.env`.
+
+## Combined Docker Image
+
+The repository root `Dockerfile` builds a single production image that contains:
+
+- the `ya-agent-platform` backend
+- the bundled `ya-agent-platform-web` frontend
+- FastAPI static serving for the built web assets
+- startup auto-migration support through `packages/ya-agent-platform/start.sh`
+
+Build locally from the repository root:
+
+```bash
+docker build -t ya-agent-platform:dev .
+```
+
+Run locally:
+
+```bash
+docker run --rm -p 9042:9042 ya-agent-platform:dev
+```
+
+The container serves the combined application on `http://127.0.0.1:9042`.
+
+## Initial API Surface
+
+- `GET /healthz` — service health probe with postgres and redis component status
+- `GET /api/v1/platform/info` — platform metadata and enabled surfaces
+- `GET /api/v1/platform/topology` — high-level component topology for the UI and tooling
+
+## Specification Set
+
+- [`spec/README.md`](spec/README.md)
+- [`spec/000-platform-overview.md`](spec/000-platform-overview.md)
+- [`spec/001-system-architecture.md`](spec/001-system-architecture.md)
+- [`spec/002-bridge-contract.md`](spec/002-bridge-contract.md)
+- [`spec/003-http-api.md`](spec/003-http-api.md)
+
+## Next Build Phase
+
+1. add persistence models and first migrations
+2. add runtime orchestration and worker execution
+3. add bridge registry and delivery guarantees
+4. connect the web app to live platform endpoints

ya_agent_platform-0.58.3.dist-info/RECORD

@@ -0,0 +1,21 @@
+ya_agent_platform/__init__.py,sha256=13C_Udthyw4k6eSBy2nsqqlNRjJAvM16pdqct27E7uA,175
+ya_agent_platform/__main__.py,sha256=2502gK30qurdBEUi2cVKrq5CVAcEGlr7x99dxnoMaew,45
+ya_agent_platform/alembic.ini,sha256=2hXTb5zVfDNd91n5DXfO-DArBWnClJp5i3zIWZivn_c,837
+ya_agent_platform/app.py,sha256=racy4giHeBcFvngCfh-5n34cUYe9c4kghlfhDOeJ6i0,4261
+ya_agent_platform/cli.py,sha256=PWBzu6C5aO6vfOgeZW4esj7qG8eP2f2rQzkPX8bf9d4,3384
+ya_agent_platform/config.py,sha256=FcstDVY3q4gvXXRV5HG-AqJMtMaa1DQwAG0_YcJuraU,1195
+ya_agent_platform/redis.py,sha256=FbX9kghVVh-DpWXDbburyB9m-rTX_KX4C2EBXUEsuBk,238
+ya_agent_platform/alembic/env.py,sha256=z1HUHsCR2A1gk6-g_9TuSJmVHPEdFQYv0aGka0ghE4Q,2020
+ya_agent_platform/alembic/script.py.mako,sha256=LIKpNreaIjWwfG8LSVF9TBkGT4av_lhzQ-yBfo9gYXI,547
+ya_agent_platform/alembic/versions/__init__.py,sha256=CyNpGB0vaUHVDQg2asrD2P5ZfuELZtyHr9J4upBBnOY,56
+ya_agent_platform/api/__init__.py,sha256=da1PTClDMl-IBkrSvq6JC1lnS-K_BASzCvxVhNxN5Ls,13
+ya_agent_platform/api/health.py,sha256=bLZO6l0njKYS1itBjni7fmCjHSpMLzU2xNCyHCk7LKs,1087
+ya_agent_platform/api/platform.py,sha256=3EmgGv1GVqaJW5LFn1XhUSwo1uQKMtfb0ywk4RFhhEo,1785
+ya_agent_platform/db/__init__.py,sha256=beJAosi9jEi_zYoVImwNwOvkFntdfE3ukD1jpF2QwdY,230
+ya_agent_platform/db/base.py,sha256=Fp7n4EfxQOxzqm34-D-rYyu60P88eZUIewCBNP_Iuc4,119
+ya_agent_platform/db/engine.py,sha256=eTt5ofSk3WYTTJAd5qL1OBY9ghbc0NyhNW87JKSCVFo,837
+ya_agent_platform/db/tables.py,sha256=r6gFpJkol_pvWsHag9tP_gKm_6cWUFFnV6egf5elvyA,234
+ya_agent_platform-0.58.3.dist-info/METADATA,sha256=Mp291pGwIWR8oR-fKJtlF5eoNB1C1W5-9PuqHjckYuw,4916
+ya_agent_platform-0.58.3.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+ya_agent_platform-0.58.3.dist-info/entry_points.txt,sha256=eN6WvrbjfNf7kIBWJ8i1faCS24ZPf73ZRnX4VxxBszA,64
+ya_agent_platform-0.58.3.dist-info/RECORD,,

ya_agent_platform-0.58.3.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

ya_agent_platform-0.58.3.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+ya-agent-platform = ya_agent_platform.cli:cli