3分の動画だけが失敗する — Rork の動画解析をワーカー経由から端末直送に引き直す

// ✅ Worker は「宛先の発行」だけを担う。動画のバイトは一切通らない
interface Env {
  GEMINI_API_KEY: string;
  SESSIONS: KVNamespace;
}
 
const MAX_BYTES = 2 * 1024 * 1024 * 1024; // Files API の1ファイル上限は 2GB
 
async function issueUploadUrl(request: Request, env: Env): Promise<Response> {
  const { sizeBytes, mimeType, userId } = await request.json<{
    sizeBytes: number;
    mimeType: string;
    userId: string;
  }>();
 
  // サイズと形式は「宛先を出す前」に弾く。上げきってから断るのは端末の帯域を捨てる行為
  if (!Number.isInteger(sizeBytes) || sizeBytes <= 0 || sizeBytes > MAX_BYTES) {
    return Response.json({ error: 'invalid_size' }, { status: 400 });
  }
  if (!['video/mp4', 'video/quicktime'].includes(mimeType)) {
    return Response.json({ error: 'unsupported_type' }, { status: 415 });
  }
 
  // 宛先の発行そのものがコストになるので、ユーザー単位で回数を絞る
  const quotaKey = `upload_quota:${userId}:${new Date().toISOString().slice(0, 10)}`;
  const used = Number((await env.SESSIONS.get(quotaKey)) ?? '0');
  if (used >= 20) {
    return Response.json({ error: 'daily_quota_exceeded' }, { status: 429 });
  }
 
  const initResponse = await fetch(
    `https://generativelanguage.googleapis.com/upload/v1beta/files?key=${env.GEMINI_API_KEY}`,
    {
      method: 'POST',
      headers: {
        'X-Goog-Upload-Protocol': 'resumable',
        'X-Goog-Upload-Command': 'start',
        'X-Goog-Upload-Header-Content-Length': String(sizeBytes),
        'X-Goog-Upload-Header-Content-Type': mimeType,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({ file: { display_name: `v_${Date.now()}` } }),
    }
  );
 
  const uploadUrl = initResponse.headers.get('X-Goog-Upload-URL');
  if (!uploadUrl) {
    return Response.json({ error: 'init_failed' }, { status: 502 });
  }
 
  await env.SESSIONS.put(quotaKey, String(used + 1), { expirationTtl: 86400 });
 
  // この URL にはセッショントークンが埋まっている。API キーは渡らない
  return Response.json({ uploadUrl, sizeBytes });
}

// app/lib/uploadVideo.ts
import * as FileSystem from 'expo-file-system';
import * as ImagePicker from 'expo-image-picker';
 
const API_BASE = 'https://your-worker.example.workers.dev';
 
export type UploadResult = { fileUri: string; sizeBytes: number };
 
export async function pickAndUploadVideo(
  userId: string,
  onProgress?: (ratio: number) => void
): Promise<UploadResult | null> {
  const permission = await ImagePicker.requestMediaLibraryPermissionsAsync();
  if (!permission.granted) return null;
 
  const picked = await ImagePicker.launchImageLibraryAsync({
    mediaTypes: ['videos'],
    quality: 1,
  });
  if (picked.canceled || !picked.assets[0]) return null;
 
  const asset = picked.assets[0];
  const info = await FileSystem.getInfoAsync(asset.uri);
  if (!info.exists) return null;
 
  const sizeBytes = info.size ?? 0;
  const mimeType = asset.mimeType ?? 'video/mp4';
 
  // Step 1: 宛先だけをサーバーからもらう
  const issued = await fetch(`${API_BASE}/api/upload-url`, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ sizeBytes, mimeType, userId }),
  });
  if (!issued.ok) {
    const { error } = await issued.json();
    throw new Error(`宛先の発行に失敗しました (${error})`);
  }
  const { uploadUrl } = await issued.json();
 
  // Step 2: 端末から Google へ直接送る。Worker は経由しない
  const task = FileSystem.createUploadTask(
    uploadUrl,
    asset.uri,
    {
      httpMethod: 'POST',
      uploadType: FileSystem.FileSystemUploadType.BINARY_CONTENT,
      headers: {
        'Content-Length': String(sizeBytes),
        'X-Goog-Upload-Offset': '0',
        'X-Goog-Upload-Command': 'upload, finalize',
      },
    },
    (p) => onProgress?.(p.totalBytesSent / p.totalBytesExpectedToSend)
  );
 
  const response = await task.uploadAsync();
  if (!response || response.status >= 300) {
    throw new Error(`アップロードに失敗しました (${response?.status})`);
  }
 
  const body = JSON.parse(response.body) as {
    file: { uri: string; state: string };
  };
  return { fileUri: body.file.uri, sizeBytes };
}

// workers/src/waitForActive.ts
type FileState = 'PROCESSING' | 'ACTIVE' | 'FAILED';
 
export async function waitForActive(
  fileName: string,
  durationSec: number,
  env: Env
): Promise<void> {
  // 実測では概ね「動画長の 1/6 前後」で ACTIVE になった。3倍の余裕を持たせ、下限は 15 秒
  const budgetMs = Math.max(15_000, Math.ceil(durationSec / 6) * 3 * 1000);
  const deadline = Date.now() + budgetMs;
 
  let waitMs = 1_000;
  while (Date.now() < deadline) {
    const res = await fetch(
      `https://generativelanguage.googleapis.com/v1beta/files/${fileName}?key=${env.GEMINI_API_KEY}`
    );
    const { state } = await res.json<{ state: FileState }>();
 
    if (state === 'ACTIVE') return;
    if (state === 'FAILED') throw new Error('file_processing_failed');
 
    await new Promise((r) => setTimeout(r, waitMs));
    waitMs = Math.min(waitMs * 1.6, 8_000); // 指数バックオフ・上限8秒
  }
  throw new Error(`file_not_active_within_${budgetMs}ms`);
}

// workers/src/analyze.ts
type Intent = 'quick_summary' | 'form_coaching' | 'lecture_notes';
 
interface VideoPlan {
  model: string;
  mediaResolution: 'MEDIA_RESOLUTION_LOW' | 'MEDIA_RESOLUTION_MEDIUM';
  fps: number;
}
 
// 「何を見たいか」で解像度とフレームレートを決める。動画の長さでは決めない
function planFor(intent: Intent): VideoPlan {
  switch (intent) {
    case 'quick_summary':
      // 何が映っているか分かればよい。静的な場面が続くので 0.5fps で足りる
      return { model: 'gemini-flash-latest', mediaResolution: 'MEDIA_RESOLUTION_LOW', fps: 0.5 };
    case 'lecture_notes':
      // スライドが切り替わる瞬間を拾えればよい
      return { model: 'gemini-flash-latest', mediaResolution: 'MEDIA_RESOLUTION_LOW', fps: 1 };
    case 'form_coaching':
      // 一瞬の関節角度を見る。ここだけは間引くと結論が変わる
      return { model: 'gemini-pro-latest', mediaResolution: 'MEDIA_RESOLUTION_MEDIUM', fps: 4 };
  }
}
 
export async function analyze(
  fileUri: string,
  intent: Intent,
  clip: { startSec?: number; endSec?: number },
  env: Env
) {
  const plan = planFor(intent);
 
  const body = {
    contents: [
      {
        parts: [
          {
            fileData: { fileUri, mimeType: 'video/mp4' },
            videoMetadata: {
              fps: plan.fps,
              ...(clip.startSec !== undefined && { startOffset: `${clip.startSec}s` }),
              ...(clip.endSec !== undefined && { endOffset: `${clip.endSec}s` }),
            },
          },
          { text: PROMPTS[intent] },
        ],
      },
    ],
    generationConfig: {
      temperature: 0.2,
      maxOutputTokens: 2048,
      mediaResolution: plan.mediaResolution,
    },
  };
 
  const res = await fetch(
    `https://generativelanguage.googleapis.com/v1beta/models/${plan.model}:generateContent?key=${env.GEMINI_API_KEY}`,
    {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify(body),
    }
  );
  return res.json();
}