Proactive Service Agents 2026: Arsitektur Partially Observable Sequential Decision, Intervention Gating, dan Recoverable Execution pada Autonomous AI

// Proactive Service Agent POSDP Decision Engine & Intervention Gating Kernel
// Berdasarkan Formulasi Matematis Unified Decision Framework (arXiv:2609.03727, September 2026)
// Mengimplementasikan Constrained Partially Observable Sequential Decision Making

export type InterventionMode = 'silent' | 'ask' | 'assist' | 'act';

export interface UserBeliefState {
  latentObjectiveId: string;
  needProbability: number; // p = P(N = 1 | b)
  userInterruptibility: number; // 0.0 (busy/focused) - 1.0 (receptive)
  taskUncertaintyEntropy: number; // H(U | o)
  contextTimestamp: number;
}

export interface AuthorizationLedger {
  grantedPermissions: Set;
  explicitDelegationTokens: string[];
  maxIrreversibleActionTier: number; // 0: Read-only, 1: Idempotent Write, 2: Destructive/Monetary
}

export interface StructuredCandidateAction {
  id: string;
  mode: InterventionMode;
  targetSubgoal: string;
  payloadAction: string;
  estimatedImmediateReward: number; // r(s, a)
  interruptionCost: number; // c_interrupt
  misunderstandingRiskCost: number; // c_risk
  privacyDisclosureCost: number; // c_privacy
  executionReversibilityCost: number; // c_undo
  requiredPermission?: string;
  requiredActionTier: number;
}

export interface GatingDecisionTelemetry {
  selectedAction: StructuredCandidateAction;
  interventionAdvantage: number; // Delta_eta(b, kappa)
  optionValueOfWaiting: number; // Q*(b, kappa, silent)
  decisionValueOfAsking?: number; // VoI(q)
  gatePassed: boolean;
  shadowPricePenalties: number;
}

export class ProactiveServiceKernel {
  private readonly gammaDiscount: number;
  private readonly shadowPrices: {
    interruption: number; // eta_1
    risk: number;         // eta_2
    privacy: number;      // eta_3
  };

  constructor(
    gamma: number = 0.95,
    shadowPrices = { interruption: 1.4, risk: 2.5, privacy: 1.8 }
  ) {
    this.gammaDiscount = gamma;
    this.shadowPrices = shadowPrices;
  }

  /**
   * 1. Evaluasi Hard Feasibility & Authorization Ledger Constraints
   * Tindakan 'act' yang tidak memiliki token otorisasi eksplisit langsung didiskualifikasi (Admissibility Barrier).
   */
  public filterAdmissibleActions(
    candidates: StructuredCandidateAction[],
    ledger: AuthorizationLedger
  ): StructuredCandidateAction[] {
    return candidates.filter((action) => {
      if (action.mode === 'silent') return true;
      if (action.requiredActionTier > ledger.maxIrreversibleActionTier) return false;
      if (action.requiredPermission && !ledger.grantedPermissions.has(action.requiredPermission)) {
        return false;
      }
      return true;
    });
  }

  /**
   * 2. Hitung Lagrangian-Relaxed Expected Reward: r_eta(s, a)
   */
  public computeRelaxedReward(action: StructuredCandidateAction, belief: UserBeliefState): number {
    if (action.mode === 'silent') {
      return 0.0; // Baseline netral
    }

    const softPenalty = 
      this.shadowPrices.interruption * (action.interruptionCost * (1.0 - belief.userInterruptibility)) +
      this.shadowPrices.risk * (action.misunderstandingRiskCost * belief.taskUncertaintyEntropy) +
      this.shadowPrices.privacy * action.privacyDisclosureCost;

    // Expected value proporsional terhadap estimasi kebutuhan nyata user
    const expectedGrossBenefit = action.estimatedImmediateReward * belief.needProbability;
    return expectedGrossBenefit - softPenalty;
  }

  /**
   * 3. Estimasi Option Value of Waiting vs Intervention Advantage
   * Delta_eta(b, kappa) = max_{a != silent} Q*(b, kappa, a) - Q*(b, kappa, silent)
   */
  public evaluateInterventionGating(
    belief: UserBeliefState,
    ledger: AuthorizationLedger,
    candidates: StructuredCandidateAction[],
    estimatedFutureSilentValue: number = 1.2
  ): GatingDecisionTelemetry {
    const admissible = this.filterAdmissibleActions(candidates, ledger);

    // Q*(b, kappa, silent) merefleksikan opsi menunggu datangnya observasi berikutnya yang lebih jelas
    const qSilent = this.gammaDiscount * estimatedFutureSilentValue;

    let bestNonSilentAction: StructuredCandidateAction | null = null;
    let maxNonSilentQ = -Infinity;

    for (const act of admissible) {
      if (act.mode === 'silent') continue;

      const immediateRelaxed = this.computeRelaxedReward(act, belief);
      // Asumsi nilai masa depan setelah aksi (termasuk branching feedback user)
      const qValue = immediateRelaxed + this.gammaDiscount * (act.mode === 'ask' ? 1.5 : 1.1);

      if (qValue > maxNonSilentQ) {
        maxNonSilentQ = qValue;
        bestNonSilentAction = act;
      }
    }

    // Conservative Tie-Breaking: Jika Delta_eta <= 0, agen WAJIB memilih silent
    const deltaInterventionAdvantage = maxNonSilentQ - qSilent;
    const shouldIntervene = deltaInterventionAdvantage > 0.0 && bestNonSilentAction !== null;

    const chosenAction = shouldIntervene
      ? bestNonSilentAction!
      : {
          id: 'action-silent-wait',
          mode: 'silent' as InterventionMode,
          targetSubgoal: 'observe_stream',
          payloadAction: 'maintain_passive_monitoring',
          estimatedImmediateReward: 0,
          interruptionCost: 0,
          misunderstandingRiskCost: 0,
          privacyDisclosureCost: 0,
          executionReversibilityCost: 0,
          requiredActionTier: 0,
        };

    return {
      selectedAction: chosenAction,
      interventionAdvantage: Number(deltaInterventionAdvantage.toFixed(4)),
      optionValueOfWaiting: Number(qSilent.toFixed(4)),
      gatePassed: shouldIntervene,
      shadowPricePenalties: this.computeRelaxedReward(chosenAction, belief),
    };
  }
}