オンデバイスAIを一次経路にして、重い処理だけクラウドへ逃がす推論ルーターをRorkアプリに組む

// ai/types.ts
export type Tier = 'cache' | 'on-device' | 'pcc' | 'remote';
 
// タスクの性質。ルーターはこれを見て最低限必要なTierを決める
export interface InferenceTask {
  // 機能の識別子（テレメトリ・キャッシュキーの一部に使う）
  kind: 'summarize' | 'classify' | 'rewrite' | 'caption' | 'chat';
  // 入力本文
  input: string;
  // 画像を伴うか（伴うなら remote まで上げる）
  image?: { uri: string; mime: string };
  // 同じ入力なら同じ出力でよいか（true ならキャッシュ可）
  deterministic: boolean;
  // この機能が許容する最大レイテンシ（ms）。超えそうなら段を上げる/諦める
  latencyBudgetMs: number;
}
 
export interface InferenceResult {
  text: string;
  servedBy: Tier;     // どの段が応答したか（観測用）
  costUsd: number;    // 概算課金額（予算管理に使う）
  cached: boolean;
}

// ai/engine.ts
import type { InferenceTask, InferenceResult, Tier } from './types';
 
export interface Engine {
  tier: Tier;
  // このエンジンがこのタスクを扱えるか（端末性能・画像対応など）
  canHandle(task: InferenceTask): Promise<boolean>;
  // 1回あたりの概算コスト（予算判定に使う。0なら無料）
  estimateCost(task: InferenceTask): number;
  run(task: InferenceTask): Promise<InferenceResult>;
}

// ai/onDeviceEngine.ts
import { NativeModulesProxy } from 'expo-modules-core';
import type { Engine, InferenceTask, InferenceResult } from './types';
 
// expo-modules で実装したネイティブ側（iOSはFoundation Models）への薄い橋
const Native = NativeModulesProxy.OnDeviceAI as
  | { isAvailable(): Promise<boolean>; generate(prompt: string): Promise<string> }
  | undefined;
 
export const onDeviceEngine: Engine = {
  tier: 'on-device',
 
  async canHandle(task: InferenceTask) {
    // ネイティブモジュール未搭載・画像入力・長文は扱わない
    if (!Native) return false;
    if (task.image) return false;
    if (task.input.length > 4000) return false;
    return Native.isAvailable();
  },
 
  estimateCost() {
    return 0; // オンデバイスは無料
  },
 
  async run(task: InferenceTask): Promise<InferenceResult> {
    const text = await Native!.generate(buildPrompt(task));
    return { text, servedBy: 'on-device', costUsd: 0, cached: false };
  },
};
 
function buildPrompt(task: InferenceTask): string {
  // タスク種別ごとに最小限の指示を付ける（オンデバイスは短い指示が安定する）
  const lead: Record<InferenceTask['kind'], string> = {
    summarize: '次の文章を3文以内で要約してください。',
    classify: '次の文章の主題を1語で答えてください。',
    rewrite: '次の文章を丁寧な日本語に整えてください。',
    caption: '内容に合う短い見出しを付けてください。',
    chat: '',
  };
  return `${lead[task.kind]}\n\n${task.input}`;
}

// ai/remoteEngine.ts
import type { Engine, InferenceTask, InferenceResult } from './types';
 
const PROXY_URL = 'https://your-worker.example.com/infer';
 
export const remoteEngine: Engine = {
  tier: 'remote',
 
  async canHandle(task: InferenceTask) {
    // 外部は最後の砦。画像も長文も受ける。ネット接続だけ確認
    return true;
  },
 
  estimateCost(task: InferenceTask) {
    // 入力トークン概算 × 単価（モデル選択は server 側で行う前提のざっくり値）
    const approxTokens = Math.ceil(task.input.length / 3);
    return (approxTokens / 1000) * 0.003; // 概算 USD
  },
 
  async run(task: InferenceTask): Promise<InferenceResult> {
    const res = await fetch(PROXY_URL, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        kind: task.kind,
        input: task.input,
        image: task.image ?? null,
      }),
    });
    if (!res.ok) throw new Error(`remote ${res.status}`);
    const json = (await res.json()) as { text: string; costUsd?: number };
    return {
      text: json.text,
      servedBy: 'remote',
      costUsd: json.costUsd ?? this.estimateCost(task),
      cached: false,
    };
  },
};

// ai/router.ts
import type { Engine, InferenceTask, InferenceResult, Tier } from './types';
 
const TIER_ORDER: Tier[] = ['cache', 'on-device', 'pcc', 'remote'];
 
// タスク種別ごとの「最低限ここまでの段が必要」という下限
function minTierFor(task: InferenceTask): Tier {
  if (task.image) return 'remote';            // 画像はオンデバイスでは扱わない
  if (task.kind === 'chat') return 'pcc';      // 対話は精度優先で最低PCC
  return 'on-device';                          // 分類・要約・整形はオンデバイス起点
}
 
export class AIRouter {
  private spentTodayUsd = 0;
 
  constructor(
    private engines: Engine[],
    private dailyBudgetUsd: number,
  ) {}
 
  private orderedEngines(min: Tier): Engine[] {
    const minIdx = TIER_ORDER.indexOf(min);
    return this.engines
      .filter((e) => TIER_ORDER.indexOf(e.tier) >= minIdx)
      .sort((a, b) => TIER_ORDER.indexOf(a.tier) - TIER_ORDER.indexOf(b.tier));
  }
 
  async route(task: InferenceTask): Promise<InferenceResult> {
    const min = minTierFor(task);
    const candidates = this.orderedEngines(min);
    let lastError: unknown;
 
    for (const engine of candidates) {
      // 予算オーバーする有料段はスキップ（無料段は常に許可）
      const cost = engine.estimateCost(task);
      if (cost > 0 && this.spentTodayUsd + cost > this.dailyBudgetUsd) {
        continue;
      }
      if (!(await engine.canHandle(task))) continue;
 
      try {
        const result = await withTimeout(engine.run(task), task.latencyBudgetMs);
        this.spentTodayUsd += result.costUsd;
        return result;
      } catch (err) {
        // この段が失敗したら次の段へ落とす（フォールバック）
        lastError = err;
        continue;
      }
    }
    throw new Error(`all tiers failed: ${String(lastError)}`);
  }
}
 
// タイムアウト付き実行。超えたら reject してルーターが次段へ
function withTimeout<T>(p: Promise<T>, ms: number): Promise<T> {
  return new Promise((resolve, reject) => {
    const id = setTimeout(() => reject(new Error('timeout')), ms);
    p.then(
      (v) => { clearTimeout(id); resolve(v); },
      (e) => { clearTimeout(id); reject(e); },
    );
  });
}

// ai/cacheEngine.ts
import * as Crypto from 'expo-crypto';
import type { Engine, InferenceTask, InferenceResult } from './types';
 
type Store = {
  get(key: string): Promise<string | null>;
  set(key: string, value: string): Promise<void>;
};
 
export function createCacheEngine(store: Store): Engine {
  return {
    tier: 'cache',
 
    async canHandle(task: InferenceTask) {
      // 非決定的タスク・画像入りはキャッシュ対象外
      return task.deterministic && !task.image;
    },
 
    estimateCost() {
      return 0;
    },
 
    async run(task: InferenceTask): Promise<InferenceResult> {
      const key = await keyFor(task);
      const hit = await store.get(key);
      if (hit === null) {
        // キャッシュミスは「失敗」として投げ、ルーターに次段へ落とさせる
        throw new Error('cache miss');
      }
      return { text: hit, servedBy: 'cache', costUsd: 0, cached: true };
    },
  };
}
 
async function keyFor(task: InferenceTask): Promise<string> {
  return Crypto.digestStringAsync(
    Crypto.CryptoDigestAlgorithm.SHA256,
    `${task.kind}:${task.input}`,
  );
}

// router.route() 内、return 直前に挿入する保存処理の例
if (task.deterministic && result.servedBy !== 'cache') {
  const key = await keyFor(task);        // cacheEngine と同じキー関数を共有
  await cacheStore.set(key, result.text);
}