feat: 完善模型用量趋势与全局手账卡片并补齐阶段验收

backend/app/local_models/runtime.py

@@ -273,7 +273,7 @@ class LocalSpeech:
         from app.contracts import TranscriptSegment
         result = await runtime.infer("qwen3-asr", "transcription", {"source": str(source.resolve()), "language": language})
         return RoutedTranscript(text=result["text"], source="local",
-                                segments=[TranscriptSegment(**s) for s in result["segments"]])
+                                segments=[TranscriptSegment(**s) for s in result["segments"]], warnings=result.get("warnings", []))
 
     async def match(self, source, reference):
         result = await runtime.infer("eres2netv2", "speaker_matching",

backend/app/local_models/worker.py

@@ -9,27 +9,49 @@ import threading
 import time
 
 
-def decode(path, *, limit_seconds=3600):
+def decode(path, *, limit_seconds=3600, warnings=None):
     import av
     import numpy as np
     frames = []
     samples = 0
+    corrupt = 0
     with av.open(path, options={"protocol_whitelist": "file,pipe"}) as container:
         if not container.streams.audio:
             raise ValueError("Media has no audio track")
         resampler = av.AudioResampler(format="fltp", layout="mono", rate=16000)
-        for frame in container.decode(audio=0):
-            for output in resampler.resample(frame):
-                audio = output.to_ndarray().reshape(-1)
-                samples += len(audio)
+        for packet in container.demux(audio=0):
+            try:
+                decoded = packet.decode()
+            except av.error.InvalidDataError:
+                corrupt += 1
+                if corrupt > 100:
+                    raise ValueError("Too many damaged audio packets")
+                # Retain the missing packet's duration as silence so later timestamps do not shift.
+                missing = max(0, round(float((packet.duration or 0) * (packet.time_base or 0)) * 16000))
+                samples += missing
                 if samples > limit_seconds * 16000:
                     raise ValueError("Audio exceeds one hour")
-                frames.append(audio)
+                if missing:
+                    frames.append(np.zeros(missing, dtype=np.float32))
+                continue
+            for frame in decoded:
+                for output in resampler.resample(frame):
+                    audio = output.to_ndarray().reshape(-1)
+                    samples += len(audio)
+                    if samples > limit_seconds * 16000:
+                        raise ValueError("Audio exceeds one hour")
+                    frames.append(audio)
         for output in resampler.resample(None):
-            frames.append(output.to_ndarray().reshape(-1))
+            audio = output.to_ndarray().reshape(-1)
+            samples += len(audio)
+            if samples > limit_seconds * 16000:
+                raise ValueError("Audio exceeds one hour")
+            frames.append(audio)
     if not frames:
         raise ValueError("Audio is empty")
     audio = np.concatenate(frames).astype(np.float32)
+    if corrupt and warnings is not None:
+        warnings.append(f"MEDIA_CORRUPT_PACKETS_SKIPPED:{corrupt}")
     if not np.isfinite(audio).all() or len(audio) < 1600:
         raise ValueError("Invalid or too short audio")
     return audio
@@ -125,7 +147,8 @@ def run(request):
             model = Qwen3ASRModel.from_pretrained(path, dtype=torch.float32 if device == "cpu" else torch.float16,
                 device_map=device, attn_implementation="sdpa", max_inference_batch_size=1, max_new_tokens=512)
             loaded = time.monotonic()
-            audio = decode(payload["source"])
+            decode_warnings = []
+            audio = decode(payload["source"], warnings=decode_warnings)
             audio_seconds = len(audio) / 16000
             regions = speech_regions(audio)
             language = {"zh": "Chinese", "en": "English", "ja": "Japanese", "yue": "Cantonese"}.get(payload.get("language"), payload.get("language"))
@@ -137,7 +160,7 @@ def run(request):
                                      "end_time": end / 16000, "text": output.text, "language": output.language})
                     sys.__stdout__.write(json.dumps({"progress": end / len(audio), "segment": segments[-1]}, ensure_ascii=False) + "\n")
                     sys.__stdout__.flush()
-            result = {"text": "\n".join(s["text"] for s in segments), "segments": segments}
+            result = {"text": "\n".join(s["text"] for s in segments), "segments": segments, "warnings": decode_warnings}
         elif operation == "speaker_matching":
             model = speaker_model(path, device)
             loaded = time.monotonic()

backend/app/media_routes.py

@@ -18,7 +18,9 @@ from app.services import transcription_service as jobs
 from app.services.attachment_service import attachment_path
 
 router = APIRouter(prefix="/api/media", tags=["Media"])
-MAX_UPLOAD_BYTES = 25 * 1024 * 1024
+from app.providers.routing import MAX_LOCAL_MEDIA_BYTES
+
+MAX_UPLOAD_BYTES = MAX_LOCAL_MEDIA_BYTES
 MEDIA_SUFFIXES = {".wav", ".mp3", ".flac", ".ogg", ".m4a", ".mp4", ".webm", ".txt", ".md"}
 
 
@@ -40,7 +42,7 @@ async def upload_attachment(request: Request, filename: str = Query(min_length=1
             async for chunk in request.stream():
                 size += len(chunk)
                 if size > MAX_UPLOAD_BYTES:
-                    raise ApiError(413, "ATTACHMENT_TOO_LARGE", "Attachment exceeds 25 MiB.")
+                    raise ApiError(413, "ATTACHMENT_TOO_LARGE", "Attachment exceeds 128 MiB.")
                 digest.update(chunk)
                 stream.write(chunk)
         if not size:

backend/app/providers/routing.py

@@ -31,6 +31,7 @@ from app.retrieval.provenance import record_embedding
 CAPABILITIES = ("embedding", "transcription", "speaker_matching")
 HTTP_TYPES = {ProviderType.openai_chat, ProviderType.openai_compatible}
 MAX_MEDIA_BYTES = 25 * 1024 * 1024
+MAX_LOCAL_MEDIA_BYTES = 128 * 1024 * 1024
 MAX_RESPONSE_BYTES = 16 * 1024 * 1024
 
 
@@ -58,6 +59,7 @@ class RoutedTranscript:
     source: str
     fallback_reason: str | None = None
     segments: list = field(default_factory=list)
+    warnings: list[str] = field(default_factory=list)
 
 
 def invalid_response() -> ProviderError:
@@ -276,21 +278,22 @@ class ModelRoutingService:
                                dimensions=local_embedding.dim, fallback_reason=reason)
 
     @staticmethod
-    def _media_file(path: Path):
+    def _media_file(path: Path, *, local_only: bool = False):
         try:
             handle = path.open("rb")
         except OSError as exc:
             raise ApiError(404, "ATTACHMENT_NOT_FOUND", "Audio attachment was not found.") from exc
         import os
-        if not 0 < os.fstat(handle.fileno()).st_size <= MAX_MEDIA_BYTES:
+        limit = MAX_LOCAL_MEDIA_BYTES if local_only else MAX_MEDIA_BYTES
+        if not 0 < os.fstat(handle.fileno()).st_size <= limit:
             handle.close()
-            raise ApiError(413, "ATTACHMENT_TOO_LARGE", "Audio attachment must be between 1 byte and 25 MiB.")
+            raise ApiError(413, "ATTACHMENT_TOO_LARGE", f"Audio attachment must be between 1 byte and {limit // (1024 * 1024)} MiB.")
         return handle
 
     async def transcribe(self, source: Path, language: str | None, *, local_only: bool = False) -> RoutedTranscript:
         binding = None if local_only else self.configuration().transcription
         if binding is None:
-            with self._media_file(source):
+            with self._media_file(source, local_only=local_only):
                 pass
         reason = None
         if binding:
@@ -343,7 +346,7 @@ class ModelRoutingService:
     async def match_speakers(self, source: Path, reference: Path, *, local_only: bool = False) -> SpeakerMatchResult:
         binding = None if local_only else self.configuration().speaker_matching
         if binding is None:
-            with self._media_file(source), self._media_file(reference):
+            with self._media_file(source, local_only=local_only), self._media_file(reference, local_only=local_only):
                 pass
         reason = None
         if binding:

backend/app/services/transcription_service.py

@@ -82,8 +82,9 @@ async def create_transcription(attachment_id, language=None, *, diarization=Fals
     actual = source if source.is_file() else attachment_path(f"{attachment_id}.txt")
     if not actual.is_file():
         raise ApiError(404, "ATTACHMENT_NOT_FOUND", "Attachment was not found.")
-    if not 0 < actual.stat().st_size <= 25 * 1024 * 1024:
-        raise ApiError(413, "ATTACHMENT_TOO_LARGE", "Attachment must be between 1 byte and 25 MiB.")
+    from app.providers.routing import MAX_LOCAL_MEDIA_BYTES, MAX_MEDIA_BYTES
+    if not 0 < actual.stat().st_size <= (MAX_LOCAL_MEDIA_BYTES if local_only else MAX_MEDIA_BYTES):
+        raise ApiError(413, "ATTACHMENT_TOO_LARGE", "仅本地处理最大支持 128 MiB；超过 25 MiB 的录音请启用仅本地处理。")
     digest = await asyncio.to_thread(lambda: hashlib.sha256(actual.read_bytes()).hexdigest())
     from app.container import container
     from app.local_models.runtime import configuration
@@ -160,6 +161,7 @@ async def _execute(job_id, request, routing=None):
             result = await (routing or container.model_routing).transcribe(source, request.language, local_only=request.local_only)
             job.text, job.source, job.fallback_reason = result.text, result.source, result.fallback_reason
             job.segments = getattr(result, "segments", []) or []
+            job.warnings.extend(getattr(result, "warnings", []) or [])
         if not job.text or not job.text.strip():
             raise ApiError(422, "TRANSCRIPT_EMPTY", "Transcript is empty.")
         if request.diarization:

backend/app/services/usage_service.py

@@ -6,7 +6,7 @@ import logging
 import math
 from contextlib import closing
 from contextvars import ContextVar
-from datetime import datetime, timezone
+from datetime import datetime, timezone, timedelta
 from uuid import uuid4
 
 from app.database.db import connect
@@ -107,8 +107,8 @@ class UsageAttempt:
             logger.warning("Usage persistence failed; model response remains available")
 
 
-def aggregate(start, end, provider_id=None, model=None, source=None):
-    query = "SELECT counters_json,completed,capability FROM model_usage WHERE started_at>=? AND started_at<?"
+def aggregate(start, end, provider_id=None, model=None, source=None, timezone_offset=0):
+    query = "SELECT counters_json,completed,capability,started_at,source FROM model_usage WHERE started_at>=? AND started_at<?"
     args = [start.astimezone(timezone.utc).isoformat(), end.astimezone(timezone.utc).isoformat()]
     for column, value in (("provider_id", provider_id), ("model", model), ("source", source)):
         if value:
@@ -117,6 +117,18 @@ def aggregate(start, end, provider_id=None, model=None, source=None):
     with closing(connection()) as conn:
         rows = conn.execute(query, args).fetchall()
         options = conn.execute("SELECT DISTINCT provider_id,model,source FROM model_usage ORDER BY provider_id,model").fetchall()
+    # Calendar buckets use the caller's UTC offset; absent counters remain null.
+    zone = timezone(timedelta(minutes=timezone_offset))
+    first = start.astimezone(zone).date()
+    last = (end - timedelta(microseconds=1)).astimezone(zone).date()
+    days = (last - first).days + 1
+    step = max(1, (days + 89) // 90)
+    series = []
+    for offset in range(0, days, step):
+        date = first + timedelta(days=offset)
+        series.append({"date": date.isoformat(), "end_date": (first + timedelta(days=min(days-1, offset+step-1))).isoformat(),
+                       "local": {"requests": 0, "totals": {key: None for key in METRICS}, "coverage": {key: 0 for key in METRICS}},
+                       "api": {"requests": 0, "totals": {key: None for key in METRICS}, "coverage": {key: 0 for key in METRICS}}})
     totals = {key: None for key in METRICS}
     coverage = {key: 0 for key in METRICS}
     hits, eligible_input, cache_requests = 0, 0, 0
@@ -125,6 +137,13 @@ def aggregate(start, end, provider_id=None, model=None, source=None):
         if row[2] in {"transcription", "speaker_matching"}:
             audio_requests += 1
         counts = json.loads(row[0])
+        date = datetime.fromisoformat(row[3]).astimezone(zone).date()
+        bucket = series[(date - first).days // step][row[4]]
+        bucket['requests'] += 1
+        for key in METRICS:
+            if counts.get(key) is not None:
+                bucket['totals'][key] = (bucket['totals'][key] or 0) + counts[key]
+                bucket['coverage'][key] += 1
         if counts.get("audio_seconds") is not None:
             audio_covered += 1
             audio_seconds = (audio_seconds or 0) + counts["audio_seconds"]
@@ -140,4 +159,4 @@ def aggregate(start, end, provider_id=None, model=None, source=None):
             "complete_requests": sum(row[1] for row in rows), "cache_covered_requests": cache_requests,
             "cache_hit_rate": hits / eligible_input if eligible_input else None,
             "options": [dict(row) for row in options], "start": start, "end": end,
-            "scope": "application_observed_usage"}
+            "scope": "application_observed_usage", "series": series, "timezone_offset": timezone_offset}

backend/app/usage_routes.py

@@ -9,11 +9,11 @@ router = APIRouter(prefix="/api/usage", tags=["Usage"])
 @router.get("")
 async def usage(start: datetime | None = None, end: datetime | None = None,
                 provider_id: str | None = Query(None, max_length=200), model: str | None = Query(None, max_length=200),
-                source: str | None = None):
+                source: str | None = None, timezone_offset: int = Query(0, ge=-840, le=840)):
     end = end or datetime.now(timezone.utc)
     start = start or end - timedelta(days=7)
     if not start.tzinfo or not end.tzinfo or end <= start:
         raise ApiError(422, "INVALID_TIME_RANGE", "Provide timezone-aware start/end with end after start.")
     if source not in {None, "local", "api"}:
         raise ApiError(422, "INVALID_USAGE_SOURCE", "Unknown usage source.")
-    return aggregate(start, end, provider_id, model, source)
+    return aggregate(start, end, provider_id, model, source, timezone_offset)