@larkup/tool-video-intelligence 0.2.0

package/dist/ui.js

@@ -0,0 +1,87 @@
+export const VIDEO_INDEXING_BRIEF_SURFACE = {
+    id: 'video-indexing-brief',
+    version: 1,
+    slot: 'data-indexing',
+    title: 'Let your AI understand this video',
+    description: 'Choose how deeply to analyze it and optionally point it to what matters most.',
+    appliesTo: ['video'],
+    estimate: {
+        modeField: 'indexingMode',
+        variants: [
+            {
+                value: 'fast',
+                analyzedFramesPerSourceMinute: 5,
+                ocrFramesPerSourceMinute: 3,
+                processingSecondsPerSourceMinute: 4,
+                maxProcessingSecondsPerSourceMinute: 5,
+                fixedOverheadSeconds: 60,
+                maxFixedOverheadSeconds: 60,
+                creditsPerSourceMinute: 1,
+            },
+            {
+                value: 'balanced',
+                analyzedFramesPerSourceMinute: 12,
+                ocrFramesPerSourceMinute: 8,
+                processingSecondsPerSourceMinute: 16,
+                maxProcessingSecondsPerSourceMinute: 30,
+                fixedOverheadSeconds: 120,
+                maxFixedOverheadSeconds: 240,
+                creditsPerSourceMinute: 2,
+            },
+            {
+                value: 'thorough',
+                analyzedFramesPerSourceMinute: 30,
+                ocrFramesPerSourceMinute: 20,
+                processingSecondsPerSourceMinute: 32,
+                maxProcessingSecondsPerSourceMinute: 60,
+                fixedOverheadSeconds: 180,
+                maxFixedOverheadSeconds: 360,
+                creditsPerSourceMinute: 4,
+            },
+        ],
+    },
+    form: {
+        submitLabel: 'Start indexing',
+        fields: [
+            {
+                key: 'goal',
+                type: 'textarea',
+                label: 'What should your AI look for? (optional)',
+                placeholder: 'For example: find the final score, the moment the package is dropped, or every mention of pricing.',
+            },
+            {
+                key: 'indexingMode',
+                type: 'select',
+                label: 'Coverage',
+                defaultValue: 'balanced',
+                options: [
+                    {
+                        label: 'Fast',
+                        value: 'fast',
+                        description: 'Sample key frames for a quick overview.',
+                        setValues: { processingAuthorityConfirmed: false },
+                    },
+                    {
+                        label: 'Balanced',
+                        value: 'balanced',
+                        description: 'Sample visual and OCR evidence across the video.',
+                        setValues: { processingAuthorityConfirmed: false },
+                    },
+                    {
+                        label: 'Thorough',
+                        value: 'thorough',
+                        description: 'Let the agent inspect denser evidence around subtle or infrequent details.',
+                        setValues: { processingAuthorityConfirmed: false },
+                    },
+                ],
+            },
+        ],
+    },
+};
+export const VIDEO_JOB_RESULT_SURFACE = {
+    id: 'video-evidence-result',
+    version: 1,
+    slot: 'chat-result',
+    title: 'Video evidence',
+    resultType: 'application/vnd.larkup.video-evidence+json;version=1',
+};

package/package.json

@@ -0,0 +1,84 @@
+{
+  "name": "@larkup/tool-video-intelligence",
+  "version": "0.2.0",
+  "type": "module",
+  "description": "Installable local and cloud video intelligence with evidence-first indexing.",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./contracts": {
+      "types": "./dist/contracts.d.ts",
+      "import": "./dist/contracts.js",
+      "default": "./dist/contracts.js"
+    },
+    "./ui": {
+      "types": "./dist/ui.d.ts",
+      "import": "./dist/ui.js",
+      "default": "./dist/ui.js"
+    },
+    "./runtime": {
+      "types": "./dist/runtime.d.ts",
+      "import": "./dist/runtime.js",
+      "default": "./dist/runtime.js"
+    }
+  },
+  "bin": {
+    "larkup-video-intelligence": "./scripts/runtime.mjs"
+  },
+  "files": [
+    "dist",
+    "runtime/app",
+    "runtime/Dockerfile",
+    "runtime/pyproject.toml",
+    "runtime/uv.lock",
+    "runtime/requirements.txt",
+    "runtime/requirements-cpu.txt",
+    "runtime/requirements-smoke.txt",
+    "scripts",
+    ".env.example",
+    "compose.yaml",
+    "compose.gpu.yaml",
+    "tool.manifest.json",
+    "README.md"
+  ],
+  "peerDependencies": {
+    "@larkup/marketplace": ">=0.1.26"
+  },
+  "peerDependenciesMeta": {
+    "@larkup/marketplace": {
+      "optional": true
+    }
+  },
+  "dependencies": {
+    "@larkup/core": "0.5.0"
+  },
+  "devDependencies": {
+    "@types/node": "^26",
+    "typescript": "^7.0.2",
+    "vitest": "^4.1.10",
+    "@larkup/marketplace": "0.2.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Larkup-AI/larkup",
+    "directory": "packages/marketplace-tools/video-intelligence"
+  },
+  "scripts": {
+    "dev": "tsc --outDir dist --watch",
+    "build": "tsc --outDir dist",
+    "type-check": "tsc --noEmit",
+    "test": "vitest run",
+    "runtime:test": "cd runtime && uv run --extra cpu --extra test python -m unittest discover -s tests -p 'test_*.py'",
+    "runtime:start": "node scripts/runtime.mjs start",
+    "runtime:stop": "node scripts/runtime.mjs stop"
+  }
+}

package/runtime/Dockerfile

@@ -0,0 +1,119 @@
+FROM python:3.12-slim AS smoke
+
+WORKDIR /service
+RUN apt-get update \
+    && apt-get install -y --no-install-recommends ffmpeg \
+    && rm -rf /var/lib/apt/lists/*
+COPY runtime/requirements-smoke.txt ./requirements-smoke.txt
+RUN python3 -m pip install --no-cache-dir -r requirements-smoke.txt
+COPY runtime/app ./app
+ENV PYTHONUNBUFFERED=1 \
+    LARKUP_VIDEO_DATA_DIR=/data \
+    LARKUP_VIDEO_MODEL_DIR=/models \
+    LARKUP_VIDEO_DEVICE=cpu \
+    LARKUP_VIDEO_DISABLE_HEAVY_OPERATORS=true
+EXPOSE 8787
+CMD ["python3", "-m", "uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8787"]
+
+FROM python:3.12-slim AS cpu
+
+ARG YOLOX_MODEL_URL=https://github.com/Megvii-BaseDetection/YOLOX/releases/download/0.1.1rc0/yolox_s.onnx
+
+WORKDIR /service
+RUN apt-get update \
+    && apt-get install -y --no-install-recommends ffmpeg libgomp1 \
+    && rm -rf /var/lib/apt/lists/*
+COPY runtime/requirements-cpu.txt ./requirements-cpu.txt
+RUN python3 -m pip install --no-cache-dir --upgrade pip \
+    && python3 -m pip install --no-cache-dir -r requirements-cpu.txt \
+    && python3 -m pip install --no-cache-dir --no-deps rapidocr-onnxruntime==1.4.4
+RUN mkdir -p /models /data \
+    && python3 -c "import urllib.request; urllib.request.urlretrieve('$YOLOX_MODEL_URL', '/models/yolox_s.onnx')"
+COPY runtime/app ./app
+ENV PYTHONUNBUFFERED=1 \
+    LARKUP_VIDEO_DATA_DIR=/data \
+    LARKUP_VIDEO_MODEL_DIR=/models \
+    LARKUP_VIDEO_DEVICE=cpu \
+    LARKUP_VIDEO_OCR_ENGINE=RapidOCR
+EXPOSE 8787
+HEALTHCHECK --interval=15s --timeout=5s --retries=10 CMD python3 -c "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8787/v1/health', timeout=4)" || exit 1
+CMD ["python3", "-m", "uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8787"]
+
+# Blackwell workers require a CUDA 12.8-compatible runtime for onnxruntime-gpu
+# (YOLOX detection) and PaddleOCR. Vision captioning and video embeddings
+# are both HTTPS calls from app/services/ -- this image only ever runs
+# local decode/detect/OCR/transcribe.
+FROM nvidia/cuda:12.8.1-cudnn-runtime-ubuntu22.04 AS system
+
+ARG DEBIAN_FRONTEND=noninteractive
+ARG YOLOX_MODEL_URL=https://github.com/Megvii-BaseDetection/YOLOX/releases/download/0.1.1rc0/yolox_s.onnx
+
+RUN apt-get update \
+    && apt-get dist-upgrade -y \
+    && apt-get install -y --no-install-recommends ca-certificates curl ffmpeg libgomp1 python3 python3-pip \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /service
+
+FROM system AS runtime
+COPY runtime/requirements.txt ./requirements.txt
+RUN python3 -m pip install --no-cache-dir --upgrade pip \
+    && python3 -m pip install --no-cache-dir paddlepaddle==3.0.0 -i https://www.paddlepaddle.org.cn/packages/stable/cpu/ \
+    && python3 -m pip install --no-cache-dir -r requirements.txt
+
+RUN mkdir -p /models /data \
+    && curl --fail --location --retry 4 "$YOLOX_MODEL_URL" --output /models/yolox_s.onnx
+
+COPY runtime/app ./app
+
+ENV PYTHONUNBUFFERED=1 \
+    LARKUP_VIDEO_DATA_DIR=/data \
+    LARKUP_VIDEO_MODEL_DIR=/models \
+    LARKUP_VIDEO_DEVICE=auto \
+    LARKUP_VIDEO_SEMANTIC_VISION=true \
+    LARKUP_VIDEO_SEMANTIC_VISION_MODEL=google/gemini-3.6-flash \
+    LARKUP_VIDEO_EMBEDDING_PROVIDER=disabled \
+    LARKUP_VIDEO_EMBEDDING_FALLBACK_PROVIDER=disabled \
+    LARKUP_VIDEO_TRANSCRIPTION_PROVIDER="" \
+    LARKUP_VIDEO_TRANSCRIPTION_FALLBACK="" \
+    LARKUP_VIDEO_TRANSCRIPTION_CHUNK_SECONDS=300 \
+    LARKUP_VIDEO_TRANSCRIPTION_CONCURRENCY=6 \
+    LARKUP_VIDEO_TRANSCRIPTION_REQUEST_TIMEOUT_SECONDS=120 \
+    LARKUP_VIDEO_REQUIRE_AUTH=false
+
+EXPOSE 8787
+HEALTHCHECK --interval=15s --timeout=5s --retries=10 CMD curl -fsS http://127.0.0.1:8787/v1/health || exit 1
+CMD ["python3", "-m", "uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8787"]
+
+FROM runtime AS runpod
+
+# The RunPod entrypoint is deliberately kept out of runtime/app (and out of
+# the published npm package) -- see deploy/gpu_providers/README.md. It still
+# has to land inside the `app` package here because its imports and the
+# `python -m app.runpod_worker` entrypoint below both assume that. Only this
+# stage needs it: a local (non-RunPod) `runtime`-target build never imports it.
+COPY deploy/gpu_providers/runpod_worker_entrypoint.py ./app/runpod_worker.py
+COPY deploy/gpu_providers/remote_source.py ./app/remote_source.py
+COPY deploy/gpu_providers/progress.py ./app/progress.py
+
+# Fail the image build if the exact RunPod entrypoint cannot import. This
+# catches native-library and Python dependency failures before a worker is
+# scheduled, where logs are much harder to recover.
+RUN python3 -c "import cv2, runpod; from app.runpod_worker import handler; assert callable(handler)"
+
+# This stage is the immutable serverless image. Do not rely on a template
+# command override: it must start the worker even when deployed as-is.
+HEALTHCHECK NONE
+CMD ["python3", "-m", "app.runpod_worker"]
+
+FROM runtime AS cloud-worker
+
+# Shared image for the "rent-a-VM" providers (vast, shadeform, salad,
+# scaleway, thundercompute, gpuai, northflank, hyperstack): each just starts
+# this image with job-specific env vars, see deploy/gpu_providers/base.py.
+COPY deploy/gpu_providers/cloud_worker_entrypoint.py ./app/cloud_worker.py
+
+RUN python3 -c "import boto3; from app.cloud_worker import main; assert callable(main)"
+
+HEALTHCHECK NONE
+CMD ["python3", "-m", "app.cloud_worker"]

package/runtime/app/__init__.py

@@ -0,0 +1,3 @@
+"""Larkup Video Intelligence runtime."""
+
+__version__ = "0.1.0"

package/runtime/app/__main__.py

@@ -0,0 +1,19 @@
+"""Portable command-line entry point for the Video Intelligence API."""
+
+from __future__ import annotations
+
+import os
+
+import uvicorn
+
+
+def main() -> None:
+    uvicorn.run(
+        "app.main:app",
+        host=os.getenv("LARKUP_VIDEO_HOST", "0.0.0.0"),
+        port=int(os.getenv("LARKUP_VIDEO_PORT", "8787")),
+    )
+
+
+if __name__ == "__main__":
+    main()

package/runtime/app/api/deps.py

@@ -0,0 +1,69 @@
+"""Shared app state and FastAPI dependencies: settings, the store, the job
+runner, request-rate limiting, and principal/admin authentication. Built
+once here so main.py and v1.py both import the same instances.
+"""
+
+from __future__ import annotations
+
+import hmac
+import os
+import time
+from collections import defaultdict, deque
+
+from fastapi import HTTPException, Request, status
+
+from app.config import Settings
+from app.db.store import AuthenticationError, Principal, Store
+from app.services.jobs import JobService
+
+settings = Settings.from_env()
+store = Store(settings.data_dir / "video-intelligence.sqlite3")
+jobs = JobService(settings, store)
+
+
+class SlidingWindowLimiter:
+    def __init__(self, requests_per_minute: int):
+        self.limit = requests_per_minute
+        self.windows: defaultdict[str, deque[float]] = defaultdict(deque)
+
+    def check(self, key: str) -> None:
+        now = time.monotonic()
+        window = self.windows[key]
+        while window and window[0] <= now - 60:
+            window.popleft()
+        if len(window) >= self.limit:
+            raise HTTPException(
+                status_code=status.HTTP_429_TOO_MANY_REQUESTS,
+                detail="request rate limit reached; retry in one minute",
+                headers={"Retry-After": "60"},
+            )
+        window.append(now)
+
+
+limiter = SlidingWindowLimiter(max(1, int(os.getenv("LARKUP_VIDEO_REQUESTS_PER_MINUTE", "120"))))
+
+
+def _bearer(request: Request) -> str | None:
+    authorization = request.headers.get("authorization", "")
+    scheme, _, token = authorization.partition(" ")
+    return token.strip() if scheme.lower() == "bearer" and token.strip() else None
+
+
+def principal(request: Request) -> Principal:
+    token = _bearer(request)
+    forwarded = request.headers.get("x-forwarded-for", "").partition(",")[0].strip()
+    limiter.check(token or forwarded or request.client.host if request.client else "local")
+    try:
+        return store.resolve_principal(token, settings.require_auth, settings.shared_api_key)
+    except AuthenticationError as error:
+        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail=str(error)) from error
+
+
+def require_admin(token: str | None) -> None:
+    if not settings.admin_token:
+        raise HTTPException(
+            status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
+            detail="admin access-code management is not configured",
+        )
+    if not token or not hmac.compare_digest(token, settings.admin_token):
+        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="invalid admin token")

package/runtime/app/api/v1.py

@@ -0,0 +1,166 @@
+"""Every /v1 route: health, uploads, jobs, usage, and access codes.
+
+The local-Docker runtime's whole HTTP surface is small enough (eight
+endpoints) that splitting it across more files would cost more to navigate
+than it would save -- see api/deps.py for the auth/rate-limit dependencies
+these handlers use.
+"""
+
+from __future__ import annotations
+
+import os
+import secrets
+from pathlib import Path
+from typing import Annotated
+
+from fastapi import APIRouter, BackgroundTasks, Depends, File, Header, HTTPException, UploadFile
+from fastapi.responses import JSONResponse, Response
+
+from app.db.schemas import (
+    CreateAccessCodeRequest,
+    CreateAccessCodeResponse,
+    CreateJobRequest,
+    JobResponse,
+    RedeemAccessCodeRequest,
+    RedeemAccessCodeResponse,
+    UsageSummary,
+)
+from app.db.store import AuthenticationError, Principal, QuotaExceededError, StoreError
+from app.services.pipeline import probe_video
+from app.api.deps import jobs, limiter, principal, require_admin, settings, store
+
+router = APIRouter()
+
+
+@router.get("/v1/health")
+def health() -> dict[str, object]:
+    return {
+        "status": "ok",
+        "version": "0.1.0",
+        "runtime": os.getenv("LARKUP_VIDEO_RUNTIME_KIND", "local-docker"),
+        "authRequired": settings.require_auth,
+        "device": settings.device,
+        "operators": {
+            "transcription": os.getenv("LARKUP_VIDEO_TRANSCRIPTION_PROVIDER", "whisper"),
+            "ocr": os.getenv("LARKUP_VIDEO_OCR_ENGINE", "PaddleOCR"),
+            "detection": "YOLOX",
+            "tracking": "anonymous-iou",
+            "semanticVision": settings.semantic_vision_model if settings.semantic_vision_enabled else None,
+            "agentBrain": settings.agent_model if settings.agent_enabled else None,
+            "agentProvider": settings.agent_provider if settings.agent_enabled else None,
+        },
+        "capabilities": ["agent-planning", "transcription", "ocr", "object-detection", "semantic-vision"],
+    }
+
+
+@router.post("/v1/uploads", status_code=201)
+def upload_video(
+    user: Annotated[Principal, Depends(principal)],
+    file: Annotated[UploadFile, File()],
+) -> dict[str, object]:
+    upload_id = "upl_" + secrets.token_hex(12)
+    original_name = Path(file.filename or "video.bin").name
+    destination = settings.data_dir / "uploads" / user.id / f"{upload_id}{Path(original_name).suffix}"
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    size = 0
+    try:
+        with destination.open("wb") as output:
+            while chunk := file.file.read(1024 * 1024):
+                size += len(chunk)
+                if size > settings.max_upload_bytes:
+                    raise HTTPException(status_code=413, detail="video exceeds the configured upload limit")
+                output.write(chunk)
+        probe = probe_video(destination)
+        store.create_upload(user.id, upload_id, original_name, destination, size)
+        return {
+            "uploadId": upload_id,
+            "fileName": original_name,
+            "sizeBytes": size,
+            "durationMs": round(probe.duration_seconds * 1_000),
+        }
+    except Exception:
+        destination.unlink(missing_ok=True)
+        raise
+    finally:
+        file.file.close()
+
+
+@router.post("/v1/jobs", response_model=JobResponse, status_code=202)
+def create_job(
+    request: CreateJobRequest,
+    user: Annotated[Principal, Depends(principal)],
+    background_tasks: BackgroundTasks,
+) -> dict[str, object]:
+    upload = store.get_upload(user.id, request.source.upload_id)
+    probe = probe_video(Path(upload["path"]))
+    job_id = "job_" + secrets.token_hex(12)
+    payload = request.model_dump(by_alias=True)
+    model_configuration = payload.pop("modelConfiguration", None)
+    store.create_job(user, job_id, request.source.upload_id, payload, probe.duration_seconds / 60)
+    # Dispatch after the response commits. This avoids losing a local job
+    # during a container restart before the thread-pool worker starts.
+    background_tasks.add_task(jobs.run, job_id, model_configuration)
+    return store.get_job(user.id, job_id)
+
+
+@router.get("/v1/jobs/{job_id}", response_model=JobResponse)
+def get_job(job_id: str, user: Annotated[Principal, Depends(principal)]) -> dict[str, object]:
+    return store.get_job(user.id, job_id)
+
+
+@router.delete("/v1/jobs/{job_id}", response_model=JobResponse)
+def cancel_job(job_id: str, user: Annotated[Principal, Depends(principal)]) -> dict[str, object]:
+    store.cancel_job(user.id, job_id)
+    return store.get_job(user.id, job_id)
+
+
+@router.delete("/v1/jobs/{job_id}/data", response_class=Response)
+def purge_job_data(job_id: str, user: Annotated[Principal, Depends(principal)]) -> Response:
+    """Delete the local source/result cache after the host removes its media asset."""
+    store.purge_job_data(user.id, job_id)
+    return Response(status_code=204)
+
+
+@router.get("/v1/usage", response_model=UsageSummary)
+def usage(user: Annotated[Principal, Depends(principal)]) -> dict[str, object]:
+    return store.usage(user)
+
+
+@router.post("/v1/access-codes/redeem", response_model=RedeemAccessCodeResponse)
+def redeem_access_code(request: RedeemAccessCodeRequest) -> dict[str, object]:
+    limiter.check("redeem")
+    try:
+        api_key, entitlement = store.redeem_access_code(request.code, request.label)
+    except AuthenticationError as error:
+        raise HTTPException(status_code=401, detail=str(error)) from error
+    return {"apiKey": api_key, "entitlement": entitlement}
+
+
+@router.post("/v1/admin/access-codes", response_model=CreateAccessCodeResponse)
+def create_access_code(
+    request: CreateAccessCodeRequest,
+    admin_token: Annotated[str | None, Header(alias="X-Larkup-Admin-Token")] = None,
+) -> dict[str, object]:
+    require_admin(admin_token)
+    entitlement = {
+        "sourceMinutesPerMonth": request.source_minutes_per_month,
+        "maxConcurrentJobs": request.max_concurrent_jobs,
+        "plan": "access-code",
+    }
+    code = store.create_access_code(
+        label=request.label,
+        entitlement=entitlement,
+        max_uses=request.max_uses,
+        expires_at=request.expires_at,
+    )
+    return {"code": code, "label": request.label, "maxUses": request.max_uses, "expiresAt": request.expires_at}
+
+
+def register_exception_handlers(app) -> None:
+    @app.exception_handler(QuotaExceededError)
+    async def _quota_error(_: object, error: QuotaExceededError) -> JSONResponse:
+        return JSONResponse(status_code=429, content={"detail": str(error)}, headers={"Retry-After": "60"})
+
+    @app.exception_handler(StoreError)
+    async def _store_error(_: object, error: StoreError) -> JSONResponse:
+        return JSONResponse(status_code=404, content={"detail": str(error)})

package/runtime/app/config.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from pathlib import Path
+
+
+def _bool(name: str, default: bool) -> bool:
+    raw = os.getenv(name)
+    if raw is None:
+        return default
+    return raw.strip().lower() in {"1", "true", "yes", "on"}
+
+
+@dataclass(frozen=True)
+class Settings:
+    data_dir: Path
+    model_dir: Path
+    require_auth: bool
+    shared_api_key: str | None
+    admin_token: str | None
+    workers: int
+    device: str
+    allow_local_paths: bool
+    max_upload_bytes: int
+    disable_heavy_operators: bool
+    semantic_vision_enabled: bool
+    semantic_vision_model: str
+    reasoning_vision_model: str
+    agent_enabled: bool
+    agent_provider: str
+    agent_model: str
+    allowed_origins: tuple[str, ...]
+
+    @classmethod
+    def from_env(cls) -> "Settings":
+        data_dir = Path(os.getenv("LARKUP_VIDEO_DATA_DIR", "/data")).resolve()
+        model_dir = Path(os.getenv("LARKUP_VIDEO_MODEL_DIR", "/models")).resolve()
+        data_dir.mkdir(parents=True, exist_ok=True)
+        model_dir.mkdir(parents=True, exist_ok=True)
+        return cls(
+            data_dir=data_dir,
+            model_dir=model_dir,
+            require_auth=_bool("LARKUP_VIDEO_REQUIRE_AUTH", False),
+            shared_api_key=os.getenv("LARKUP_VIDEO_SHARED_API_KEY") or None,
+            admin_token=os.getenv("LARKUP_VIDEO_ADMIN_TOKEN") or None,
+            workers=max(1, min(8, int(os.getenv("LARKUP_VIDEO_WORKERS", "1")))),
+            device=os.getenv("LARKUP_VIDEO_DEVICE", "auto"),
+            allow_local_paths=_bool("LARKUP_VIDEO_ALLOW_LOCAL_PATHS", False),
+            max_upload_bytes=max(
+                1,
+                int(os.getenv("LARKUP_VIDEO_MAX_UPLOAD_BYTES", str(20 * 1024**3))),
+            ),
+            disable_heavy_operators=_bool("LARKUP_VIDEO_DISABLE_HEAVY_OPERATORS", False),
+            semantic_vision_enabled=_bool("LARKUP_VIDEO_SEMANTIC_VISION", True),
+            # Vercel AI Gateway model ids, not local HuggingFace paths -- both
+            # run entirely through gateway_vision.GatewayVisionClient, which
+            # reads these same env vars itself. Kept here too so /v1/health
+            # can report them. The bulk model captions every clip cheaply;
+            # the reasoning model is reserved for watch_original's final
+            # dense-verification pass, where accuracy matters more than cost.
+            semantic_vision_model=os.getenv(
+                "LARKUP_VIDEO_SEMANTIC_VISION_MODEL", "google/gemini-3.6-flash"
+            ),
+            reasoning_vision_model=os.getenv(
+                "LARKUP_VIDEO_REASONING_VISION_MODEL", "google/gemini-3.6-flash"
+            ),
+            agent_enabled=_bool("LARKUP_VIDEO_AGENT_ENABLED", True),
+            agent_provider=os.getenv("LARKUP_VIDEO_AGENT_PROVIDER", "vercel_ai_gateway"),
+            agent_model=os.getenv("LARKUP_VIDEO_AGENT_MODEL", "openai/gpt-5-mini"),
+            allowed_origins=tuple(
+                origin.strip()
+                for origin in os.getenv(
+                    "LARKUP_VIDEO_ALLOWED_ORIGINS", "http://localhost:3000"
+                ).split(",")
+                if origin.strip()
+            ),
+        )