Skip to content

Self-evolving Context Database for AI Agents. Unify Agent Memory, Knowledge RAG and Skills.

8.5 KB
Raw Blame
"""Resolve the server at setup; retain verified native embedding packages."""

from __future__ import annotations

import hashlib
import os
import platform
import sys
import tempfile
from pathlib import Path
from urllib.parse import parse_qs, urldefrag, urlparse

import httpx
from packaging.requirements import Requirement
from packaging.specifiers import SpecifierSet
from packaging.tags import sys_tags
from packaging.utils import InvalidWheelFilename, parse_wheel_filename
from packaging.version import InvalidVersion, Version

_CPP = "https://github.com/abetlen/llama-cpp-python/releases/download/"
# macOS uses the working Metal archive. The same release's CPU macOS archive
# fails CRC validation and must not be substituted here.
_PACKAGES = {
    ("Darwin", "arm64"): (
        "v0.3.30-metal/llama_cpp_python-0.3.30-py3-none-macosx_11_0_arm64.whl",
        "4f5b385f31dbda502d7118aff0c07c9e98961fa0402c025b89ff3250db843eb3",
    ),
    ("Linux", "x86_64"): (
        "v0.3.30/llama_cpp_python-0.3.30-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl",
        "591337ea31b6fea25f02da53db136041899a530eda1b2c2611f0bebe7c560a15",
    ),
    ("Linux", "aarch64"): (
        "v0.3.30/llama_cpp_python-0.3.30-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl",
        "0720e1d122a4d1ad46607813bd34018ff46b0f50cd0a38fb93fad650b3b98ade",
    ),
    ("Windows", "x86_64"): (
        "v0.3.36/llama_cpp_python-0.3.36-py3-none-win_amd64.whl",
        "ae5e88a2cf464e5a2dde7c8898c2d5c71cc24d03cac6396bf7509456bde0b9fb",
    ),
}


def install_requirements(*, allow_source_build=False):
    from .quick_local import OPENVIKING_REQUIREMENT, SourceBuildRequired

    system = platform.system()
    machine = platform.machine().lower()
    machine = {"amd64": "x86_64", "arm64": "arm64" if system == "Darwin" else "aarch64"}.get(
        machine, machine
    )
    packages = _PACKAGES.get((system, machine))
    compatible = sys.maxsize > 2**32
    if system == "Darwin":
        compatible = compatible and Version(platform.mac_ver()[0] or "0") >= Version("14")
    elif system == "Linux":
        libc, version = platform.libc_ver()
        compatible = compatible and libc == "glibc" and Version(version or "0") >= Version("2.31")
    if not packages or not compatible:
        if not allow_source_build:
            raise SourceBuildRequired(
                "No reviewed Quick Local binary is available for this platform. "
                "Use a separate OpenViking server, or explicitly allow a source build "
                "in setup. A build needs native development tools and can take several minutes."
            )
        requirements = [OPENVIKING_REQUIREMENT, "llama-cpp-python==0.3.30"]
    else:
        cpp_path, cpp_hash = packages
        requirements = [
            OPENVIKING_REQUIREMENT,
            f"llama-cpp-python @ {_CPP}{cpp_path}#sha256={cpp_hash}",
        ]
    # The PM resolver otherwise chooses a LiteLLM release that excludes Python
    # 3.14. This constraint belongs only to OpenViking's private environment.
    return [*requirements, 'litellm==1.83.7; python_version >= "3.14"']


def resolve_server_requirement(*, allow_source_build=False):
    """Select a stable PyPI release only during explicit Quick Local setup."""
    from .quick_local import QuickLocalSetupError

    try:
        response = httpx.get("https://pypi.org/pypi/openviking/json", timeout=30)
        response.raise_for_status()
        return _select_server_requirement(
            response.json()["releases"],
            python_version=platform.python_version(),
            tags=list(sys_tags()),
            allow_source_build=allow_source_build,
        )
    except (httpx.HTTPError, KeyError, TypeError, ValueError) as exc:
        raise QuickLocalSetupError(
            "Could not check OpenViking releases on PyPI. Check network access and retry setup."
        ) from exc


def _select_server_requirement(releases, *, python_version, tags, allow_source_build=False):
    from .quick_local import OPENVIKING_REQUIREMENT, QuickLocalSetupError

    specifier = Requirement(OPENVIKING_REQUIREMENT).specifier
    ranked_tags = {tag: rank for rank, tag in enumerate(tags)}
    versions = []
    for raw_version, files in releases.items():
        try:
            version = Version(raw_version)
        except InvalidVersion:
            continue
        if version in specifier and not version.is_prerelease and not version.is_devrelease:
            versions.append((version, files))
    for version, files in sorted(versions, key=lambda item: item[0], reverse=True):
        wheels = []
        source_available = False
        for file in files:
            if file.get("yanked") or python_version not in SpecifierSet(
                file.get("requires_python") or ""
            ):
                continue
            if file.get("packagetype") == "sdist":
                source_available = True
                continue
            try:
                name, wheel_version, _build, wheel_tags = parse_wheel_filename(file["filename"])
            except (InvalidWheelFilename, KeyError):
                continue
            matches = wheel_tags.intersection(ranked_tags)
            if name == "openviking" and wheel_version == version and matches:
                wheels.append((min(ranked_tags[tag] for tag in matches), file))
        if wheels:
            file = min(wheels, key=lambda item: item[0])[1]
            url = file["url"]
            if (
                urlparse(url).scheme != "https"
                or urlparse(url).hostname != "files.pythonhosted.org"
            ):
                raise QuickLocalSetupError("OpenViking's release download must come from PyPI.")
            digest = file["digests"]["sha256"]
            return f"openviking[local-embed] @ {url}#sha256={digest}"
        if allow_source_build and source_available:
            return f"openviking[local-embed]=={version}"
    raise QuickLocalSetupError(
        "No compatible OpenViking release is available for this Python and platform. "
        "Use a separate server or explicitly allow a source build in setup."
    )


def verified_requirements(requirements: list[str], cache: Path) -> list[str]:
    """Give installers local wheels whose bytes match the reviewed pins.

    PM's project resolver does not enforce hashes in URL fragments. Checking
    before installation also protects the pre-PM path and cache reuse.
    """
    from .quick_local import QuickLocalSetupError, _prepare_private_directory

    verified = []
    for value in requirements:
        requirement = Requirement(value)
        if not requirement.url:
            verified.append(value)
            continue
        url, fragment = urldefrag(requirement.url)
        digest = parse_qs(fragment).get("sha256", [""])[0]
        if len(digest) != 64 or any(c not in "0123456789abcdef" for c in digest):
            raise QuickLocalSetupError("Quick Local's native package needs a reviewed SHA-256 pin.")
        _prepare_private_directory(cache)
        directory = cache / digest
        _prepare_private_directory(directory)
        wheel = directory / Path(urlparse(url).path).name
        if not wheel.name.endswith(".whl") or wheel.is_symlink():
            raise QuickLocalSetupError("Quick Local's native package must be a private wheel file.")
        if not wheel.is_file() or _sha256(wheel) != digest:
            fd, temporary = tempfile.mkstemp(dir=directory, suffix=".download")
            try:
                checksum = hashlib.sha256()
                with os.fdopen(fd, "wb") as output:
                    with httpx.stream("GET", url, follow_redirects=True, timeout=60) as response:
                        response.raise_for_status()
                        for chunk in response.iter_bytes(1024 * 1024):
                            checksum.update(chunk)
                            output.write(chunk)
                if checksum.hexdigest() != digest:
                    raise QuickLocalSetupError(
                        "Quick Local's native package failed SHA-256 verification. Installation was cancelled."
                    )
                os.replace(temporary, wheel)
            finally:
                Path(temporary).unlink(missing_ok=True)
        extras = f"[{','.join(sorted(requirement.extras))}]" if requirement.extras else ""
        marker = f" ; {requirement.marker}" if requirement.marker else ""
        verified.append(f"{requirement.name}{extras} @ {wheel.absolute().as_uri()}{marker}")
    return verified


def _sha256(path: Path) -> str:
    with path.open("rb") as file:
        return hashlib.file_digest(file, "sha256").hexdigest()