Skip to content

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

7.3 KB
Raw Blame
# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.
# SPDX-License-Identifier: AGPL-3.0
"""Compile task and routing embedding APIs."""

import asyncio
import math

from fastapi import APIRouter, Depends, Header, Path, Query, status
from pydantic import BaseModel, ConfigDict, Field, model_validator

from openviking.core.path_variables import resolve_path_variables
from openviking.core.uri_validation import validate_request_viking_uri
from openviking.server.auth import get_request_context
from openviking.server.dependencies import get_service
from openviking.server.identity import RequestContext
from openviking.server.models import Response
from openviking.service.compile_service import CompileConfigUpdate, CompileRequest
from openviking_cli.exceptions import InvalidArgumentError

router = APIRouter(prefix="/api/v1", tags=["compile"])


@router.post("/compile", status_code=status.HTTP_202_ACCEPTED)
async def create_compile(
    body: CompileRequest,
    ctx: RequestContext = Depends(get_request_context),
    idempotency_key: str | None = Header(
        None, min_length=16, max_length=128, pattern=r"^[A-Za-z0-9:._-]+$"
    ),
    x_request_id: str | None = Header(None),
):
    """Queue a Compile task with the authenticated caller's forwarding identity."""
    connection = {"api_key": ctx.api_key} if ctx.api_key else {}
    connection.update(account_id=ctx.account_id, user_id=ctx.user.user_id)
    if ctx.actor_peer_id:
        connection["actor_peer_id"] = ctx.actor_peer_id
    # Persist the submission's request ID for all asynchronous Runtime calls.
    if x_request_id:
        connection["request_id"] = x_request_id
    task = await get_service().compile.create(
        body,
        connection=connection,
        ctx=ctx,
        **({"idempotency_key": idempotency_key} if idempotency_key else {}),
    )
    return Response(status="ok", result=task.to_dict())


__all__ = ["router"]


@router.get("/compile/config")
async def get_compile_config(
    to: str = Query(..., min_length=1),
    ctx: RequestContext = Depends(get_request_context),
):
    return Response(status="ok", result=await get_service().compile.get_config(to, ctx))


@router.post("/compile/config/update")
async def update_compile_config(
    body: CompileConfigUpdate,
    ctx: RequestContext = Depends(get_request_context),
):
    return Response(status="ok", result=await get_service().compile.update_config(body, ctx))


@router.get("/compile/configs")
async def list_compile_configs(
    limit: int = Query(20, ge=1, le=100),
    cursor: str | None = Query(None),
    ctx: RequestContext = Depends(get_request_context),
):
    return Response(
        status="ok",
        result=await get_service().compile.list_configs(ctx, limit=limit, cursor=cursor),
    )


@router.get("/compile/operations")
async def list_compile_operations(
    to: str = Query(..., min_length=1),
    limit: int = Query(20, ge=1, le=100),
    cursor: str | None = Query(None),
    ctx: RequestContext = Depends(get_request_context),
):
    result = await get_service().compile.list_operations(to, ctx, limit=limit, cursor=cursor)
    return Response(status="ok", result=result)


@router.get("/compile/operations/{operation_id}/outputs")
async def operation_outputs(
    operation_id: str = Path(
        ..., min_length=1, max_length=128, pattern=r"^[A-Za-z0-9][A-Za-z0-9:._-]*$"
    ),
    to: str = Query(..., min_length=1),
    limit: int = Query(20, ge=1, le=100),
    cursor: str | None = Query(None),
    ctx: RequestContext = Depends(get_request_context),
):
    """List one operation's output files and frozen version references."""
    return Response(
        status="ok",
        result=await get_service().compile.operation_outputs(
            to, operation_id, ctx, limit=limit, cursor=cursor
        ),
    )


@router.get("/compile/capabilities")
async def compile_capabilities(ctx: RequestContext = Depends(get_request_context)):
    return Response(status="ok", result=get_service().compile.capabilities(ctx))


@router.get("/compile/submissions/{key}")
async def get_submission(
    key: str = Path(..., min_length=16, max_length=128, pattern=r"^[A-Za-z0-9:._-]+$"),
    ctx: RequestContext = Depends(get_request_context),
):
    from openviking.service.external_task_service import submission_task_id
    from openviking.service.task_tracker import get_task_tracker
    from openviking_cli.exceptions import NotFoundError

    task_id = submission_task_id(ctx, "compile", "cmp_", key)
    task = await get_task_tracker().get(
        task_id, account_id=ctx.account_id, user_id=ctx.user.user_id
    )
    if task is None:
        raise NotFoundError(key, "submission")
    return Response(status="ok", result=task.to_dict())


class CompileEmbeddingRequest(BaseModel):
    """Transient Compile routing text; an empty batch requests model identity only."""

    model_config = ConfigDict(extra="forbid")
    target_uri: str
    texts: list[str] = Field(default_factory=list, max_length=32)
    expected_model: str | None = None

    @model_validator(mode="after")
    def bound_text(self):
        """Bound each routing description and the total before contacting the provider."""
        if any(not text.strip() or len(text) > 1024 for text in self.texts):
            raise ValueError("Compile embedding texts require 1..1024 characters")
        return self


@router.post("/compile/embeddings")
async def compile_embeddings(
    request: CompileEmbeddingRequest,
    _ctx: RequestContext = Depends(get_request_context),
):
    """Embed task-local routing candidates without indexing or retaining their content.

    Target validation uses the same tenant identity and ACL checks as file reads.
    The configured embedder supplies provider concurrency/rate controls. Only model
    identity and vectors cross the Bot/Server boundary; credentials never do.
    """
    from openviking.core.namespace import classify_uri
    from openviking.models.embedder.base import embed_compat

    target = validate_request_viking_uri(resolve_path_variables(request.target_uri), _ctx)
    classification = classify_uri(target)
    if classification.context_type != "resource" and not classification.is_skill_namespace:
        raise InvalidArgumentError(
            "Compile embeddings require a resource or Skill namespace target"
        )
    fs = get_service().viking_fs
    await fs.stat(target, ctx=_ctx, skip_count=True)
    embedder = fs._get_embedder(_ctx)
    # The account's effective embedding settings identify task-local cached vectors.
    model = (await get_service().embedding_provider.get_status(_ctx.account_id)).fingerprint
    if request.expected_model and request.expected_model != model:
        raise InvalidArgumentError("Compile embedding model changed during the task")
    # Small chunks also bound providers whose embed_async implementation has no limiter.
    vectors = []
    for start in range(0, len(request.texts), 4):
        batch = await asyncio.gather(
            *(embed_compat(embedder, text) for text in request.texts[start : start + 4])
        )
        for result in batch:
            vector = result.dense_vector
            if not vector or len(vector) > 8192 or not all(math.isfinite(x) for x in vector):
                raise InvalidArgumentError("Compile requires finite dense embedding vectors")
            vectors.append(vector)
    return Response(status="ok", result={"model": model, "vectors": vectors}).model_dump()