feat: real Gemini 2.5 Pro inference + visible streaming

- Replace @google-cloud/vertexai SDK with direct REST + ADC auth.
  Earlier SDK calls returned empty text on Cloud Run; REST is robust
  across SDK versions and exposes the full response shape.
- Surface provider (vertex/anthropic/stub) and model on every AgentTurn,
  rendered as a chip on each turn card so the demo never lies about
  who wrote the line.
- Add SENTINEL_PACE_PHASE_MS / SENTINEL_PACE_TURN_MS so stub-mode runs
  stream phase-by-phase instead of landing in one paint. Real-LLM mode
  uses model latency as the natural pacer (no artificial sleeps).
- Update Dockerfile for Next.js 16 standalone layout (now
  .next/standalone/sentinelcloud/web/server.js).

Author: divyamohan1993

Dockerfile

@@ -24,7 +24,10 @@ ENV NEXT_TELEMETRY_DISABLED=1
 ENV PORT=8080
 ENV HOSTNAME=0.0.0.0
 RUN addgroup --system --gid 1001 nodejs && adduser --system --uid 1001 nextjs
-COPY --from=builder --chown=nextjs:nodejs /app/.next/standalone ./
+# Next.js 16 standalone output places the runtime under
+# `.next/standalone/sentinelcloud/web/` when the build context is the repo root.
+# We flatten that here so the entrypoint stays `node server.js`.
+COPY --from=builder --chown=nextjs:nodejs /app/.next/standalone/sentinelcloud/web/ ./
 COPY --from=builder --chown=nextjs:nodejs /app/.next/static ./.next/static
 COPY --from=builder --chown=nextjs:nodejs /app/public ./public
 USER nextjs

web/components/RunStage.tsx

@@ -208,10 +208,24 @@ function TurnCard({ turn }: { turn: any }) {
     critic: 'border-[#aab1c5]/30 text-[#aab1c5]',
     narrator: 'border-white/30 text-white',
   };
+  const providerTone: Record<string, string> = {
+    vertex: 'border-[#5b8cff]/40 text-[#5b8cff]',
+    anthropic: 'border-[#fb923c]/40 text-[#fb923c]',
+    stub: 'border-[var(--color-fg-3)]/40 text-[var(--color-fg-3)]',
+  };
+  const provider = turn.provider as string | undefined;
+  const model = turn.model as string | undefined;
   return (
     <div className="glass p-3.5">
-      <div className="flex items-center justify-between mb-1.5">
-        <div className={`text-[11px] uppercase tracking-wider px-2 py-0.5 rounded border ${tone[role] || ''}`}>{role}</div>
+      <div className="flex items-center justify-between mb-1.5 gap-2">
+        <div className="flex items-center gap-1.5 flex-wrap">
+          <div className={`text-[11px] uppercase tracking-wider px-2 py-0.5 rounded border ${tone[role] || ''}`}>{role}</div>
+          {provider && (
+            <div className={`text-[10px] uppercase tracking-wider px-1.5 py-0.5 rounded border ${providerTone[provider] || ''}`} title={model || provider}>
+              {provider === 'vertex' ? 'gemini' : provider === 'anthropic' ? 'claude' : 'stub'}
+            </div>
+          )}
+        </div>
         <div className="text-[11px] text-[var(--color-fg-3)] font-mono tabular-nums">
           conf {turn.confidence?.toFixed?.(2) ?? '-'} · {turn.latencyMs ?? 0}ms
         </div>

web/lib/agents/agents.ts

@@ -26,6 +26,8 @@ function turn(partial: Partial<AgentTurn> & Pick<AgentTurn, 'agent' | 'runId'>):
     latencyMs: partial.latencyMs ?? 0,
     tokensIn: partial.tokensIn ?? 0,
     tokensOut: partial.tokensOut ?? 0,
+    provider: partial.provider,
+    model: partial.model,
     ts: partial.ts ?? Date.now(),
   };
 }
@@ -45,7 +47,7 @@ export async function runAnalyst(runId: string, signals: Signal[], topology: unk
     thought: j.thought ?? '',
     evidence: Array.isArray(j.evidence) ? j.evidence : [],
     confidence: clamp01(j.confidence),
-    latencyMs: r.latencyMs, tokensIn: r.tokensIn, tokensOut: r.tokensOut,
+    latencyMs: r.latencyMs, tokensIn: r.tokensIn, tokensOut: r.tokensOut, provider: r.provider, model: r.model,
   });
 }
 
@@ -59,7 +61,7 @@ export async function runDevil(runId: string, signals: Signal[], analystThought:
     dissent: j.dissent ?? j.alternativeHypothesis ?? '',
     evidence: Array.isArray(j.evidenceForAlternative) ? j.evidenceForAlternative : [],
     confidence: clamp01(j.confidence),
-    latencyMs: r.latencyMs, tokensIn: r.tokensIn, tokensOut: r.tokensOut,
+    latencyMs: r.latencyMs, tokensIn: r.tokensIn, tokensOut: r.tokensOut, provider: r.provider, model: r.model,
   });
 }
 
@@ -74,7 +76,7 @@ export async function runSafety(
     thought: j.thought ?? '',
     policyViolations: Array.isArray(j.policyViolations) ? j.policyViolations : [],
     confidence: clamp01(j.confidence),
-    latencyMs: r.latencyMs, tokensIn: r.tokensIn, tokensOut: r.tokensOut,
+    latencyMs: r.latencyMs, tokensIn: r.tokensIn, tokensOut: r.tokensOut, provider: r.provider, model: r.model,
   });
 }
 
@@ -99,7 +101,7 @@ export async function runStrategist(
     proposal,
     costDeltaUsd: proposal?.estimatedCostUsdDelta,
     confidence: clamp01(j.confidence),
-    latencyMs: r.latencyMs, tokensIn: r.tokensIn, tokensOut: r.tokensOut,
+    latencyMs: r.latencyMs, tokensIn: r.tokensIn, tokensOut: r.tokensOut, provider: r.provider, model: r.model,
   });
 }
 
@@ -111,7 +113,7 @@ export async function runVerifier(runId: string, proposal: Action, signals: Sign
     runId, agent: 'verifier',
     thought: `${j.thought ?? ''} | predicted=${JSON.stringify(j.predictedKpis ?? {})} | disagreement=${j.disagreementPct ?? '?'}%`,
     confidence: clamp01(j.confidence),
-    latencyMs: r.latencyMs, tokensIn: r.tokensIn, tokensOut: r.tokensOut,
+    latencyMs: r.latencyMs, tokensIn: r.tokensIn, tokensOut: r.tokensOut, provider: r.provider, model: r.model,
   });
 }
 
@@ -124,7 +126,7 @@ export async function runCritic(runId: string, proposal: Action, toolCards: stri
     thought: j.thought ?? '',
     policyViolations: Array.isArray(j.violations) ? j.violations : [],
     confidence: clamp01(j.confidence),
-    latencyMs: r.latencyMs, tokensIn: r.tokensIn, tokensOut: r.tokensOut,
+    latencyMs: r.latencyMs, tokensIn: r.tokensIn, tokensOut: r.tokensOut, provider: r.provider, model: r.model,
   });
 }
 
@@ -137,7 +139,7 @@ export async function runNarrator(runId: string, story: string): Promise<AgentTu
     runId, agent: 'narrator',
     thought: j.summary ?? '',
     confidence: clamp01(j.confidence ?? 0.8),
-    latencyMs: r.latencyMs, tokensIn: r.tokensIn, tokensOut: r.tokensOut,
+    latencyMs: r.latencyMs, tokensIn: r.tokensIn, tokensOut: r.tokensOut, provider: r.provider, model: r.model,
   });
 }
 

web/lib/agents/orchestrator.ts

@@ -29,13 +29,25 @@ export type RunEvent =
   | { type: 'done'; report: RunReport }
   | { type: 'error'; message: string };
 
+// Pacing makes phase events visible to the human watching the screen.
+// Real LLM calls already take 2–10 s each; this is the floor so the stub
+// path also has breathing room. Disabled when a real provider is in use,
+// since model latency is the natural pacer.
+const PACE_PHASE_MS = Number(process.env.SENTINEL_PACE_PHASE_MS || 600);
+const PACE_TURN_MS  = Number(process.env.SENTINEL_PACE_TURN_MS  || 350);
+const sleep = (ms: number) => new Promise<void>(r => setTimeout(r, ms));
+
 export async function* orchestrate(scenario: Scenario): AsyncGenerator<RunEvent, void, void> {
   const runId = `r_${nanoid(12)}`;
   const startedAt = Date.now();
   const turns: AgentTurn[] = [];
   const signals = [...scenario.signals].sort((a, b) => a.ts - b.ts);
+  let stubInUse = false;
 
   const emit = <T extends RunEvent>(e: T) => e;
+  const phasePace = async () => { if (stubInUse && PACE_PHASE_MS > 0) await sleep(PACE_PHASE_MS); };
+  const turnPace  = async () => { if (stubInUse && PACE_TURN_MS  > 0) await sleep(PACE_TURN_MS); };
+  const trackProvider = (t: AgentTurn) => { if (t.provider === 'stub') stubInUse = true; };
 
   try {
     yield emit({ type: 'phase', phase: 'ingest' });
@@ -45,16 +57,25 @@ export async function* orchestrate(scenario: Scenario): AsyncGenerator<RunEvent,
     yield emit({ type: 'memory', episodeIds: recalled.map(r => r.id) });
 
     yield emit({ type: 'phase', phase: 'analyze' });
+    await phasePace();
     const analyst = await runAnalyst(runId, signals, scenario.topology);
+    trackProvider(analyst);
     turns.push(analyst); yield emit({ type: 'turn', turn: analyst });
+    await turnPace();
 
     yield emit({ type: 'phase', phase: 'debate' });
+    await phasePace();
     const devil = await runDevil(runId, signals, analyst.thought);
+    trackProvider(devil);
     turns.push(devil); yield emit({ type: 'turn', turn: devil });
+    await turnPace();
 
     yield emit({ type: 'phase', phase: 'strategize' });
+    await phasePace();
     const strategist = await runStrategist(runId, signals, analyst.thought, devil.dissent || '');
+    trackProvider(strategist);
     turns.push(strategist); yield emit({ type: 'turn', turn: strategist });
+    await turnPace();
 
     if (!strategist.proposal) {
       yield emit({ type: 'error', message: 'Strategist returned no proposal' });
@@ -66,16 +87,24 @@ export async function* orchestrate(scenario: Scenario): AsyncGenerator<RunEvent,
     const blastTurn: AgentTurn = { ...strategist, id: `t_${nanoid(10)}`, blastRadius: blast };
     turns.push(blastTurn);
     yield emit({ type: 'blast', score: blast });
+    await turnPace();
 
     yield emit({ type: 'phase', phase: 'verify' });
+    await phasePace();
     const critic = await runCritic(runId, action, toolCardsAsText());
+    trackProvider(critic);
     turns.push(critic); yield emit({ type: 'turn', turn: critic });
+    await turnPace();
 
     yield emit({ type: 'phase', phase: 'safety' });
+    await phasePace();
     const safety = await runSafety(runId, action, constitutionToText(DEFAULT_CONSTITUTION));
+    trackProvider(safety);
     turns.push(safety); yield emit({ type: 'turn', turn: safety });
+    await turnPace();
 
     yield emit({ type: 'phase', phase: 'policy_gate' });
+    await phasePace();
     const det = checkDeterministic(action, DEFAULT_CONSTITUTION);
     const allViolations = [
       ...det.violations,
@@ -84,6 +113,7 @@ export async function* orchestrate(scenario: Scenario): AsyncGenerator<RunEvent,
     ];
     const policyAllowed = det.allowed && (safety.policyViolations || []).length === 0;
     yield emit({ type: 'policy', allowed: policyAllowed, violations: allViolations });
+    await turnPace();
 
     if (!policyAllowed) {
       action = {
@@ -98,31 +128,40 @@ export async function* orchestrate(scenario: Scenario): AsyncGenerator<RunEvent,
     }
 
     const verifier = await runVerifier(runId, action, signals);
+    trackProvider(verifier);
     turns.push(verifier); yield emit({ type: 'turn', turn: verifier });
+    await turnPace();
 
     yield emit({ type: 'phase', phase: 'confidence_gate' });
+    await phasePace();
     const fused = fuseConfidence(turns);
     const gate = shouldAutoAct(action, fused, blast);
     yield emit({ type: 'gate', auto: gate.auto, threshold: gate.threshold, reason: gate.reason, fusedConfidence: fused });
+    await turnPace();
 
     yield emit({ type: 'action', action });
 
     let outcome: RunReport['outcome'] = 'in_progress';
     let actuationOk = true;
     if (gate.auto && policyAllowed) {
       yield emit({ type: 'phase', phase: 'act' });
+      await phasePace();
       const res = await actuate(action);
       actuationOk = res.ok;
       yield emit({ type: 'actuated', ok: res.ok, details: res.details, artifact: res.artifact });
       outcome = res.ok ? 'auto_resolved' : 'failed';
     } else {
       yield emit({ type: 'phase', phase: 'act' });
+      await phasePace();
       yield emit({ type: 'actuated', ok: true, details: 'Paused for human review (HITL)' });
       outcome = 'hitl_required';
     }
+    await turnPace();
 
     yield emit({ type: 'phase', phase: 'verify_outcome' });
+    await phasePace();
     yield emit({ type: 'phase', phase: 'learn' });
+    await phasePace();
 
     const finishedAt = Date.now();
     const mttrSec = Math.max(1, Math.round((finishedAt - startedAt) / 1000));