aria-code 0.167.0__py3-none-win_amd64.whl

aria_code/providers/google_video_provider.py

@@ -0,0 +1,256 @@
+"""google_video_provider.py — Google Cloud Vertex AI & Gemini API Veo Video provider.
+
+Generates video clips via Google Cloud Veo 3.1:
+- veo-3.1-fast-generate-001 (default: faster and cheaper per second)
+- veo-3.1-generate-001 (higher quality)
+
+Checked against our production project on 2026-09-15: only the Veo 3.1 GA models are
+reachable; veo-3.0-* and veo-2.0-generate-001 return 404. Veo 3.1 accepts
+durations of 4, 6 or 8 seconds and aspect ratios 16:9 / 9:16, is served from a
+region (not "global"), and its long-running operation is read with
+:fetchPredictOperation.
+
+Dual authentication:
+1. Google Cloud Vertex AI: Uses ADC (Application Default Credentials) + VERTEX_PROJECT / GOOGLE_CLOUD_PROJECT
+2. Google AI Studio / Gemini API: Uses GEMINI_API_KEY or GOOGLE_API_KEY
+"""
+
+from __future__ import annotations
+
+import base64
+import logging
+import os
+import time
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+logger = logging.getLogger(__name__)
+
+DEFAULT_VEO_MODEL = "veo-3.1-fast-generate-001"
+QUALITY_VEO_MODEL = "veo-3.1-generate-001"
+VEO_DURATIONS = (4, 6, 8)
+
+
+def veo_duration(seconds: Any) -> int:
+    """The shortest duration Veo 3.1 accepts (4, 6 or 8 s) that covers `seconds`.
+
+    Rounding up: the edit trims a clip to its beat, but cannot stretch one.
+    """
+    try:
+        wanted = float(seconds)
+    except (TypeError, ValueError):
+        wanted = 6.0
+    return next((allowed for allowed in VEO_DURATIONS if allowed >= wanted), VEO_DURATIONS[-1])
+
+
+def veo_location() -> str:
+    """Veo runs in a region; the chat models' "global" location has no Veo endpoint."""
+    location = (os.getenv("VEO_LOCATION") or os.getenv("VERTEX_LOCATION") or "").strip()
+    return "us-central1" if not location or location == "global" else location
+
+
+def _video_bytes(payload: Dict[str, Any]) -> Optional[bytes]:
+    """The first video's bytes from a finished operation, in any of the shapes Veo has used."""
+    response = payload.get("response") or {}
+    items = response.get("videos") or response.get("predictions") or response.get("generatedSamples") or []
+    for item in items:
+        encoded = item.get("bytesBase64Encoded") or (item.get("video") or {}).get("bytesBase64Encoded")
+        if encoded:
+            return base64.b64decode(encoded)
+        gcs_uri = item.get("gcsUri") or (item.get("video") or {}).get("uri")
+        if gcs_uri and gcs_uri.startswith("gs://"):
+            try:
+                from google.cloud import storage
+
+                bucket, _, name = gcs_uri[5:].partition("/")
+                return storage.Client().bucket(bucket).blob(name).download_as_bytes()
+            except Exception as exc:  # noqa: BLE001
+                logger.warning(f"[GoogleVideo] Could not read {gcs_uri}: {exc}")
+    return None
+
+
+def has_google_video_config() -> bool:
+    """Return True if Google Cloud Vertex AI or Gemini API is configured for Veo."""
+    vertex_project = os.getenv("VERTEX_PROJECT") or os.getenv("GOOGLE_CLOUD_PROJECT", "")
+    api_key = os.getenv("GEMINI_API_KEY", "") or os.getenv("GOOGLE_API_KEY", "")
+    return bool(vertex_project or api_key)
+
+
+def _get_vertex_token() -> Optional[str]:
+    """Mint access token from Google Cloud ADC."""
+    try:
+        import google.auth
+        from google.auth.transport.requests import Request as GoogleAuthRequest
+
+        creds, _ = google.auth.default(
+            scopes=["https://www.googleapis.com/auth/cloud-platform"]
+        )
+        creds.refresh(GoogleAuthRequest())
+        return creds.token
+    except Exception as exc:
+        logger.debug(f"[GoogleVideo] ADC token unavailable: {exc}")
+        return None
+
+
+def generate_video_google(
+    prompt: str,
+    *,
+    image_path: Optional[str] = None,
+    model: str = DEFAULT_VEO_MODEL,
+    aspect_ratio: str = "16:9",
+    duration_seconds: int = 5,
+    poll_interval: float = 3.0,
+    max_wait_seconds: float = 180.0,
+) -> Dict[str, Any]:
+    """Generate video via Google Cloud Veo (text-to-video or image-to-video).
+
+    Returns {"success": True, "path": str, "model": str, "duration": int, ...} on success.
+    """
+    prompt = (prompt or "").strip()
+    if not prompt and not image_path:
+        return {"success": False, "error": "Prompt or image_path is required for video generation"}
+
+    if aspect_ratio not in {"16:9", "9:16"}:
+        aspect_ratio = "9:16" if aspect_ratio in {"3:4", "4:5", "2:3"} else "16:9"
+
+    duration_seconds = veo_duration(duration_seconds)
+
+    vertex_project = os.getenv("VERTEX_PROJECT") or os.getenv("GOOGLE_CLOUD_PROJECT", "")
+    api_key = os.getenv("GEMINI_API_KEY", "") or os.getenv("GOOGLE_API_KEY", "")
+
+    if not vertex_project and not api_key:
+        return {
+            "success": False,
+            "error": "Google Cloud credentials not found (set VERTEX_PROJECT with ADC, or GEMINI_API_KEY/GOOGLE_API_KEY).",
+        }
+
+    instance: Dict[str, Any] = {"prompt": prompt}
+    if image_path and Path(image_path).exists():
+        try:
+            img_bytes = Path(image_path).read_bytes()
+            suffix = Path(image_path).suffix.lower()
+            mime = "image/png" if suffix == ".png" else "image/webp" if suffix == ".webp" else "image/jpeg"
+            instance["image"] = {"bytesBase64Encoded": base64.b64encode(img_bytes).decode("ascii"), "mimeType": mime}
+        except Exception as exc:
+            logger.warning(f"[GoogleVideo] Failed to read source image {image_path}: {exc}")
+
+    body = {
+        "instances": [instance],
+        "parameters": {
+            "aspectRatio": aspect_ratio,
+            "durationSeconds": duration_seconds,
+            "sampleCount": 1,
+            # Narration and music are laid over by the edit; Veo's own audio
+            # would only be muted, and generating it costs more.
+            "generateAudio": False,
+        },
+    }
+
+    import requests
+
+    token = _get_vertex_token() if vertex_project else None
+    display_model = f"Google Cloud Veo 3.1 ({model})"
+    last_error = ""
+
+    # 1. Vertex AI long-running prediction, read back with :fetchPredictOperation.
+    if token and vertex_project:
+        location = veo_location()
+        base = f"https://{location}-aiplatform.googleapis.com/v1/projects/{vertex_project}/locations/{location}/publishers/google/models/{model}"
+        headers = {"Authorization": f"Bearer {token}", "Content-Type": "application/json"}
+        try:
+            resp = requests.post(f"{base}:predictLongRunning", headers=headers, json=body, timeout=30)
+            if resp.status_code in (200, 201, 202) and resp.json().get("name"):
+                op_name = resp.json()["name"]
+                start_time = time.time()
+                while time.time() - start_time < max_wait_seconds:
+                    time.sleep(poll_interval)
+                    poll = requests.post(f"{base}:fetchPredictOperation", headers=headers, json={"operationName": op_name}, timeout=30)
+                    if poll.status_code != 200:
+                        continue
+                    payload = poll.json()
+                    if not payload.get("done"):
+                        continue
+                    if payload.get("error"):
+                        last_error = f"Veo operation failed: {payload['error']}"
+                        break
+                    video = _video_bytes(payload)
+                    if video:
+                        from aria_code.artifacts import create_user_artifact
+
+                        artifact = create_user_artifact("video", "veo", "clip", ".mp4")
+                        artifact.path.write_bytes(video)
+                        return {
+                            "success": True,
+                            "path": str(artifact.path),
+                            "model": display_model,
+                            "model_id": model,
+                            "provider": "Google Cloud Vertex AI",
+                            "duration": duration_seconds,
+                            "aspect_ratio": aspect_ratio,
+                        }
+                    filtered = (payload.get("response") or {}).get("raiMediaFilteredReasons")
+                    last_error = f"Veo returned no video{f' (filtered: {filtered})' if filtered else ''}."
+                    break
+                else:
+                    last_error = f"Veo did not finish within {int(max_wait_seconds)} s."
+            else:
+                last_error = f"Vertex AI HTTP {resp.status_code}: {resp.text[:300]}"
+        except Exception as exc:
+            last_error = str(exc)
+
+    # 2. Try Gemini API if API key configured
+    if api_key:
+        gemini_endpoint = f"https://generativelanguage.googleapis.com/v1beta/models/{model}:predictLongRunning"
+        try:
+            resp = requests.post(
+                gemini_endpoint,
+                headers={"x-goog-api-key": api_key, "Content-Type": "application/json"},
+                json=body,
+                timeout=30,
+            )
+            if resp.status_code in (200, 201, 202):
+                op_data = resp.json()
+                op_name = op_data.get("name")
+                if op_name:
+                    poll_url = f"https://generativelanguage.googleapis.com/v1beta/{op_name}"
+                    start_time = time.time()
+                    while time.time() - start_time < max_wait_seconds:
+                        time.sleep(poll_interval)
+                        poll_resp = requests.get(
+                            poll_url,
+                            headers={"x-goog-api-key": api_key},
+                            timeout=20,
+                        )
+                        if poll_resp.status_code == 200:
+                            p_json = poll_resp.json()
+                            if p_json.get("done"):
+                                if "error" in p_json:
+                                    last_error = f"Gemini Veo error: {p_json['error']}"
+                                    break
+                                response_payload = p_json.get("response", {})
+                                predictions = response_payload.get("predictions") or response_payload.get("generatedSamples") or []
+                                if predictions:
+                                    item = predictions[0]
+                                    video_b64 = item.get("bytesBase64Encoded") or (item.get("video", {})).get("bytesBase64Encoded")
+                                    if video_b64:
+                                        from aria_code.artifacts import create_user_artifact
+                                        artifact = create_user_artifact("video", "veo", "clip", ".mp4")
+                                        artifact.path.write_bytes(base64.b64decode(video_b64))
+                                        return {
+                                            "success": True,
+                                            "path": str(artifact.path),
+                                            "model": f"Gemini API {model}",
+                                            "provider": "Google Gemini API",
+                                            "duration": duration_seconds,
+                                            "aspect_ratio": aspect_ratio,
+                                        }
+                                break
+            else:
+                last_error = f"Gemini API HTTP {resp.status_code}: {resp.text[:300]}"
+        except Exception as exc:
+            last_error = str(exc)
+
+    return {
+        "success": False,
+        "error": f"Google Veo video generation unavailable: {last_error or 'No response from API'}",
+    }

aria_code/providers/llm/__init__.py

@@ -0,0 +1,19 @@
+from .base import BaseLLMProvider, Message, ProviderConfig
+from .ollama import OllamaProvider
+from .openai_compat import (
+    DeepSeekProvider, OpenAIProvider, GroqProvider,
+    TogetherProvider, DashScopeProvider, LMStudioProvider,
+    SiliconFlowProvider, MoonshotProvider, ZhiPuProvider,
+)
+from .anthropic import AnthropicProvider
+from .registry import get_provider, list_available_providers, stream_cloud_fallback, register_provider
+
+__all__ = [
+    "BaseLLMProvider", "Message", "ProviderConfig",
+    "OllamaProvider", "DeepSeekProvider", "OpenAIProvider",
+    "AnthropicProvider", "GroqProvider", "TogetherProvider",
+    "DashScopeProvider", "LMStudioProvider",
+    "SiliconFlowProvider", "MoonshotProvider", "ZhiPuProvider",
+    "get_provider", "list_available_providers",
+    "stream_cloud_fallback", "register_provider",
+]

aria_code/providers/llm/anthropic.py

@@ -0,0 +1,184 @@
+"""
+providers/llm/anthropic.py — Anthropic Claude Provider
+=======================================================
+支持 claude-3-5-sonnet / claude-3-haiku / claude-3-opus 等。
+支持流式 thinking（扩展思考模式）。
+
+需要设置: ANTHROPIC_API_KEY=sk-ant-...
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+from typing import Any, AsyncIterator, Dict, List, Optional
+
+from .base import BaseLLMProvider, Message, ProviderConfig
+
+logger = logging.getLogger(__name__)
+
+_ANTHROPIC_API_URL = "https://api.anthropic.com/v1/messages"
+_ANTHROPIC_VERSION = "2023-06-01"
+
+
+class AnthropicProvider(BaseLLMProvider):
+
+    provider_name     = "anthropic"
+    supports_tools    = True
+    supports_thinking = True    # claude-3-5-sonnet 支持 extended thinking
+    local             = False
+
+    DEFAULT_MODEL = "claude-3-5-haiku-latest"
+
+    def __init__(self, config: ProviderConfig):
+        super().__init__(config)
+        self.api_key = config.api_key or os.getenv("ANTHROPIC_API_KEY", "")
+        self.model   = config.model or self.DEFAULT_MODEL
+
+    async def is_available(self) -> bool:
+        return bool(self.api_key)
+
+    # Minimum system-prompt length (chars) to bother caching.
+    # Prompts shorter than this don't benefit from prompt caching.
+    _CACHE_MIN_CHARS = 1024
+
+    def _build_cached_system(self, system_text: str) -> list:
+        """
+        Wrap a long system prompt in a cache_control block so Anthropic
+        caches it across calls.  Returns the `system` field value (a list
+        of content blocks, or a plain string for short prompts).
+
+        Anthropic prompt caching docs:
+          https://docs.anthropic.com/en/docs/build-with-claude/prompt-caching
+        """
+        if len(system_text) < self._CACHE_MIN_CHARS:
+            return system_text  # type: ignore[return-value]
+        return [
+            {
+                "type": "text",
+                "text": system_text,
+                "cache_control": {"type": "ephemeral"},
+            }
+        ]
+
+    async def stream(
+        self,
+        messages: List[Message],
+        tools: Optional[List[Dict]] = None,
+        temperature: Optional[float] = None,
+        max_tokens: Optional[int] = None,
+        cancel_event=None,
+    ) -> AsyncIterator[Dict[str, Any]]:
+        import aiohttp
+
+        temp     = temperature if temperature is not None else self.config.temperature
+        n_tokens = max_tokens  if max_tokens  is not None else self.config.max_tokens
+
+        # Anthropic 格式：system 单独提取
+        system_parts = [m.content for m in messages if m.role == "system"]
+        system_text  = "\n\n".join(system_parts) if system_parts else None
+        anthro_msgs  = [
+            {"role": m.role, "content": m.content}
+            for m in messages if m.role != "system"
+        ]
+
+        payload: Dict[str, Any] = {
+            "model":      self.model,
+            "max_tokens": n_tokens,
+            "messages":   anthro_msgs,
+            "stream":     True,
+        }
+        if system_text:
+            # Use prompt caching for long system prompts to reduce TTFT and cost
+            payload["system"] = self._build_cached_system(system_text)
+        if temp > 0:
+            payload["temperature"] = temp
+        if tools:
+            payload["tools"] = [
+                {
+                    "name":         t.get("name"),
+                    "description":  t.get("description", ""),
+                    "input_schema": t.get("parameters", {"type": "object", "properties": {}}),
+                }
+                for t in tools
+            ]
+
+        headers = {
+            "x-api-key":           self.api_key,
+            "anthropic-version":   _ANTHROPIC_VERSION,
+            "anthropic-beta":      "prompt-caching-2024-07-31",
+            "content-type":        "application/json",
+        }
+
+        proxy = (os.getenv("HTTPS_PROXY") or os.getenv("https_proxy")
+                 or os.getenv("HTTP_PROXY")  or os.getenv("http_proxy"))
+        try:
+            async with aiohttp.ClientSession(trust_env=True) as sess:
+                async with sess.post(
+                    _ANTHROPIC_API_URL, json=payload, headers=headers,
+                    proxy=proxy,
+                    timeout=aiohttp.ClientTimeout(total=self.config.timeout)
+                ) as resp:
+                    if resp.status != 200:
+                        body = await resp.text()
+                        yield {"type": "error",
+                               "message": f"Anthropic HTTP {resp.status}: {body[:300]}"}
+                        return
+
+                    _pending_tool_name = ""
+                    _pending_tool_args = ""
+
+                    async for raw in resp.content:
+                        if cancel_event and cancel_event.is_set():
+                            return
+                        line = raw.decode("utf-8", errors="ignore").strip()
+                        if not line or not line.startswith("data:"):
+                            continue
+
+                        try:
+                            data = json.loads(line[5:].strip())
+                        except json.JSONDecodeError:
+                            continue
+
+                        etype = data.get("type", "")
+
+                        # 思考 token（扩展思考模式）
+                        if etype == "content_block_start":
+                            cb = data.get("content_block", {})
+                            if cb.get("type") == "thinking":
+                                yield {"type": "thinking", "text": cb.get("thinking", "")}
+                            elif cb.get("type") == "tool_use":
+                                _pending_tool_name = cb.get("name", "")
+                                _pending_tool_args = ""
+
+                        elif etype == "content_block_delta":
+                            delta = data.get("delta", {})
+                            dt    = delta.get("type", "")
+                            if dt == "text_delta":
+                                yield {"type": "token", "text": delta.get("text", "")}
+                            elif dt == "thinking_delta":
+                                yield {"type": "thinking", "text": delta.get("thinking", "")}
+                            elif dt == "input_json_delta":
+                                _pending_tool_args += delta.get("partial_json", "")
+
+                        elif etype == "content_block_stop":
+                            if _pending_tool_name:
+                                try:
+                                    args = json.loads(_pending_tool_args)
+                                except Exception:
+                                    args = {"_raw": _pending_tool_args}
+                                yield {"type": "tool_call",
+                                       "name": _pending_tool_name,
+                                       "arguments": args}
+                                _pending_tool_name = ""
+                                _pending_tool_args = ""
+
+                        elif etype == "message_stop":
+                            yield {"type": "done"}
+                            return
+
+        except aiohttp.ClientConnectorError as e:
+            yield {"type": "error", "message": f"Anthropic 连接失败: {e}"}
+        except Exception as e:
+            yield {"type": "error", "message": f"Anthropic 错误: {e}"}

aria_code/providers/llm/arthera_gateway.py

@@ -0,0 +1,90 @@
+"""Google models through the Arthera gateway, using the session you signed in with.
+
+`/login` gave you an identity and nothing else: to reach a Google model you
+still needed a Gemini API key from AI Studio, or gcloud and a billed Google
+Cloud project of your own. That is setup this product exists to spare people,
+and every layer of it is a place to get stuck — a missing dependency, gcloud
+not on PATH, a suspended billing account.
+
+The server holds a project and a service account with access to Vertex, and
+exposes it in the OpenAI shape. So this provider is the ordinary
+OpenAI-compatible one pointed at that endpoint, authorised with the Firebase
+token `/login` already stored. There is nothing for the user to configure.
+
+The token is read at call time rather than captured once, because it lasts an
+hour and `/login` refreshes it in the same config file.
+"""
+from __future__ import annotations
+
+import json
+import logging
+import os
+from pathlib import Path
+from typing import Optional
+
+from .base import ProviderConfig
+from .openai_compat import OpenAICompatProvider
+
+logger = logging.getLogger(__name__)
+
+DEFAULT_API_URL = "https://api.arthera.xyz"
+DEFAULT_MODEL = "google/gemini-3.8-flash"
+
+
+def _config_path() -> Path:
+    """Where /login saved the session: the same file, by the same rule.
+
+    This used to be ~/.arthera/config.json, or ARIA_CONFIG_DIR. /login writes
+    through aria_home(), which is ~/.arthera only when that legacy folder
+    already exists and ~/.aria-code otherwise, and is overridden by ARIA_HOME.
+    So on a new install — the people signing in to reach a model without a
+    key — the session was saved in one folder and looked for in another, and
+    signing in never gave them a model. Asking aria_home() is what the 38
+    files that once hardcoded ~/.arthera were moved over to for this reason.
+    """
+    from aria_code.packages.aria_core.paths import aria_home
+
+    return aria_home() / "config.json"
+
+
+def session_token() -> Optional[str]:
+    """The Firebase token `/login` stored, or None when signed out."""
+    try:
+        config = json.loads(_config_path().read_text(encoding="utf-8"))
+    except (OSError, ValueError):
+        return None
+    from aria_code.account_session import account_id, get_account_token
+    if account_id(config):
+        return get_account_token(config)
+    from aria_code.apps.cli.session_refresh import refresh_config_file
+    return refresh_config_file(_config_path())
+
+
+def gateway_base_url() -> str:
+    """Where the gateway lives. Overridable for staging and self-hosting."""
+    api = os.getenv("ARIA_API_URL", "").strip() or DEFAULT_API_URL
+    from aria_code.service_endpoints import current_url
+    return f"{current_url(api)}/api/v2/llm/v1"
+
+
+class ArtheraGatewayProvider(OpenAICompatProvider):
+    """Google models billed to the Arthera project, for a signed-in user."""
+
+    provider_name = "arthera"
+    DEFAULT_BASE_URL = ""          # resolved per instance; it is deployment state
+    DEFAULT_MODEL = DEFAULT_MODEL
+
+    def __init__(self, config: ProviderConfig):
+        if not config.base_url:
+            config.base_url = gateway_base_url()
+        # The bearer is the session, not a key the user pasted. Reading it
+        # here keeps a signed-out user from presenting an empty credential
+        # and getting a 401 they cannot act on.
+        if not config.api_key:
+            config.api_key = session_token() or ""
+        super().__init__(config)
+
+    @staticmethod
+    def available() -> bool:
+        """True when there is a session to authorise calls with."""
+        return bool(session_token())