kiapi 0.1.0__py3-none-any.whl

kiapi/api/jobs/router.py

@@ -0,0 +1,62 @@
+"""Jobs API: list / get / delete. Every generation (sync or async) is a job."""
+
+from fastapi import APIRouter, Depends, HTTPException
+
+from kiapi.api import REQUIRE_AUTH, get_ctx
+from kiapi.core.app import AppContext
+from kiapi.core.job import Job, JobID, JobStatus
+
+from ._operations.get_job_id import get_job_id
+from ._views.job_delete_response import JobDeleteResponse
+from ._views.job_list_response import JobListResponse
+
+router = APIRouter(prefix="/v1/jobs", dependencies=REQUIRE_AUTH)
+
+
+@router.get("", response_model=JobListResponse)
+async def list_jobs(ctx: AppContext = Depends(get_ctx)) -> dict:
+    """List in-memory jobs.
+
+    Every generation request creates a job, including sync requests. Jobs are
+    useful for progress polling, result inspection, and discovering artifact
+    file_ids. They are not persisted across process restarts.
+    """
+    return {"object": "list", "data": [j.to_dict() for j in ctx.job_store.list_all()]}
+
+
+@router.get("/{job_id}", response_model=Job)
+async def get_job(
+    job_id: JobID = Depends(get_job_id),
+    ctx: AppContext = Depends(get_ctx),
+) -> dict:
+    """Get a job's status, progress, result, and artifacts.
+
+    Poll this endpoint after an async response or after a sync request times
+    out. When status is succeeded, artifact file ids can be downloaded through
+    the Files API.
+    """
+    job = ctx.job_store.get(job_id)
+    if job is None:
+        raise HTTPException(status_code=404, detail=f"unknown job {job_id!r}")
+    return job.to_dict()
+
+
+@router.delete("/{job_id}", response_model=JobDeleteResponse)
+async def delete_job(
+    job_id: JobID = Depends(get_job_id),
+    ctx: AppContext = Depends(get_ctx),
+) -> dict:
+    """Remove a job record from the in-memory store.
+
+    Queued jobs are forgotten and effectively canceled. A running job cannot be
+    interrupted; deleting it only removes the record, and generated files are
+    managed separately by the Files API.
+    """
+    job = ctx.job_store.get(job_id)
+    if job is None:
+        raise HTTPException(status_code=404, detail=f"unknown job {job_id!r}")
+    # A running job cannot be interrupted (MLX/generation is not preemptible);
+    # deleting it just forgets it. Queued jobs are effectively canceled.
+    running = job.status == JobStatus.RUNNING
+    ctx.job_store.delete(job_id)
+    return {"deleted": True, "job_id": job_id, "was_running": running}

kiapi/api/models/_schemas/openai_model_spec.py

@@ -0,0 +1,26 @@
+from pydantic import BaseModel, Field
+
+
+class OpenAIModelSpec(BaseModel):
+    """An OpenAI-compatible model spec (one entry in a model list)."""
+
+    id: str = Field(
+        ...,
+        description="Model name to pass in the chat request model field.",
+        examples=["qwen3-omni"],
+    )
+    object: str = Field(
+        default="model",
+        description="OpenAI-compatible object marker.",
+        examples=["model"],
+    )
+    created: int = Field(
+        ...,
+        description="Unix timestamp (seconds) for when the model became available.",
+        examples=[1735689600],
+    )
+    owned_by: str = Field(
+        default="kiapi",
+        description="Owner marker for OpenAI-compatible model lists.",
+        examples=["kiapi"],
+    )

kiapi/api/models/_views/model_list_response.py

@@ -0,0 +1,15 @@
+from pydantic import BaseModel, Field
+
+from .._schemas.openai_model_spec import OpenAIModelSpec
+
+
+class ModelListResponse(BaseModel):
+    object: str = Field(
+        default="list",
+        description="OpenAI-style list envelope marker.",
+        examples=["list"],
+    )
+    data: list[OpenAIModelSpec] = Field(
+        default_factory=list,
+        description="Chat models available via the OpenAI-compatible /v1/models endpoint.",
+    )

kiapi/api/models/router.py

@@ -0,0 +1,29 @@
+import time
+
+from fastapi import APIRouter
+
+from kiapi.core.model import model_registry
+
+from ._schemas.openai_model_spec import OpenAIModelSpec
+from ._views.model_list_response import ModelListResponse
+
+router = APIRouter()
+
+# Stable per-process timestamp used for the OpenAI-compatible ``created`` field;
+# kiapi models don't carry a real creation date, so we report server start.
+_CREATED = int(time.time())
+
+
+@router.get("/v1/models", response_model=ModelListResponse)
+async def list_openai_compatible_chat_models() -> ModelListResponse:
+    """List OpenAI-compatible chat models.
+
+    Returns the OpenAI /v1/models shape so OpenAI chat clients work unchanged.
+    Other capabilities expose richer, family-specific model lists at
+    /v1/{domain}/{family}/models.
+    """
+    data = [
+        OpenAIModelSpec(id=spec.name, created=_CREATED)
+        for spec in model_registry.list_specs("chat")
+    ]
+    return ModelListResponse(data=data)

kiapi/api/video/ltx2/_views/__init__.py

@@ -0,0 +1 @@
+"""API response views for the LTX-2 video endpoints."""

kiapi/api/video/ltx2/_views/video_response.py

@@ -0,0 +1,59 @@
+"""``/v1/video/ltx2/generate`` result payload (the Job ``result`` shape).
+
+Mirrors the dict returned by ``capabilities/ltx2/_models/ltx2.run_generate`` so
+the MP4 result is self-describing in OpenAPI. It is an output-side projection of
+the model result, so it lives under ``api/video/ltx2/_views``.
+"""
+
+from typing import Any, Literal
+
+from pydantic import BaseModel, Field
+
+
+class _Timings(BaseModel):
+    total_s: float = Field(
+        description="Wall-clock generation time in seconds (model run only)."
+    )
+
+
+class VideoResponse(BaseModel):
+    """Capability-specific ``result`` for a succeeded LTX-2 generation job."""
+
+    file_id: str = Field(
+        description=(
+            "Files-API id of the produced MP4. Fetch metadata at GET /v1/files/{id} "
+            "or bytes at /download. This is also the artifact returned as raw "
+            "bytes by a single-artifact sync call."
+        )
+    )
+    video_bytes: int = Field(description="Size of the produced MP4 in bytes.")
+
+    mode: Literal[
+        "T2V",
+        "I2V",
+        "I2V(first+last)",
+        "I2V(last)",
+        "A2V",
+        "A2V+I2V",
+        "T2V+Audio",
+    ] = Field(
+        description=(
+            "Detected generation mode, inferred from image/end_image/audio inputs "
+            "and `generate_audio`."
+        )
+    )
+    prompt: str = Field(description="Prompt used for the generation.")
+    params: dict[str, Any] = Field(
+        description=(
+            "Resolved parameters actually used for the run (prompt, dimensions, "
+            "frame count, fps, seed, conditioning strengths, and generate_audio), "
+            "so the result is reproducible."
+        )
+    )
+    has_audio: bool = Field(
+        description=(
+            "Whether an auxiliary audio track was produced or supplied and muxed "
+            "into the MP4."
+        )
+    )
+    timings: _Timings = Field(description="kiapi extension: server-side timing.")

kiapi/api/video/ltx2/router.py

@@ -0,0 +1,89 @@
+"""Video API (ltx2): ``POST /v1/video/ltx2/generate`` (JSON; sync or async)."""
+
+from fastapi import APIRouter, Depends, HTTPException
+from fastapi.responses import Response
+
+from kiapi.api import (
+    REQUIRE_AUTH,
+    build_job_responses,
+    get_accept,
+    get_ctx,
+    get_worker,
+    register_capability_endpoints,
+    submit_and_maybe_wait,
+)
+from kiapi.capabilities.ltx2 import (
+    GenerateRequest,
+    ValidationError,
+    detect_mode,
+    handle_generate,
+    validate_generate,
+)
+from kiapi.core.app import AppContext
+from kiapi.core.model import UnknownModelError, model_registry
+from kiapi.core.worker import Worker
+
+from ._views.video_response import VideoResponse
+
+router = APIRouter(dependencies=REQUIRE_AUTH)
+
+
+@router.post(
+    "/v1/video/ltx2/generate",
+    responses=build_job_responses("video/mp4", result_model=VideoResponse),
+)
+async def generate(
+    req: GenerateRequest,
+    accept: str | None = Depends(get_accept),
+    ctx: AppContext = Depends(get_ctx),
+    worker: Worker = Depends(get_worker),
+) -> Response:
+    """Generate a short MP4 with LTX-2 distilled (text/image/audio to video).
+
+    The mode is inferred from supplied inputs: prompt only is T2V; `image` adds
+    first-frame I2V; `end_image` adds last-frame conditioning; `audio` drives A2V
+    timing/motion; and `generate_audio=true` asks LTX-2 to synthesize audio. The
+    same endpoint serves both `sync` and `async` via `mode`.
+
+    Sync content negotiation: the job produces one MP4 artifact, so unless the
+    client asks for JSON the raw video bytes are returned with
+    `X-Kiapi-File-Id` / `X-Kiapi-Job-Id` headers. With
+    `Accept: application/json` (or async), the Job JSON is returned, whose
+    `result` follows VideoResponse.
+
+    LTX-2 is a transient model: each call reserves the configured memory budget,
+    loads the pipeline, generates, and frees it instead of keeping a resident
+    model in `/health`. Async returns 202 immediately; poll
+    GET /v1/jobs/{job_id} and fetch the artifact via GET /v1/files/{file_id}.
+    """
+    try:
+        spec = model_registry.resolve("ltx2", req.model)
+    except UnknownModelError as exc:
+        raise HTTPException(status_code=400, detail=str(exc))  # noqa: B904
+    try:
+        validate_generate(req, variant=spec.name, has_audio=req.audio is not None)
+    except ValidationError as exc:
+        raise HTTPException(status_code=422, detail=str(exc))  # noqa: B904
+
+    mode = detect_mode(
+        has_image=req.image is not None,
+        has_end_image=req.end_image is not None,
+        has_audio=req.audio is not None,
+        generate_audio=req.generate_audio,
+    )
+
+    def thunk():  # type: ignore
+        return handle_generate(ctx, req, mode)
+
+    return await submit_and_maybe_wait(
+        ctx,
+        worker,
+        type="ltx2",
+        params=req.gen_params() | {"model": spec.name, "mode_detected": mode},
+        thunk=thunk,
+        mode=req.mode,
+        accept=accept,
+    )
+
+
+register_capability_endpoints(router, name="ltx2", base_path="/v1/video/ltx2")

kiapi/api/web/_views/__init__.py

@@ -0,0 +1,7 @@
+from .fetch_api_request import FetchAPIRequest
+from .fetch_error_response import FetchErrorResponse
+
+__all__ = [
+    "FetchAPIRequest",
+    "FetchErrorResponse",
+]

kiapi/api/web/_views/fetch_api_request.py

@@ -0,0 +1,26 @@
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class FetchAPIRequest(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    url: str = Field(
+        ...,
+        min_length=1,
+        description=(
+            "Absolute `http://` or `https://` URL of an HTML page to render. "
+            "Binary resources such as images, audio, video, archives, and PDFs "
+            "are rejected with `not_html`; use the Files API for stored artifacts."
+        ),
+        examples=["https://example.com/"],
+    )
+    accept: str | None = Field(
+        default=None,
+        description=(
+            "Requested output media type. `application/pdf` returns a PDF. "
+            "`text/markdown`, `text/plain`, `text/*`, `*/*`, browser default "
+            "headers, or an omitted header return Markdown. Other concrete media "
+            "types such as `application/json` are rejected with HTTP 406."
+        ),
+        examples=["text/markdown", "application/pdf"],
+    )

kiapi/api/web/_views/fetch_error_response.py

@@ -0,0 +1,25 @@
+from pydantic import BaseModel, Field
+
+
+class _FetchErrorDetail(BaseModel):
+    error: str = Field(
+        description=(
+            "Stable error code such as `unsupported_accept`, `invalid_request`, "
+            "`not_html`, `empty_content`, or `fetch_failed`."
+        )
+    )
+    message: str = Field(description="Human-readable error detail.")
+    url: str = Field(description="URL submitted to `/v1/web/fetch`.")
+    content_type: str | None = Field(
+        default=None,
+        description=(
+            "Detected upstream Content-Type when known. Present for non-HTML "
+            "resources and some fetch failures."
+        ),
+    )
+
+
+class FetchErrorResponse(BaseModel):
+    detail: _FetchErrorDetail = Field(
+        description="Structured fetch error payload returned by FastAPI."
+    )

kiapi/api/web/router.py

@@ -0,0 +1,302 @@
+"""Web API (web): ``POST /v1/web/search`` + ``GET /v1/web/fetch``.
+
+``fetch`` selects its output format from the ``Accept`` header (``text/markdown``
+default, ``application/pdf``) and returns the rendered page as a raw body, in the
+generation families' raw-bytes-by-default style; errors come back as JSON.
+"""
+
+import asyncio
+from typing import Annotated
+
+from fastapi import APIRouter, Depends, Header, HTTPException, Query, Response
+from fastapi.responses import FileResponse
+from pydantic import ValidationError as PydanticValidationError
+
+from kiapi.api import (
+    REQUIRE_AUTH,
+    get_ctx,
+    get_worker,
+    register_capability_endpoints,
+)
+from kiapi.api._settings import settings_manager
+from kiapi.api.web._views import FetchAPIRequest, FetchErrorResponse
+from kiapi.capabilities.web import (
+    FetchError,
+    FetchRequest,
+    SearchBackendError,
+    SearchRequest,
+    SearchResponse,
+    handle_fetch,
+    handle_search,
+)
+from kiapi.core.app import AppContext
+from kiapi.core.memory import MemoryBudgetError
+from kiapi.core.model import UnknownModelError
+from kiapi.core.setup import SetupRequiredError
+from kiapi.core.worker import Worker
+
+router = APIRouter(dependencies=REQUIRE_AUTH)
+
+
+def fetch_api_request(
+    url: Annotated[
+        str,
+        Query(
+            min_length=1,
+            description=(
+                "Absolute http:// or https:// URL of an HTML page to fetch. "
+                "Non-HTML resources such as images, audio, video, archives, and "
+                "PDFs are rejected with `not_html`."
+            ),
+            examples=["https://example.com/"],
+        ),
+    ],
+    accept: Annotated[
+        str | None,
+        Header(
+            alias="Accept",
+            description=(
+                "Requested output media type. application/pdf returns PDF; "
+                "text/markdown, text/plain, text/*, */*, browser default "
+                "headers, or an omitted header return Markdown. application/json "
+                "and other incompatible concrete media types return HTTP 406."
+            ),
+            examples=["text/markdown", "application/pdf"],
+        ),
+    ] = None,
+) -> FetchAPIRequest:
+    return FetchAPIRequest(url=url, accept=accept)
+
+
+@router.post(
+    "/v1/web/search",
+    response_model=SearchResponse,
+    responses={
+        400: {"description": "Unknown web model or invalid model selection."},
+        422: {"description": "Request schema or validation error."},
+        502: {
+            "description": "SearXNG backend was unreachable or returned an HTTP error."
+        },
+        503: {
+            "description": "Backend Docker image is not activated or memory budget is exhausted."
+        },
+        504: {
+            "description": "SearXNG or the sync job exceeded the configured timeout."
+        },
+    },
+)
+async def search_web(
+    req: SearchRequest,
+    ctx: AppContext = Depends(get_ctx),
+    worker: Worker = Depends(get_worker),
+) -> dict:
+    """Search the live web with SearXNG and return JSON results.
+
+    The request body maps to SearXNG's search parameters. `query` is passed
+    through verbatim, so SearXNG inline operators such as `site:`, `!wp`,
+    `!images`, and language operators like `:ja` work normally. `format=json` is
+    always added by kiapi.
+
+    This endpoint is synchronous from the client's perspective: it waits up to
+    `KIAPI_SYNC_TIMEOUT_S` and returns `SearchResponse`. Internally it still
+    creates a Job and runs through the single-flight worker so web backends share
+    the same queue, setup checks, and resident subprocess lifecycle as other
+    capabilities.
+
+    Results are live and non-deterministic. `results` is optionally truncated by
+    `max_results`, while `answers`, `infoboxes`, `suggestions`, and
+    `unresponsive_engines` are forwarded from SearXNG without truncation.
+    """
+    settings = settings_manager.get_settings()
+
+    job = ctx.job_store.create(type="web.search", params=req.model_dump(mode="json"))
+    fut = await worker.submit(job, lambda: handle_search(ctx, req))
+
+    try:
+        return await asyncio.wait_for(fut, timeout=settings.sync_timeout_s)
+    except TimeoutError:
+        raise HTTPException(  # noqa: B904
+            status_code=504,
+            detail=f"web.search job {job.id} exceeded sync timeout "
+            f"({settings.sync_timeout_s}s); it keeps running - poll /v1/jobs/{job.id}",
+        )
+    except SearchBackendError as exc:
+        raise HTTPException(status_code=exc.status_code, detail=str(exc))  # noqa: B904
+    except UnknownModelError as exc:
+        raise HTTPException(status_code=400, detail=str(exc))  # noqa: B904
+    except SetupRequiredError as exc:
+        raise HTTPException(status_code=503, detail=str(exc))  # noqa: B904
+    except MemoryBudgetError as exc:
+        raise HTTPException(status_code=503, detail=str(exc))  # noqa: B904
+    except Exception as exc:
+        raise HTTPException(status_code=500, detail=f"web.search failed: {exc}")  # noqa: B904
+
+
+def _negotiate_format(accept: str | None) -> str | None:
+    """Map the Accept header to a fetch format, or None if unacceptable.
+
+    ``application/pdf`` → ``pdf``; markdown/text/wildcard/absent → ``markdown``
+    (the default); a concrete incompatible type (e.g. ``application/json``) → None.
+    """
+    if accept is None:
+        return "markdown"
+    a = accept.lower()
+    if "application/pdf" in a:
+        return "pdf"
+    if any(t in a for t in ("text/markdown", "text/plain", "text/*", "*/*")):
+        return "markdown"
+    return None
+
+
+@router.get(
+    "/v1/web/fetch",
+    responses={
+        200: {
+            "description": (
+                "Rendered page body. Markdown is returned by default; PDF is "
+                "returned when the Accept header allows application/pdf."
+            ),
+            "content": {
+                "text/markdown": {"schema": {"type": "string"}},
+                "application/pdf": {"schema": {"type": "string", "format": "binary"}},
+            },
+            "headers": {
+                "X-Kiapi-Url": {
+                    "description": "Fetched URL recorded on the stored artifact.",
+                    "schema": {"type": "string"},
+                },
+                "X-Kiapi-File-Id": {
+                    "description": "Files-API id of the rendered Markdown or PDF artifact.",
+                    "schema": {"type": "string"},
+                },
+                "X-Kiapi-Job-Id": {
+                    "description": "Job id created for the fetch operation.",
+                    "schema": {"type": "string"},
+                },
+                "X-Kiapi-Content-Type": {
+                    "description": "Detected upstream page Content-Type, when known.",
+                    "schema": {"type": "string"},
+                },
+            },
+        },
+        406: {
+            "model": FetchErrorResponse,
+            "description": "Accept header does not allow Markdown or PDF.",
+        },
+        422: {
+            "model": FetchErrorResponse,
+            "description": "Invalid URL, non-HTML resource, or empty rendered content.",
+        },
+        502: {
+            "model": FetchErrorResponse,
+            "description": "Target URL or Crawl4AI backend was unreachable or returned an HTTP error.",
+        },
+        503: {
+            "description": "Backend Docker image is not activated or memory budget is exhausted."
+        },
+        504: {
+            "description": "Crawl4AI or the sync job exceeded the configured timeout."
+        },
+    },
+)
+async def fetch_web(
+    api_req: FetchAPIRequest = Depends(fetch_api_request),
+    ctx: AppContext = Depends(get_ctx),
+    worker: Worker = Depends(get_worker),
+) -> Response:
+    """Render one HTML page to Markdown or PDF and stream the raw body.
+
+    `url` is supplied as a query parameter. The router resolves the `Accept`
+    header to the capability request's internal `format`: `application/pdf`
+    selects PDF; Markdown-compatible, text-compatible, wildcard, browser default,
+    or omitted Accept headers select Markdown. Incompatible concrete media types
+    return HTTP 406 with a structured JSON error.
+
+    Fetch performs a cheap preflight check before rendering. Non-HTML resources
+    are rejected with `not_html`; pages that render to no extractable text are
+    rejected with `empty_content`. Successful bodies are stored in the Files API
+    and streamed back directly with `X-Kiapi-File-Id`, `X-Kiapi-Job-Id`, and
+    upstream `X-Kiapi-Content-Type` headers when available.
+    """
+    settings = settings_manager.get_settings()
+    fmt = _negotiate_format(api_req.accept)
+    if fmt is None:
+        raise HTTPException(
+            status_code=406,
+            detail={
+                "error": "unsupported_accept",
+                "message": "Accept must allow text/markdown or application/pdf.",
+                "url": api_req.url,
+            },
+        )
+
+    try:
+        req = FetchRequest(url=api_req.url, format=fmt)  # type: ignore[arg-type]
+    except PydanticValidationError as exc:
+        # Keep the fetch error envelope and stay JSON-serializable: a custom
+        # field_validator raises ValueError, whose object pydantic stashes in
+        # each error's ``ctx`` — passing exc.errors() straight through would
+        # 500 on encoding. Surface the human-readable messages only.
+        raise HTTPException(  # noqa: B904
+            status_code=422,
+            detail={
+                "error": "invalid_request",
+                "message": "; ".join(e["msg"] for e in exc.errors()),
+                "url": api_req.url,
+            },
+        )
+
+    job = ctx.job_store.create(type="web.fetch", params=req.model_dump(mode="json"))
+    fut = await worker.submit(job, lambda: handle_fetch(ctx, req))
+
+    try:
+        result = await asyncio.wait_for(fut, timeout=settings.sync_timeout_s)
+    except FetchError as exc:
+        raise HTTPException(  # noqa: B904
+            status_code=exc.status_code,
+            detail={
+                "error": exc.code,
+                "message": str(exc),
+                "url": api_req.url,
+                "content_type": exc.content_type,
+            },
+        )
+    except TimeoutError:
+        raise HTTPException(  # noqa: B904
+            status_code=504,
+            detail=f"web.fetch job {job.id} exceeded sync timeout "
+            f"({settings.sync_timeout_s}s); it keeps running - poll /v1/jobs/{job.id}",
+        )
+    except UnknownModelError as exc:
+        raise HTTPException(status_code=400, detail=str(exc))  # noqa: B904
+    except SetupRequiredError as exc:
+        raise HTTPException(status_code=503, detail=str(exc))  # noqa: B904
+    except MemoryBudgetError as exc:
+        raise HTTPException(status_code=503, detail=str(exc))  # noqa: B904
+    except Exception as exc:
+        raise HTTPException(status_code=500, detail=f"web.fetch failed: {exc}")  # noqa: B904
+
+    file_id = result["file_id"]
+    rec = ctx.file_store.get(file_id)
+    if rec is None:
+        raise HTTPException(
+            status_code=500,
+            detail=f"web.fetch produced missing artifact {file_id!r}",
+        )
+
+    headers = {
+        "X-Kiapi-Url": result["url"],
+        "X-Kiapi-File-Id": file_id,
+        "X-Kiapi-Job-Id": job.id,
+    }
+    if result.get("content_type"):
+        headers["X-Kiapi-Content-Type"] = result["content_type"]
+    return FileResponse(
+        rec.path,
+        media_type=rec.content_type,
+        filename=rec.filename,
+        headers=headers,
+    )
+
+
+register_capability_endpoints(router, name="web", base_path="/v1/web")

kiapi/capabilities/__init__.py

@@ -0,0 +1,24 @@
+"""Family packages — one subpackage per family (dir == family).
+
+Each family exposes a ``register()`` that populates the global model + help
+registries (see core/model, core/help). Registration is explicit, not an import
+side effect: the CLI bootstrap calls each family's ``register`` before starting
+the API server or running setup/check commands.
+
+Shared building blocks reused across families live here too: the common
+request-error types and the Files-API path resolver.
+"""
+
+from ._exceptions.CapabilityError import CapabilityError
+from ._exceptions.ValidationError import ValidationError
+from ._helpers.attach_mflux_progress import attach_mflux_progress
+from ._helpers.get_file_path import get_file_path
+from ._helpers.resolve_file_ref import resolve_file_ref
+
+__all__ = [
+    "CapabilityError",
+    "ValidationError",
+    "attach_mflux_progress",
+    "get_file_path",
+    "resolve_file_ref",
+]

kiapi/capabilities/_exceptions/CapabilityError.py

@@ -0,0 +1,2 @@
+class CapabilityError(ValueError):
+    """Bad request detected at service time."""