Rork × マルチモーダルAI：カメラ・音声・テキストを統合したインテリジェントアプリ設計パターン

// services/aiOrchestrator.ts
 
import { MultimodalContext, ModalityInput } from '../types/multimodal';
 
type AIProvider = 'coreml' | 'gemini' | 'claude' | 'whisper';
 
interface OrchestratorConfig {
  preferOnDevice: boolean;       // オンデバイス処理を優先するか
  maxLatencyMs: number;          // 許容最大レイテンシ
  costBudgetPerRequest: number;  // 1リクエストあたりの予算（USD）
}
 
const DEFAULT_CONFIG: OrchestratorConfig = {
  preferOnDevice: true,
  maxLatencyMs: 3000,
  costBudgetPerRequest: 0.05,
};
 
export class AIOrchestrator {
  private config: OrchestratorConfig;
 
  constructor(config: Partial<OrchestratorConfig> = {}) {
    this.config = { ...DEFAULT_CONFIG, ...config };
  }
 
  // 入力内容に応じて最適なモデルを選択
  selectProvider(inputs: ModalityInput[]): AIProvider {
    const hasImage = inputs.some(i => i.type === 'image');
    const hasAudio = inputs.some(i => i.type === 'audio');
    const hasText = inputs.some(i => i.type === 'text');
 
    // 音声入力がある場合、まず Whisper で変換
    if (hasAudio) {
      return 'whisper';  // まずテキスト化 → 再度ルーティング
    }
 
    // 画像のみ（テキストなし）→ オンデバイス処理
    if (hasImage && !hasText && this.config.preferOnDevice) {
      return 'coreml';
    }
 
    // 画像＋テキスト → Gemini（マルチモーダルネイティブ）
    if (hasImage && hasText) {
      return 'gemini';
    }
 
    // テキストのみで複雑な推論が必要 → Claude
    const textInputs = inputs.filter(i => i.type === 'text');
    const totalLength = textInputs.reduce((sum, i) => {
      return sum + (i.data as { content: string }).content.length;
    }, 0);
 
    if (totalLength > 500) {
      return 'claude';
    }
 
    // 短いテキストのみ → Core ML でオンデバイス処理
    return this.config.preferOnDevice ? 'coreml' : 'gemini';
  }
 
  // メイン処理パイプライン
  async process(context: MultimodalContext): Promise<AIResponse> {
    const pipeline = this.buildPipeline(context.inputs);
    let result: AIResponse = { text: '', confidence: 0 };
 
    for (const step of pipeline) {
      result = await this.executeStep(step, context, result);
    }
 
    return result;
  }
 
  // 入力に応じた処理パイプラインを構築
  private buildPipeline(inputs: ModalityInput[]): PipelineStep[] {
    const steps: PipelineStep[] = [];
 
    // Step 1: 音声をテキストに変換
    const audioInputs = inputs.filter(i => i.type === 'audio');
    if (audioInputs.length > 0) {
      steps.push({ provider: 'whisper', task: 'transcribe', inputs: audioInputs });
    }
 
    // Step 2: 画像の前処理（オンデバイス分類）
    const imageInputs = inputs.filter(i => i.type === 'image');
    if (imageInputs.length > 0 && this.config.preferOnDevice) {
      steps.push({ provider: 'coreml', task: 'classify', inputs: imageInputs });
    }
 
    // Step 3: 統合分析（全入力をまとめてクラウドAIへ）
    const mainProvider = this.selectProvider(inputs);
    steps.push({ provider: mainProvider, task: 'analyze', inputs });
 
    return steps;
  }
}
 
// 期待する出力:
// Pipeline: [whisper:transcribe] → [coreml:classify] → [gemini:analyze]
// 音声入力が "この花の名前は？" → テキスト化
// 画像 → Core ML で植物分類 → ラベル: "バラ科"
// 全データを Gemini に送信 → "この画像にはバラ科の花が写っています。品種は..."

// components/SmartCamera.tsx
 
import React, { useState, useCallback, useRef } from 'react';
import { View, Text, StyleSheet, TouchableOpacity, Image } from 'react-native';
 
interface SmartCameraProps {
  onCapture: (image: ImageInput) => void;
  onRealtimeResult?: (result: string) => void;
}
 
export function SmartCamera({ onCapture, onRealtimeResult }: SmartCameraProps) {
  const [preview, setPreview] = useState<string | null>(null);
  const [analyzing, setAnalyzing] = useState(false);
  const frameCountRef = useRef(0);
 
  // フレーム分析（5フレームに1回実行してパフォーマンスを確保）
  const handleFrame = useCallback(async (frameData: string) => {
    frameCountRef.current += 1;
    if (frameCountRef.current % 5 !== 0) return;
 
    // Core ML でオンデバイス分類
    try {
      const result = await classifyWithCoreML(frameData);
      onRealtimeResult?.(result.label);
    } catch (error) {
      console.warn('Frame analysis failed:', error);
    }
  }, [onRealtimeResult]);
 
  // 撮影ボタン押下
  const handleCapture = useCallback(async () => {
    setAnalyzing(true);
    try {
      const photo = await capturePhoto();
      setPreview(photo.uri);
 
      const imageInput: ImageInput = {
        uri: photo.uri,
        base64: photo.base64,
        width: photo.width,
        height: photo.height,
        mimeType: 'image/jpeg',
      };
      onCapture(imageInput);
    } finally {
      setAnalyzing(false);
    }
  }, [onCapture]);
 
  return (
    <View style={styles.container}>
      {/* カメラプレビュー領域 */}
      <View style={styles.cameraPreview}>
        {preview ? (
          <Image source={{ uri: preview }} style={styles.previewImage} />
        ) : (
          <Text style={styles.placeholder}>カメラプレビュー</Text>
        )}
      </View>
 
      {/* 撮影ボタン */}
      <TouchableOpacity
        style={styles.captureButton}
        onPress={handleCapture}
        disabled={analyzing}
      >
        <Text style={styles.captureText}>
          {analyzing ? '分析中...' : '撮影'}
        </Text>
      </TouchableOpacity>
    </View>
  );
}
 
// 期待する動作:
// 1. カメラプレビュー中 → 5フレームごとに Core ML で分類
// 2. 撮影ボタン押下 → 高解像度画像をキャプチャ → onCapture コールバック
// 3. 統合レイヤーを通じて Gemini/Claude に画像を送信

// utils/imagePreprocessor.ts
 
interface PreprocessConfig {
  maxWidth: number;
  maxHeight: number;
  quality: number;        // 0.0 - 1.0
  format: 'jpeg' | 'png';
}
 
const PREPROCESS_CONFIGS: Record<string, PreprocessConfig> = {
  // Core ML: 高解像度は不要
  coreml: { maxWidth: 224, maxHeight: 224, quality: 0.8, format: 'jpeg' },
  // Gemini: 中解像度で十分
  gemini: { maxWidth: 1024, maxHeight: 1024, quality: 0.85, format: 'jpeg' },
  // Claude: テキスト読み取り時は高解像度
  claude: { maxWidth: 2048, maxHeight: 2048, quality: 0.9, format: 'png' },
};
 
export async function preprocessImage(
  imageUri: string,
  targetProvider: string
): Promise<{ uri: string; base64: string; sizeKB: number }> {
  const config = PREPROCESS_CONFIGS[targetProvider] || PREPROCESS_CONFIGS.gemini;
 
  // リサイズ + 圧縮
  const resized = await resizeImage(imageUri, config.maxWidth, config.maxHeight);
  const compressed = await compressImage(resized, config.quality, config.format);
 
  return {
    uri: compressed.uri,
    base64: compressed.base64,
    sizeKB: Math.round(compressed.size / 1024),
  };
}
 
// 期待する出力:
// preprocessImage('photo.jpg', 'gemini')
// → { uri: 'resized_photo.jpg', base64: '...', sizeKB: 180 }
// 元画像 3MB → Gemini向け 180KB に圧縮

// 文字を読ませる要求かどうかで長辺を決める
type VisionIntent = "classify" | "read_text";
 
const LONG_EDGE_BY_INTENT: Record<VisionIntent, number> = {
  classify: 768,   // 被写体の分類・雰囲気の判定
  read_text: 1024, // ラベル・説明書き・手書きメモ
};
 
export async function preprocessImageForIntent(
  imageUri: string,
  intent: VisionIntent
) {
  const longEdge = LONG_EDGE_BY_INTENT[intent];
  const resized = await resizeImage(imageUri, longEdge, longEdge);
  return compressImage(resized, 0.85, "jpeg");
}
 
// 呼び出し側は「何をさせたいか」だけを渡す
// preprocessImageForIntent(uri, "classify") → 約 105KB
// preprocessImageForIntent(uri, "read_text") → 約 180KB

// hooks/useVoiceInput.ts
 
import { useState, useCallback, useRef } from 'react';
 
interface VoiceInputState {
  isListening: boolean;
  interimText: string;     // 認識途中のテキスト
  finalText: string;        // 確定したテキスト
  confidence: number;
}
 
export function useVoiceInput() {
  const [state, setState] = useState<VoiceInputState>({
    isListening: false,
    interimText: '',
    finalText: '',
    confidence: 0,
  });
  const audioChunksRef = useRef<ArrayBuffer[]>([]);
 
  const startListening = useCallback(async () => {
    setState(prev => ({ ...prev, isListening: true, interimText: '' }));
    audioChunksRef.current = [];
 
    // マイク入力のストリーム処理
    const stream = await startAudioStream({
      sampleRate: 16000,
      channels: 1,
      encoding: 'pcm_16bit',
    });
 
    stream.on('data', async (chunk: ArrayBuffer) => {
      audioChunksRef.current.push(chunk);
 
      // 500msごとに中間結果を取得
      if (audioChunksRef.current.length % 8 === 0) {
        const interim = await transcribeChunk(audioChunksRef.current);
        setState(prev => ({ ...prev, interimText: interim.text }));
      }
    });
 
    stream.on('silence', async () => {
      // 無音を検出 → 最終結果を確定
      const final = await transcribeFull(audioChunksRef.current);
      setState(prev => ({
        ...prev,
        isListening: false,
        finalText: final.text,
        confidence: final.confidence,
        interimText: '',
      }));
    });
  }, []);
 
  const stopListening = useCallback(() => {
    setState(prev => ({ ...prev, isListening: false }));
    // オーディオストリームを停止
    stopAudioStream();
  }, []);
 
  return { ...state, startListening, stopListening };
}
 
// 期待する動作:
// 1. startListening() → マイク起動
// 2. ユーザーが "この写真に写っている建物は何ですか" と話す
// 3. interimText: "この写真に" → "この写真に写って" → "この写真に写っている建物は..."
// 4. 無音検出 → finalText: "この写真に写っている建物は何ですか"
// 5. confidence: 0.95

// services/intentClassifier.ts
 
export type Intent = 'question' | 'command' | 'context' | 'correction';
 
interface IntentResult {
  intent: Intent;
  confidence: number;
  entities: Record<string, string>;  // 抽出されたエンティティ
}
 
// ルールベース + ML ハイブリッド分類
export async function classifyIntent(text: string): Promise<IntentResult> {
  // 1. ルールベースの高速判定（疑問詞・命令形）
  const questionPatterns = /^(何|どう|なぜ|いつ|どこ|誰|what|how|why|when|where|who)/i;
  const commandPatterns = /^(して|やって|変えて|教えて|見せて|show|change|do|tell)/i;
  const correctionPatterns = /^(違う|ちがう|そうじゃない|not that|wrong|no,)/i;
 
  if (correctionPatterns.test(text)) {
    return { intent: 'correction', confidence: 0.9, entities: {} };
  }
  if (questionPatterns.test(text)) {
    return { intent: 'question', confidence: 0.85, entities: {} };
  }
  if (commandPatterns.test(text)) {
    return { intent: 'command', confidence: 0.85, entities: {} };
  }
 
  // 2. ML モデルで詳細判定（Core ML NLModel）
  const mlResult = await classifyWithNLModel(text);
  return {
    intent: mlResult.label as Intent,
    confidence: mlResult.confidence,
    entities: mlResult.entities,
  };
}
 
// 期待する出力:
// classifyIntent("この花の名前は？")
// → { intent: 'question', confidence: 0.92, entities: { target: '花' } }
 
// classifyIntent("もっと明るくして")
// → { intent: 'command', confidence: 0.88, entities: { action: '明るく' } }

// hooks/useContextualTextInput.ts
 
import { useState, useCallback, useEffect } from 'react';
 
interface ContextualTextState {
  text: string;
  relatedModality: 'image' | 'audio' | 'none';
  suggestions: string[];      // コンテキストに応じた入力候補
}
 
export function useContextualTextInput(
  recentInputs: ModalityInput[]
) {
  const [state, setState] = useState<ContextualTextState>({
    text: '',
    relatedModality: 'none',
    suggestions: [],
  });
 
  // 直近の入力モダリティに応じてサジェストを更新
  useEffect(() => {
    const lastInput = recentInputs[recentInputs.length - 1];
    if (!lastInput) return;
 
    if (lastInput.type === 'image') {
      setState(prev => ({
        ...prev,
        relatedModality: 'image',
        suggestions: [
          'これは何ですか？',
          'この写真の詳細を教えてください',
          'この商品の価格を調べて',
          'テキストを読み取って',
        ],
      }));
    } else if (lastInput.type === 'audio') {
      setState(prev => ({
        ...prev,
        relatedModality: 'audio',
        suggestions: [
          'もう少し詳しく',
          'それについて画像を見せてください',
          '要約してください',
        ],
      }));
    }
  }, [recentInputs]);
 
  const setText = useCallback((text: string) => {
    setState(prev => ({ ...prev, text }));
  }, []);
 
  return { ...state, setText };
}

// components/MultimodalInputBar.tsx
 
import React, { useState, useCallback } from 'react';
import { View, TextInput, TouchableOpacity, Text, StyleSheet, Animated } from 'react-native';
 
type InputMode = 'text' | 'camera' | 'voice';
 
interface MultimodalInputBarProps {
  onSubmit: (input: ModalityInput) => void;
  isProcessing: boolean;
}
 
export function MultimodalInputBar({ onSubmit, isProcessing }: MultimodalInputBarProps) {
  const [mode, setMode] = useState<InputMode>('text');
  const [text, setText] = useState('');
  const slideAnim = useState(new Animated.Value(0))[0];
 
  const switchMode = useCallback((newMode: InputMode) => {
    // スライドアニメーションでモード切替
    Animated.spring(slideAnim, {
      toValue: newMode === 'text' ? 0 : newMode === 'camera' ? 1 : 2,
      useNativeDriver: true,
    }).start();
    setMode(newMode);
  }, [slideAnim]);
 
  const handleTextSubmit = useCallback(() => {
    if (!text.trim()) return;
    onSubmit({
      type: 'text',
      timestamp: Date.now(),
      data: { content: text.trim(), intent: 'question' },
    });
    setText('');
  }, [text, onSubmit]);
 
  return (
    <View style={styles.container}>
      {/* モード切替ボタン */}
      <View style={styles.modeSelector}>
        <TouchableOpacity
          onPress={() => switchMode('camera')}
          style={[styles.modeButton, mode === 'camera' && styles.activeMode]}
        >
          <Text>📷</Text>
        </TouchableOpacity>
        <TouchableOpacity
          onPress={() => switchMode('voice')}
          style={[styles.modeButton, mode === 'voice' && styles.activeMode]}
        >
          <Text>🎤</Text>
        </TouchableOpacity>
        <TouchableOpacity
          onPress={() => switchMode('text')}
          style={[styles.modeButton, mode === 'text' && styles.activeMode]}
        >
          <Text>⌨️</Text>
        </TouchableOpacity>
      </View>
 
      {/* 入力エリア — モードに応じて切替 */}
      {mode === 'text' && (
        <View style={styles.textInputContainer}>
          <TextInput
            style={styles.textInput}
            value={text}
            onChangeText={setText}
            onSubmitEditing={handleTextSubmit}
            placeholder="メッセージを入力..."
            editable={!isProcessing}
          />
          <TouchableOpacity onPress={handleTextSubmit} disabled={isProcessing}>
            <Text style={styles.sendButton}>送信</Text>
          </TouchableOpacity>
        </View>
      )}
 
      {mode === 'voice' && (
        <View style={styles.voiceContainer}>
          <Text style={styles.voiceText}>
            {isProcessing ? '処理中...' : 'タップして話してください'}
          </Text>
        </View>
      )}
 
      {mode === 'camera' && (
        <View style={styles.cameraContainer}>
          <Text style={styles.cameraText}>
            {isProcessing ? '分析中...' : 'タップして撮影'}
          </Text>
        </View>
      )}
    </View>
  );
}
 
const styles = StyleSheet.create({
  container: { padding: 12, backgroundColor: '#fff', borderTopWidth: 1, borderColor: '#e0e0e0' },
  modeSelector: { flexDirection: 'row', justifyContent: 'center', marginBottom: 8, gap: 16 },
  modeButton: { padding: 8, borderRadius: 20, backgroundColor: '#f0f0f0' },
  activeMode: { backgroundColor: '#e0e7ff' },
  textInputContainer: { flexDirection: 'row', alignItems: 'center' },
  textInput: { flex: 1, borderWidth: 1, borderColor: '#ddd', borderRadius: 20, paddingHorizontal: 16, paddingVertical: 8, fontSize: 16 },
  sendButton: { marginLeft: 8, color: '#4f46e5', fontWeight: '600', fontSize: 16 },
  voiceContainer: { alignItems: 'center', padding: 20 },
  voiceText: { fontSize: 16, color: '#666' },
  cameraContainer: { alignItems: 'center', padding: 20 },
  cameraText: { fontSize: 16, color: '#666' },
});

// state/multimodalStateMachine.ts
 
type AppState =
  | 'idle'            // 待機中
  | 'capturing'       // カメラ撮影中
  | 'listening'       // 音声入力中
  | 'typing'          // テキスト入力中
  | 'processing'      // AI処理中
  | 'displaying'      // 結果表示中
  | 'error';          // エラー
 
type AppEvent =
  | { type: 'START_CAMERA' }
  | { type: 'START_VOICE' }
  | { type: 'START_TEXT' }
  | { type: 'INPUT_RECEIVED'; payload: ModalityInput }
  | { type: 'AI_RESPONSE'; payload: AIResponse }
  | { type: 'ERROR'; payload: Error }
  | { type: 'RESET' };
 
export function multimodalReducer(state: AppState, event: AppEvent): AppState {
  switch (state) {
    case 'idle':
      if (event.type === 'START_CAMERA') return 'capturing';
      if (event.type === 'START_VOICE') return 'listening';
      if (event.type === 'START_TEXT') return 'typing';
      return state;
 
    case 'capturing':
    case 'listening':
    case 'typing':
      if (event.type === 'INPUT_RECEIVED') return 'processing';
      if (event.type === 'ERROR') return 'error';
      if (event.type === 'RESET') return 'idle';
      return state;
 
    case 'processing':
      if (event.type === 'AI_RESPONSE') return 'displaying';
      if (event.type === 'ERROR') return 'error';
      return state;
 
    case 'displaying':
      if (event.type === 'START_CAMERA') return 'capturing';
      if (event.type === 'START_VOICE') return 'listening';
      if (event.type === 'START_TEXT') return 'typing';
      if (event.type === 'RESET') return 'idle';
      return state;
 
    case 'error':
      if (event.type === 'RESET') return 'idle';
      return state;
 
    default:
      return state;
  }
}
 
// 期待する遷移:
// idle → START_CAMERA → capturing → INPUT_RECEIVED → processing → AI_RESPONSE → displaying
// displaying → START_VOICE → listening → INPUT_RECEIVED → processing → ...

// hooks/useModalityGate.ts
import { useCallback } from "react";
import { useCameraPermissions } from "expo-camera";
import {
  getRecordingPermissionsAsync,
  requestRecordingPermissionsAsync,
} from "expo-audio";
 
// blocked = OS がもうダイアログを出してくれない状態（canAskAgain: false）
export type GateResult = "granted" | "denied" | "blocked";
 
export function useModalityGate() {
  const [cameraPermission, requestCameraPermission] = useCameraPermissions();
 
  const ensureCamera = useCallback(async (): Promise<GateResult> => {
    if (cameraPermission?.granted) return "granted";
    if (cameraPermission && !cameraPermission.canAskAgain) return "blocked";
 
    const next = await requestCameraPermission();
    if (next.granted) return "granted";
    return next.canAskAgain ? "denied" : "blocked";
  }, [cameraPermission, requestCameraPermission]);
 
  const ensureVoice = useCallback(async (): Promise<GateResult> => {
    const current = await getRecordingPermissionsAsync();
    if (current.granted) return "granted";
    if (!current.canAskAgain) return "blocked";
 
    const next = await requestRecordingPermissionsAsync();
    if (next.granted) return "granted";
    return next.canAskAgain ? "denied" : "blocked";
  }, []);
 
  return { ensureCamera, ensureVoice };
}

const { ensureCamera } = useModalityGate();
 
const handleCameraPress = async () => {
  const result = await ensureCamera();
 
  if (result === "granted") {
    dispatch({ type: "START_CAMERA" });
    return;
  }
 
  // 縮退したことを層の側に残す。UI は状態を見るだけにする
  dispatch({
    type: "DISABLE_MODALITY",
    payload: { modality: "camera", reason: result },
  });
 
  if (result === "blocked") {
    Alert.alert(
      "カメラを使うには",
      "設定でカメラを許可すると、撮った写真をそのまま質問に使えるようになります。",
      [
        { text: "あとで", style: "cancel" },
        { text: "設定を開く", onPress: () => Linking.openSettings() },
      ],
    );
  }
};

// services/fallbackStrategy.ts
 
interface FallbackChain {
  primary: AIProvider;
  fallbacks: AIProvider[];
  offlineOnly: AIProvider | null;
}
 
const FALLBACK_CHAINS: Record<string, FallbackChain> = {
  imageAnalysis: {
    primary: 'gemini',
    fallbacks: ['claude', 'coreml'],
    offlineOnly: 'coreml',
  },
  textGeneration: {
    primary: 'claude',
    fallbacks: ['gemini'],
    offlineOnly: null,  // テキスト生成はオフラインでは不可
  },
  speechToText: {
    primary: 'whisper',
    fallbacks: ['coreml'],  // iOS の Speech Framework
    offlineOnly: 'coreml',
  },
};
 
export async function executeWithFallback<T>(
  task: string,
  execute: (provider: AIProvider) => Promise<T>
): Promise<T> {
  const chain = FALLBACK_CHAINS[task];
  if (!chain) throw new Error(`Unknown task: ${task}`);
 
  // オフラインチェック
  const isOnline = await checkNetworkStatus();
  if (!isOnline && chain.offlineOnly) {
    return execute(chain.offlineOnly);
  }
  if (!isOnline && !chain.offlineOnly) {
    throw new Error('この機能にはインターネット接続が必要です');
  }
 
  // プライマリ → フォールバック の順に試行
  const providers = [chain.primary, ...chain.fallbacks];
  let lastError: Error | null = null;
 
  for (const provider of providers) {
    try {
      return await execute(provider);
    } catch (error) {
      lastError = error as Error;
      console.warn(`${provider} failed for ${task}:`, error);
      continue;
    }
  }
 
  throw lastError || new Error(`All providers failed for ${task}`);
}
 
// 使用例:
// const result = await executeWithFallback('imageAnalysis', async (provider) => {
//   return await analyzeImage(imageData, provider);
// });
// → gemini 失敗 → claude にフォールバック → それも失敗 → coreml で処理

// utils/latencyBudget.ts
 
interface BudgetAllocation {
  preprocessing: number;   // 画像リサイズ・音声チャンク化
  onDeviceML: number;      // Core ML 推論
  networkTransfer: number; // APIへのデータ送信
  cloudInference: number;  // クラウドAI推論
  postprocessing: number;  // 結果の整形・表示
}
 
// 合計3秒の予算配分
const DEFAULT_BUDGET: BudgetAllocation = {
  preprocessing: 200,      // 200ms
  onDeviceML: 300,         // 300ms
  networkTransfer: 500,    // 500ms
  cloudInference: 1500,    // 1500ms
  postprocessing: 100,     // 100ms
};
// 残り: 400ms をバッファとして確保
 
export function createTimedExecution<T>(
  budgetMs: number,
  fallback: T
): (fn: () => Promise<T>) => Promise<T> {
  return async (fn) => {
    const controller = new AbortController();
    const timeout = setTimeout(() => controller.abort(), budgetMs);
 
    try {
      const result = await fn();
      clearTimeout(timeout);
      return result;
    } catch (error) {
      clearTimeout(timeout);
      if ((error as Error).name === 'AbortError') {
        console.warn(`Budget exceeded: ${budgetMs}ms`);
        return fallback;
      }
      throw error;
    }
  };
}

// utils/costTracker.ts — APIコストの追跡
 
interface CostEntry {
  provider: string;
  inputTokens: number;
  outputTokens: number;
  imageCount: number;
  estimatedCostUSD: number;
  timestamp: number;
}
 
// 月間コスト上限の管理
const MONTHLY_BUDGET_USD = 50;
 
export class CostTracker {
  private entries: CostEntry[] = [];
 
  addEntry(entry: CostEntry) {
    this.entries.push(entry);
  }
 
  getMonthlyTotal(): number {
    const now = new Date();
    const monthStart = new Date(now.getFullYear(), now.getMonth(), 1).getTime();
    return this.entries
      .filter(e => e.timestamp >= monthStart)
      .reduce((sum, e) => sum + e.estimatedCostUSD, 0);
  }
 
  isWithinBudget(): boolean {
    return this.getMonthlyTotal() < MONTHLY_BUDGET_USD;
  }
 
  // 予算超過時はオンデバイスモデルのみに制限
  shouldUseCloudAI(): boolean {
    return this.isWithinBudget();
  }
}

// プログレッシブにモダリティを開示するヘルパー
class ModalityProgressionManager {
  // セッション数と直近の成功体験で「次に見せていい入力」を決める
  static getEnabledModalities(
    sessionCount: number,
    lastResultRating: number | null
  ): InputModality[] {
    if (sessionCount === 0) return ["text"]; // 初回はテキストだけ
    if (sessionCount < 3) return ["text", "camera"]; // 数回はテキスト+カメラ
 
    // 直近の結果評価が3以上のユーザーだけ、音声まで開放する
    if (lastResultRating !== null && lastResultRating >= 3) {
      return ["text", "camera", "voice"];
    }
 
    return ["text", "camera"];
  }
}

// 3段オーケストレーション
async function tieredMultimodalCall(ctx: MultimodalContext): Promise<AIResponse> {
  // 1段目: Gemini 2.0 Flash
  const firstPass = await callGemini(ctx);
  if (firstPass.confidence >= 0.6) return firstPass;
 
  // 2段目: Claude Haiku（テキスト中心の問題に強い）
  const secondPass = await callClaudeHaiku(ctx, { previousAttempt: firstPass });
  if (secondPass.confidence >= 0.6) return secondPass;
 
  // 3段目: ユーザーに追加情報を求める（API呼び出しなし）
  return {
    type: "clarification_needed",
    suggestedQuestions: secondPass.clarifyingQuestions ?? defaultClarifyingQuestions,
  };
}

class SilenceConfirmAudioRecorder {
  private silenceThresholdMs = 3000; // 3秒
  private lastVoiceAt = Date.now();
  private silenceTimer: NodeJS.Timeout | null = null;
 
  onAudioFrame(volume: number, onFinish: () => void) {
    if (volume > 0.05) {
      // 話し始めたらタイマーをクリア
      this.lastVoiceAt = Date.now();
      if (this.silenceTimer) {
        clearTimeout(this.silenceTimer);
        this.silenceTimer = null;
      }
      return;
    }
 
    // 沈黙が始まったら3秒タイマー
    if (!this.silenceTimer) {
      this.silenceTimer = setTimeout(() => {
        onFinish(); // 確定して送信
      }, this.silenceThresholdMs);
    }
  }
}

import { manipulateAsync, SaveFormat } from "expo-image-manipulator";
 
// 短辺 1024px を保つリサイズ
async function resizeForGemini(localUri: string): Promise<string> {
  const result = await manipulateAsync(
    localUri,
    [{ resize: { width: 1024 } }], // Expoは width だけ指定すれば短辺扱いではなく幅、ただし大半の写真は横長なので短辺になる
    { compress: 0.85, format: SaveFormat.JPEG }
  );
  return result.uri;
}

// __tests__/smoke/coreml-fallback.smoke.test.ts
describe("Core ML fallback smoke", () => {
  beforeAll(() => {
    // ネットワークを意図的に切る（クラウドが死んでいる状況を模す）
    jest.spyOn(global, "fetch").mockRejectedValue(new Error("offline"));
  });
 
  it("画像分類がオンデバイスで完走する", async () => {
    const result = await classifyImage("./__fixtures__/sample-landscape.jpg");
    expect(result.source).toBe("on-device");
    expect(result.labels.length).toBeGreaterThan(0);
  });
 
  it("テキスト分類がオンデバイスで完走する", async () => {
    const result = await classifyText("こんにちは、今日はいい天気ですね");
    expect(result.source).toBe("on-device");
    expect(result.sentiment).toBeDefined();
  });
});