@nauticana/sail 1.1.32 → 1.1.34

package/src/agent/model/agent_studio.ts

@@ -1,6 +1,7 @@
-/** Agent Studio `studio-v2` wire types. Field names are the backend's JSON names. */
+/** Agent Studio wire types (Scout v1.2.7). Field names are the backend's JSON names. */
 
-export type AgentMergeMode = 'append' | 'replace';
+/** R replace, A append, I intersect (non-prompt settings only). */
+export type AgentMergeMode = 'R' | 'A' | 'I';
 export type AgentResetScope = 'agent_override' | 'type_default' | 'platform_baseline';
 
 export interface AgentSummary {
@@ -10,6 +11,7 @@ export interface AgentSummary {
   purpose: string;
   enabled: boolean;
   is_default: boolean;
+  archived: boolean;
   readiness: string;
   readiness_reason: string;
   type_defaults_revision: number;
@@ -35,10 +37,6 @@ export interface AgentModelSelection {
   video_model: string;
 }
 
-export interface AgentApprovalPolicy {
-  require_approval: boolean;
-}
-
 /** One contribution to a prompt section. `editable` is response-only. */
 export interface AgentPromptLayer {
   scope_id: string;
@@ -48,6 +46,8 @@ export interface AgentPromptLayer {
   editable: boolean;
   instruction: string;
   output: string;
+  /** Who last edited the layer; absent on the baseline. */
+  bound_by?: number;
 }
 
 export interface AgentPromptSection {
@@ -77,7 +77,6 @@ export interface AgentDraft {
   display_name: string;
   enabled: boolean;
   is_default: boolean;
-  approval_policy: AgentApprovalPolicy;
   models: AgentModelSelection;
   languages: AgentLanguageDraft[];
   agent_scope_id?: string;
@@ -103,6 +102,7 @@ export interface AgentTestResult {
   latency_ms: number;
   input_tokens: number;
   output_tokens: number;
+  /** Cost in minor units. */
   credits: number;
   sections: string[];
 }
@@ -110,6 +110,10 @@ export interface AgentTestResult {
 export interface AgentPublishRequest {
   agent_name: string;
   change_summary: string;
+  /** 1–99 deploys the release as a canary. */
+  canary_percentage?: number;
+  /** RFC 3339; a future time schedules the release. */
+  effective_at?: string;
   expected_agent_revision: number;
   expected_type_defaults_revision: number;
 }
@@ -137,6 +141,7 @@ export interface AgentSetDefaultRequest {
 export interface AgentSetEnabledRequest {
   agent_name: string;
   enabled: boolean;
+  reason?: string;
   expected_agent_revision: number;
 }
 
@@ -151,19 +156,41 @@ export interface AgentRelease {
   version: number;
   enabled: boolean;
   models: AgentModelSelection;
-  require_approval: boolean;
   definition_digest: string;
   change_summary: string;
   published_by: number;
   published_at: string;
   active: boolean;
   languages: string[];
+  activation?: ReleaseActivation;
+}
+
+/** A scheduled publish; state P pending, A activated, R refused, X cancelled. */
+export interface ReleaseActivation {
+  id: number;
+  agent_name: string;
+  version: number;
+  definition_digest: string;
+  canary_percentage?: number;
+  effective_at: string;
+  state: 'P' | 'A' | 'R' | 'X';
+  scheduled_by: string;
+  scheduled_at: string;
+  attempts: number;
+  next_attempt_at?: string;
+  reason?: string;
+  detail?: string;
+  decided_by?: string;
+  decided_at?: string;
 }
 
 export interface AgentAuditEvent {
   event: string;
   detail: string;
-  user_id: number;
+  actor_kind?: string;
+  actor_id?: string;
+  /** Set only when a person acted. */
+  user_id?: number;
   event_time: string;
 }
 
@@ -196,3 +223,89 @@ export interface StudioModel {
   image_credits: number;
   video_credits_per_sec: number;
 }
+
+/** One optional Studio API the backend mounted. Unknown ids are ignored; grants still decide. */
+export interface StudioFeature {
+  id: string;
+  version: number;
+  actions: string[];
+  /** Authorization object of the actions; empty is AGENT_STUDIO. */
+  object?: string;
+}
+
+/** `copy_from` and `template_id` are exclusive. */
+export interface AgentCreateRequest {
+  agent_type: string;
+  display_name: string;
+  copy_from?: string;
+  template_id?: string;
+  template_version?: number;
+  references?: Record<string, Record<string, string>>;
+  idempotency_key: string;
+}
+
+export interface AgentRenameRequest {
+  agent_name: string;
+  display_name: string;
+  expected_agent_revision: number;
+}
+
+export interface AgentArchiveRequest {
+  agent_name: string;
+  expected_agent_revision: number;
+}
+
+export interface AgentSettingSource {
+  scope_id: string;
+  scope_kind: string;
+  resource_version: string;
+  merge_mode: AgentMergeMode;
+  sealed: boolean;
+}
+
+/** One binding on the agent's scope chain; `editable` marks the agent's and its type's scopes. */
+export interface AgentSetting {
+  scope_id: string;
+  scope_kind: string;
+  editable: boolean;
+  resource_kind: string;
+  resource_id: string;
+  resource_version: string;
+  merge_mode: AgentMergeMode;
+  sealed: boolean;
+  value: unknown;
+}
+
+export interface AgentEffectiveSetting {
+  resource_kind: string;
+  resource_id: string;
+  value: unknown;
+  source: AgentSettingSource;
+  superseded?: AgentSettingSource[];
+}
+
+/** Bindings other than prompt sections; `problem` says why they do not compile. */
+export interface AgentSettings {
+  agent_name: string;
+  agent_scope_id: string;
+  type_scope_id: string;
+  bindings: AgentSetting[];
+  effective: AgentEffectiveSetting[];
+  problem?: string;
+  expected_agent_revision: number;
+  expected_type_defaults_revision: number;
+}
+
+/** Binds, or with `remove` ends, one resource at the agent or type scope. */
+export interface AgentSettingChange {
+  agent_name: string;
+  scope_id: string;
+  resource_kind: string;
+  resource_id: string;
+  merge_mode?: AgentMergeMode;
+  sealed: boolean;
+  value?: unknown;
+  remove: boolean;
+  expected_agent_revision: number;
+  expected_type_defaults_revision: number;
+}

package/src/agent/model/approval.ts

@@ -0,0 +1,42 @@
+/** Scout approval desk wire types (v1.2.7). Codes render through backend captions. */
+
+/** A approved, X rejected, E edited (tool-call proposals only, with revised arguments). */
+export type ApprovalVerdict = 'A' | 'X' | 'E';
+
+export interface ApproverReference {
+  kind: string;
+  ref: string;
+}
+
+/** One decision a reviewer owes; evidence stays behind its own authorization. */
+export interface ApprovalRequest {
+  request_id: string;
+  execution_step_id: number;
+  conversation_id: string;
+  scope_id?: string;
+  rule_id: string;
+  action: string;
+  resource: string;
+  output_class: string;
+  risk_tier: string;
+  summary: string;
+  proposed_digest: string;
+  status: string;
+  deadline_at?: string;
+  created_at: string;
+  revises_step_id?: number;
+  rule_source: string;
+  route_id?: string;
+  route_step: number;
+  approver_reference?: ApproverReference;
+}
+
+export interface ApprovalResolveRequest {
+  request_id: string;
+  execution_step_id: number;
+  verdict: ApprovalVerdict;
+  proposed_digest: string;
+  reason?: string;
+  /** The JSON object an `E` verdict runs the tool call with instead. */
+  revised_arguments?: Record<string, unknown>;
+}

package/src/agent/model/conversation.ts

@@ -4,7 +4,15 @@ import { InjectionToken } from '@angular/core';
 export interface ConversationTurnRequest {
   request_id: string;
   conversation_id: string;
-  agent_id: string;
+  /** The agent type alias; its default agent serves a new conversation. */
+  agent_type: string;
+  /** One agent of that type instead of its default. */
+  agent_name?: string;
+  /** Pins a new conversation to one release; needs `release_reason`. */
+  release?: string;
+  release_reason?: string;
+  /** The product's opaque reference to the work the turn serves. */
+  work_ref?: string;
   /** Opaque product payload; the backend forwards it to the agent unread. */
   input: unknown;
 }

package/src/agent/model/decision.ts

@@ -1,6 +1,7 @@
 import { ObjectRef } from './turn_event';
 
-export type DecisionOutcome = 'allow' | 'deny' | 'pending';
+/** A allowed, D denied, P pending (`audit_decision_outcome`). */
+export type DecisionOutcome = 'A' | 'D' | 'P';
 
 export interface PrincipalRef {
   kind: string;

package/src/agent/model/turn_event.ts

@@ -10,6 +10,7 @@ export const TURN_EVENT_KINDS = [
   'effect',
   'progress',
   'result',
+  'citations',
   'extension',
 ] as const;
 
@@ -73,6 +74,14 @@ export interface TurnExtensionEvent {
   payload?: unknown;
 }
 
+export interface Citation {
+  url: string;
+  domain?: string;
+  title?: string;
+  snippet?: string;
+  position: number;
+}
+
 export interface TurnEvent {
   v: number;
   kind: TurnEventKind;
@@ -83,6 +92,7 @@ export interface TurnEvent {
   effect?: TurnEffectEvent;
   progress?: TurnProgressEvent;
   extension?: TurnExtensionEvent;
+  citations?: Citation[];
 }
 
 const knownKinds: ReadonlySet<string> = new Set(TURN_EVENT_KINDS);

package/src/agent/service/agent_studio.service.ts

@@ -2,27 +2,38 @@ import { Injectable } from '@angular/core';
 import { Observable } from 'rxjs';
 import { BaseRestService } from '../../service/base_rest.service';
 import {
+  AgentArchiveRequest,
   AgentAuditEvent,
+  AgentCreateRequest,
   AgentDraft,
   AgentEnabledState,
   AgentPublishRequest,
   AgentRelease,
   AgentReleaseSection,
+  AgentRenameRequest,
   AgentResetRequest,
   AgentRestoreRequest,
   AgentSetDefaultRequest,
   AgentSetEnabledRequest,
+  AgentSettingChange,
+  AgentSettings,
   AgentSummary,
   AgentTestRequest,
   AgentTestResult,
+  StudioFeature,
   StudioModel,
 } from '../model/agent_studio';
 
 const studioBasePath = '/api/agent-studio/';
 
-/** Client for the `studio-v2` Agent Studio routes, which are fixed and unversioned. */
+/** Client for Scout's core Agent Studio routes, which are fixed and unversioned. */
 @Injectable({ providedIn: 'root' })
 export class AgentStudioService extends BaseRestService {
+  /** The optional Studio APIs the backend mounted; `agents` is the core set. */
+  features(): Observable<StudioFeature[]> {
+    return this.http.get<StudioFeature[]>(this.studioUrl('features'));
+  }
+
   listAgents(): Observable<AgentSummary[]> {
     return this.http.get<AgentSummary[]>(this.studioUrl('agents'));
   }
@@ -36,6 +47,30 @@ export class AgentStudioService extends BaseRestService {
     return this.http.post<AgentDraft>(this.studioUrl('draft'), draft);
   }
 
+  create(request: AgentCreateRequest): Observable<AgentSummary> {
+    return this.http.post<AgentSummary>(this.studioUrl('create'), request);
+  }
+
+  rename(request: AgentRenameRequest): Observable<AgentSummary> {
+    return this.http.post<AgentSummary>(this.studioUrl('rename'), request);
+  }
+
+  archive(request: AgentArchiveRequest): Observable<AgentSummary> {
+    return this.http.post<AgentSummary>(this.studioUrl('archive'), request);
+  }
+
+  unarchive(request: AgentArchiveRequest): Observable<AgentSummary> {
+    return this.http.post<AgentSummary>(this.studioUrl('unarchive'), request);
+  }
+
+  settings(agentName: string): Observable<AgentSettings> {
+    return this.http.get<AgentSettings>(this.studioUrl('settings'), { params: { agent_name: agentName } });
+  }
+
+  saveSetting(change: AgentSettingChange): Observable<AgentSettings> {
+    return this.http.post<AgentSettings>(this.studioUrl('setting'), change);
+  }
+
   setEnabled(request: AgentSetEnabledRequest): Observable<AgentEnabledState> {
     return this.http.post<AgentEnabledState>(this.studioUrl('enabled'), request);
   }

package/src/agent/service/approval.service.ts

@@ -0,0 +1,18 @@
+import { Injectable } from '@angular/core';
+import { Observable } from 'rxjs';
+import { BaseRestService } from '../../service/base_rest.service';
+import { ApprovalRequest, ApprovalResolveRequest } from '../model/approval';
+
+/** Client for Scout's approval desk under the fixed `/api/approval/` path. */
+@Injectable({ providedIn: 'root' })
+export class ApprovalService extends BaseRestService {
+  /** The requests the signed-in person may decide now, soonest deadline first. */
+  pending(): Observable<ApprovalRequest[]> {
+    return this.http.get<ApprovalRequest[]>(this.url('/api/approval/pending'));
+  }
+
+  /** 409 when the request was reassigned or decided differently since it was read. */
+  resolve(request: ApprovalResolveRequest): Observable<ApprovalRequest> {
+    return this.http.post<ApprovalRequest>(this.url('/api/approval/resolve'), request);
+  }
+}

package/src/agent/util/release_diff.ts

@@ -0,0 +1,33 @@
+import { AgentReleaseSection } from '../model/agent_studio';
+
+export interface ReleaseSectionDiff {
+  language_code: string;
+  prompt_header_id: number;
+  caption: string;
+  status: 'added' | 'changed' | 'removed';
+  old_text: string;
+  new_text: string;
+}
+
+/**
+ * Section changes from `prior` to `current`, keyed by language and prompt header. Caption and
+ * description are part of the compiled prompt, so they count; so does a pure reordering.
+ */
+export function diffReleaseSections(prior: AgentReleaseSection[], current: AgentReleaseSection[]): ReleaseSectionDiff[] {
+  const key = (s: AgentReleaseSection) => `${s.language_code}#${s.prompt_header_id}`;
+  const text = (s: AgentReleaseSection) =>
+    `${s.description ? `${s.caption} — ${s.description}` : s.caption}\n${s.output ? `${s.instruction}\n\nOutput: ${s.output}` : s.instruction}`;
+  const row = (s: AgentReleaseSection, status: ReleaseSectionDiff['status'], old_text: string, new_text: string): ReleaseSectionDiff =>
+    ({ language_code: s.language_code, prompt_header_id: s.prompt_header_id, caption: s.caption, status, old_text, new_text });
+  const remaining = new Map(prior.map((s) => [key(s), s]));
+  const rows: ReleaseSectionDiff[] = [];
+  for (const section of current) {
+    const old = remaining.get(key(section));
+    remaining.delete(key(section));
+    if (!old) rows.push(row(section, 'added', '', text(section)));
+    else if (text(old) !== text(section)) rows.push(row(section, 'changed', text(old), text(section)));
+    else if (old.sequence !== section.sequence) rows.push(row(section, 'changed', `position ${old.sequence}`, `position ${section.sequence}`));
+  }
+  for (const old of remaining.values()) rows.push(row(old, 'removed', text(old), ''));
+  return rows;
+}

package/src/agent/util/studio_errors.ts

@@ -1,3 +1,4 @@
+import { errorDetail } from '../../util/errors';
 import { AgentFieldError, AgentValidationProblem } from '../model/agent_studio';
 
 /**
@@ -59,3 +60,13 @@ export function retryAfterSeconds(err: unknown): number | undefined {
   const seconds = Number(raw);
   return Number.isFinite(seconds) && seconds >= 0 ? seconds : undefined;
 }
+
+/** One message for a failed Studio call: the conflict cause, the field errors, or the detail. */
+export function studioErrorMessage(err: unknown, fallback = 'Request failed.'): string {
+  const cause = studioConflictCause(err);
+  if (cause === 'revision') return 'This agent changed since you opened it. Reload and reapply your edits.';
+  if (cause === 'sealed') return 'A wider scope sealed this section, so narrower layers cannot change it.';
+  const fields = studioFieldErrors(err);
+  if (fields.length > 0) return fields.map((f) => `${f.field}: ${f.message}`).join('; ');
+  return errorDetail(err, fallback);
+}

package/src/agent/util/turn_timeline.ts

@@ -1,4 +1,5 @@
 import {
+  Citation,
   EvidenceRef,
   TurnApprovalEvent,
   TurnEffectEvent,
@@ -31,6 +32,7 @@ export type TurnTimelineItem =
   | { kind: 'evidence'; refs: EvidenceRef[] }
   | { kind: 'progress'; progress: TurnProgressEvent }
   | { kind: 'extension'; extension: TurnExtensionEvent }
+  | { kind: 'citations'; citations: Citation[] }
   | { kind: 'result' };
 
 function errorClassOf(tool: TurnToolEvent): string | undefined {
@@ -62,7 +64,8 @@ export function buildTurnTimeline(events: readonly unknown[]): TurnTimelineItem[
   };
 
   const applyApproval = (approval: TurnApprovalEvent | undefined, state: ToolCallApproval): void => {
-    if (!approval) return;
+    // A turn-level suspension carries an empty approval; turn status shows it, not a tool row.
+    if (!approval?.call_id) return;
     const call = callFor(approval);
     call.approval = state;
     call.decision = approval.decision;
@@ -106,6 +109,9 @@ export function buildTurnTimeline(events: readonly unknown[]): TurnTimelineItem[
       case 'extension':
         if (event.extension) items.push({ kind: 'extension', extension: event.extension });
         break;
+      case 'citations':
+        if (event.citations?.length) items.push({ kind: 'citations', citations: event.citations });
+        break;
       case 'result':
         items.push({ kind: 'result' });
         break;

package/src/component/login/account_deletion.html

@@ -13,10 +13,23 @@
         <input matInput formControlName="confirm" autocomplete="off" required>
       </mat-form-field>
 
-      <mat-form-field appearance="outline">
-        <mat-label>Confirm your password</mat-label>
-        <input matInput type="password" formControlName="password" autocomplete="current-password" required>
-      </mat-form-field>
+      @if (method() === 'password') {
+        <mat-form-field appearance="outline">
+          <mat-label>Confirm your password</mat-label>
+          <input matInput type="password" formControlName="credential" autocomplete="current-password" required>
+        </mat-form-field>
+      } @else {
+        <button matButton type="button" [disabled]="loading()" (click)="sendCode()">
+          {{ codeSent() ? 'Resend code' : 'Send me a code' }}
+        </button>
+        <mat-form-field appearance="outline">
+          <mat-label>One-time code</mat-label>
+          <input matInput formControlName="credential" inputmode="numeric" autocomplete="one-time-code" required>
+        </mat-form-field>
+      }
+      <button matButton type="button" (click)="toggleMethod()">
+        {{ method() === 'password' ? 'Use a one-time code instead' : 'Use my password instead' }}
+      </button>
 
       <mat-form-field appearance="outline">
         <mat-label>Reason (optional)</mat-label>

package/src/component/login/account_deletion.ts

@@ -1,7 +1,7 @@
 import {
-  ChangeDetectionStrategy, Component, ViewEncapsulation, computed, inject, input, signal,
+  ChangeDetectionStrategy, Component, ViewEncapsulation, computed, inject, input, linkedSignal, signal,
 } from '@angular/core';
-import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { toSignal } from '@angular/core/rxjs-interop';
 import { FormBuilder, ReactiveFormsModule, Validators } from '@angular/forms';
 import { MatButtonModule } from '@angular/material/button';
 import { MatFormFieldModule } from '@angular/material/form-field';
@@ -10,18 +10,17 @@ import { Router, RouterLink } from '@angular/router';
 import { BaseAsync } from '../abstract/base_async';
 import { BaseAuthService } from '../../service/auth.service';
 import { SAIL_GUI_CONFIG, SailGuiConfig, DEFAULT_CONFIG } from '../../config';
+import { ReauthCredentials } from '../../model/auth';
 
 /**
  * AccountDeletionComponent — App Store / Play Store compliance surface.
  *
- * Typed-confirmation UX (standard anti-fat-finger pattern): user must type
- * the literal `confirmationText` (default "DELETE") before the destructive
- * button enables. Optional `reason` textarea forwarded to the backend's
- * DELETE /api/user/account for the audit trail.
- *
- * On success: local session cleared by BaseAuthService.deleteAccount; this
- * component then navigates to `config.accountDeletedRoute` (default
- * `/login/local`).
+ * The destructive button enables once the user types `confirmationText`
+ * (default "DELETE") and re-authenticates with a password or, for accounts
+ * without one, a one-time code (`reauthMethod`, switchable in the form).
+ * The optional reason is forwarded to DELETE /api/user/account for audit.
+ * On success the session is cleared and the router goes to
+ * `config.accountDeletedRoute` (default `/login/local`).
  */
 @Component({
   selector: 'sail-account-deletion',
@@ -44,37 +43,45 @@ export class AccountDeletionComponent extends BaseAsync {
     inject(SAIL_GUI_CONFIG, { optional: true }) ?? DEFAULT_CONFIG;
 
   readonly confirmationText = input('DELETE');
+  readonly reauthMethod = input<'password' | 'code'>('password');
+  readonly method = linkedSignal(() => this.reauthMethod());
+  readonly codeSent = signal(false);
 
   readonly form = this.fb.nonNullable.group({
-    confirm:  ['', Validators.required],
-    password: ['', Validators.required],   // re-auth gate required by keel
-    reason:   [''],
+    confirm:    ['', Validators.required],
+    credential: ['', Validators.required],
+    reason:     [''],
   });
 
-  readonly typedValue = signal('');
-  private readonly passwordValue = signal('');
+  private readonly confirmValue = toSignal(this.form.controls.confirm.valueChanges, { initialValue: '' });
+  private readonly credentialValue = toSignal(this.form.controls.credential.valueChanges, { initialValue: '' });
   readonly canSubmit = computed(() =>
-    this.typedValue() === this.confirmationText() &&
-    !!this.passwordValue() &&
+    this.confirmValue() === this.confirmationText() &&
+    !!this.credentialValue() &&
     !this.loading(),
   );
 
-  constructor() {
-    super();
-    this.form.controls.confirm.valueChanges
-      .pipe(takeUntilDestroyed())
-      .subscribe((v) => this.typedValue.set(v ?? ''));
-    this.form.controls.password.valueChanges
-      .pipe(takeUntilDestroyed())
-      .subscribe((v) => this.passwordValue.set(v ?? ''));
+  toggleMethod() {
+    this.method.update((m) => m === 'password' ? 'code' : 'password');
+    this.codeSent.set(false);
+    this.form.controls.credential.reset();
+    this.clearMessages();
+  }
+
+  sendCode() {
+    this.run(this.auth.sendReauthCode(), (res) => {
+      this.codeSent.set(true);
+      this.successMessage.set(`A code was sent to your ${res.channel}.`);
+    }, 'Failed to send a code. Please try again.');
   }
 
   onDelete() {
     if (!this.canSubmit()) return;
-    const password = this.form.controls.password.value;
-    const reason = this.form.controls.reason.value?.trim() || undefined;
+    const credential = this.form.controls.credential.value;
+    const reauth: ReauthCredentials = this.method() === 'code' ? { reauthCode: credential } : { password: credential };
+    const reason = this.form.controls.reason.value.trim() || undefined;
     this.run(
-      this.auth.deleteAccount({ password }, reason),
+      this.auth.deleteAccount(reauth, reason),
       () => this.router.navigateByUrl(this.guiConfig.accountDeletedRoute ?? '/login/local'),
       'Failed to delete account. Please try again.',
     );

package/src/component/login/login_component.html

@@ -15,6 +15,17 @@
     @if (sessionHandoffError()) {
       <p class="auth-error" role="alert">{{ sessionHandoffError() }}</p>
     }
+    @if (signInPrompt(); as prompt) {
+      <p class="auth-message" role="status">
+        {{ prompt === 'login' ? 'Sign in again to continue.' : 'Choose the account to continue with.' }}
+      </p>
+      <div class="auth-actions">
+        @if (prompt === 'select_account') {
+          <button matButton="elevated" class="primary" type="button" (click)="auth.continueSession()">Continue with the signed-in account</button>
+        }
+        <button matButton type="button" (click)="auth.signOutHere()">Sign out of the current account</button>
+      </div>
+    }
     <form [formGroup]="loginForm" (ngSubmit)="login()" class="auth-form">
       <mat-form-field appearance="outline">
         <mat-label>Username</mat-label>

package/src/component/login/login_component.ts

@@ -27,7 +27,7 @@ import { SsoLoginComponent } from '../sso/sso_login';
   ],
 })
 export class LoginComponent extends BaseAsync {
-  private auth = inject(BaseAuthService);
+  protected readonly auth = inject(BaseAuthService);
   protected fb = inject(FormBuilder);
   protected readonly guiConfig: SailGuiConfig = inject(SAIL_GUI_CONFIG, {optional: true}) ?? DEFAULT_CONFIG;
   private readonly queryParams = inject(ActivatedRoute).snapshot.queryParamMap;
@@ -35,6 +35,7 @@ export class LoginComponent extends BaseAsync {
   protected readonly passwordChanged = this.queryParams.get('passwordChanged') === 'true';
   /** OAuth session hand-off failure from BaseAuthService, shown below. */
   protected readonly sessionHandoffError = this.auth.sessionHandoffError;
+  protected readonly signInPrompt = this.auth.signInPrompt;
 
   /**
    * Auto-show the embedded SocialLoginComponent whenever at least one