@nauticana/sail 1.1.18 → 1.1.20

package/src/agent/service/turn_stream.ts

@@ -0,0 +1,70 @@
+import { computed, signal } from '@angular/core';
+import { TURN_ERROR_CANCELED, TurnReplyFrame, TurnStreamStatus } from '../model/reply_frame';
+import { TurnEvent } from '../model/turn_event';
+
+const terminalStatuses: ReadonlySet<TurnStreamStatus> = new Set(['completed', 'canceled', 'failed']);
+
+/**
+ * Client-side state of one turn's reply stream. Transport stays the app's: it feeds frames to
+ * `accept`, reconnects from `cursor()`, and reports an expired replay window. One instance per
+ * turn; not injectable.
+ */
+export class TurnStream {
+  private readonly frames = signal<TurnReplyFrame[]>([]);
+  private readonly state = signal<TurnStreamStatus>('idle');
+  private readonly lastSequence = signal(0);
+
+  readonly status = this.state.asReadonly();
+  /** Last sequence rendered; a reconnect resumes after it. */
+  readonly cursor = this.lastSequence.asReadonly();
+  readonly events = computed<TurnEvent[]>(() => this.frames().flatMap((frame) => frame.events));
+  readonly finalFrame = computed(() => this.frames().find((frame) => frame.final));
+  readonly isTerminal = computed(() => terminalStatuses.has(this.state()));
+
+  constructor(readonly requestId: string) {}
+
+  /** Returns false for a frame of another turn, one already rendered, or one after the final. */
+  accept(frame: TurnReplyFrame): boolean {
+    if (frame.request_id !== this.requestId || this.isTerminal()) return false;
+    if (frame.sequence <= this.lastSequence()) return false;
+    this.lastSequence.set(frame.sequence);
+    this.append(frame);
+    return true;
+  }
+
+  /** The reconnect cursor fell behind the retained window; the app now reads the stored result. */
+  markReplayExpired(): void {
+    if (!this.isTerminal()) this.state.set('replay_expired');
+  }
+
+  /**
+   * A final frame rebuilt from the turn record: a payload or an error code, no intermediate
+   * events. It completes the turn whatever its sequence.
+   */
+  acceptStoredResult(frame: TurnReplyFrame): boolean {
+    if (frame.request_id !== this.requestId || !frame.final || this.isTerminal()) return false;
+    this.append(frame);
+    return true;
+  }
+
+  /** Cancel is a request: the turn stays `cancelling` until its final frame arrives. */
+  markCancelRequested(): void {
+    if (!this.isTerminal()) this.state.set('cancelling');
+  }
+
+  private append(frame: TurnReplyFrame): void {
+    this.frames.update((frames) => [...frames, frame]);
+    this.state.set(this.statusAfter(frame));
+  }
+
+  private statusAfter(frame: TurnReplyFrame): TurnStreamStatus {
+    if (frame.final) {
+      if (frame.error_code === TURN_ERROR_CANCELED) return 'canceled';
+      return frame.error_code ? 'failed' : 'completed';
+    }
+    if (this.state() === 'cancelling') return 'cancelling';
+    // approval_pending ends the delivery, not the turn: resumed frames follow on the same stream.
+    const last = frame.events[frame.events.length - 1];
+    return last?.kind === 'approval_pending' ? 'awaiting_approval' : 'streaming';
+  }
+}

package/src/agent/util/studio_errors.ts

@@ -0,0 +1,61 @@
+import { AgentFieldError, AgentValidationProblem } from '../model/agent_studio';
+
+/**
+ * Why a Studio mutation answered 409. The backend reports a stale agent revision and a stale
+ * type-defaults revision with the same message, so both are `revision`: reload the draft.
+ */
+export type StudioConflictCause = 'revision' | 'sealed' | 'other';
+
+type ErrorShape = {
+  status?: unknown;
+  error?: unknown;
+  problem?: unknown;
+  headers?: { get?: (name: string) => string | null };
+  response?: { headers?: { get?: (name: string) => string | null } };
+};
+
+function shapeOf(err: unknown): ErrorShape | undefined {
+  return err && typeof err === 'object' ? (err as ErrorShape) : undefined;
+}
+
+function detailOf(err: unknown): string {
+  const shape = shapeOf(err);
+  const body = shape?.problem ?? shape?.error;
+  if (typeof body === 'string') return body;
+  if (!body || typeof body !== 'object') return '';
+  const { detail, message } = body as { detail?: unknown; message?: unknown };
+  if (typeof detail === 'string') return detail;
+  return typeof message === 'string' ? message : '';
+}
+
+export function studioConflictCause(err: unknown): StudioConflictCause | undefined {
+  if (shapeOf(err)?.status !== 409) return undefined;
+  const detail = detailOf(err);
+  if (detail.includes('binding sealed')) return 'sealed';
+  if (detail.includes('revision conflict')) return 'revision';
+  return 'other';
+}
+
+/** Field errors of a 400; the backend carries them as a JSON document in the problem detail. */
+export function studioFieldErrors(err: unknown): AgentFieldError[] {
+  if (shapeOf(err)?.status !== 400) return [];
+  const detail = detailOf(err);
+  if (!detail.startsWith('{')) return [];
+  try {
+    const problem = JSON.parse(detail) as Partial<AgentValidationProblem>;
+    return Array.isArray(problem.fields) ? problem.fields : [];
+  } catch {
+    return [];
+  }
+}
+
+/** Whole seconds from `Retry-After` on a 429/503; undefined when the server gave no advice. */
+export function retryAfterSeconds(err: unknown): number | undefined {
+  const shape = shapeOf(err);
+  if (shape?.status !== 429 && shape?.status !== 503) return undefined;
+  const headers = shape.headers ?? shape.response?.headers;
+  const raw = headers?.get?.('Retry-After');
+  if (!raw) return undefined;
+  const seconds = Number(raw);
+  return Number.isFinite(seconds) && seconds >= 0 ? seconds : undefined;
+}

package/src/agent/util/turn_timeline.ts

@@ -0,0 +1,115 @@
+import {
+  EvidenceRef,
+  TurnApprovalEvent,
+  TurnEffectEvent,
+  TurnEvent,
+  TurnExtensionEvent,
+  TurnProgressEvent,
+  TurnToolEvent,
+  isKnownTurnEvent,
+} from '../model/turn_event';
+
+export type ToolCallApproval = 'pending' | 'resolved';
+
+export interface ToolCallView {
+  kind: 'tool';
+  call_id: string;
+  tool_id: string;
+  tool_version: string;
+  arguments?: unknown;
+  result?: TurnToolEvent;
+  /** Set only for an `is_error` result; its output is never shown. */
+  errorClass?: string;
+  effect?: TurnEffectEvent;
+  approval?: ToolCallApproval;
+  decision?: string;
+}
+
+export type TurnTimelineItem =
+  | { kind: 'text'; text: string }
+  | ToolCallView
+  | { kind: 'evidence'; refs: EvidenceRef[] }
+  | { kind: 'progress'; progress: TurnProgressEvent }
+  | { kind: 'extension'; extension: TurnExtensionEvent }
+  | { kind: 'result' };
+
+function errorClassOf(tool: TurnToolEvent): string | undefined {
+  if (!tool.is_error) return undefined;
+  const output = tool.output;
+  if (!output || typeof output !== 'object') return '';
+  const errorClass = (output as { error?: unknown }).error;
+  return typeof errorClass === 'string' ? errorClass : '';
+}
+
+/**
+ * Folds a turn's events, in frame order, into renderable items: text deltas concatenate, and a
+ * call's proposal, result, effect, and approval meet on one item by `call_id`. Unknown kinds
+ * are skipped.
+ */
+export function buildTurnTimeline(events: readonly unknown[]): TurnTimelineItem[] {
+  const items: TurnTimelineItem[] = [];
+  const calls = new Map<string, ToolCallView>();
+
+  const callFor = (source: { call_id?: string; tool_id?: string; tool_version?: string }): ToolCallView => {
+    const callId = source.call_id ?? '';
+    let call = calls.get(callId);
+    if (!call) {
+      call = { kind: 'tool', call_id: callId, tool_id: source.tool_id ?? '', tool_version: source.tool_version ?? '' };
+      calls.set(callId, call);
+      items.push(call);
+    }
+    return call;
+  };
+
+  const applyApproval = (approval: TurnApprovalEvent | undefined, state: ToolCallApproval): void => {
+    if (!approval) return;
+    const call = callFor(approval);
+    call.approval = state;
+    call.decision = approval.decision;
+  };
+
+  for (const candidate of events) {
+    if (!isKnownTurnEvent(candidate)) continue;
+    const event: TurnEvent = candidate;
+    switch (event.kind) {
+      case 'text_delta': {
+        const last = items[items.length - 1];
+        if (last?.kind === 'text') last.text += event.text ?? '';
+        else items.push({ kind: 'text', text: event.text ?? '' });
+        break;
+      }
+      case 'tool_proposal':
+        if (event.tool) callFor(event.tool).arguments = event.tool.arguments;
+        break;
+      case 'tool_result':
+        if (event.tool) {
+          const call = callFor(event.tool);
+          call.result = event.tool;
+          call.errorClass = errorClassOf(event.tool);
+        }
+        break;
+      case 'effect':
+        if (event.effect) callFor(event.effect).effect = event.effect;
+        break;
+      case 'approval_pending':
+        applyApproval(event.approval, 'pending');
+        break;
+      case 'approval_resolved':
+        applyApproval(event.approval, 'resolved');
+        break;
+      case 'evidence':
+        if (event.evidence?.length) items.push({ kind: 'evidence', refs: event.evidence });
+        break;
+      case 'progress':
+        if (event.progress) items.push({ kind: 'progress', progress: event.progress });
+        break;
+      case 'extension':
+        if (event.extension) items.push({ kind: 'extension', extension: event.extension });
+        break;
+      case 'result':
+        items.push({ kind: 'result' });
+        break;
+    }
+  }
+  return items;
+}

package/src/component/dashboard/data_card.html

@@ -33,5 +33,12 @@
         <button matButton="elevated" type="button" class="primary" (click)="upgrade.emit()">{{ ctaLabel() }}</button>
       </div>
     }
+    @case ('no-source') {
+      <div class="data-card-no-source" role="group" [attr.aria-label]="(heading() || 'Insight') + ' — source unavailable'">
+        <p class="no-source-name">{{ sourceName() }}</p>
+        <p class="no-source-message">{{ noSourceMessage() }}</p>
+        <button matButton="elevated" type="button" class="primary" (click)="connect.emit()">{{ connectLabel() }}</button>
+      </div>
+    }
   }
 </section>

package/src/component/dashboard/data_card.ts

@@ -30,10 +30,14 @@ export class DataCardComponent {
   readonly errorMessage = input<string>('Could not load this data.');
   readonly emptyMessage = input<string>('No data yet.');
   readonly lockedMessage = input<string>('Upgrade to unlock this insight.');
+  readonly sourceName = input<string>('data source');
+  readonly noSourceMessage = input<string>('Connect the required data source to see this insight.');
   readonly ctaLabel = input<string>('Upgrade');
+  readonly connectLabel = input<string>('Connect');
   readonly tableHeaders = input<string[]>([]);
   readonly tableRows = input<(string | number)[][]>([]);
   readonly upgrade = output<void>();
+  readonly connect = output<void>();
   readonly retry = output<void>();
 
   /** The chart, provided as a single <ng-template>; instantiated only when ready. */

package/src/component/dashboard/no_source_overlay.html

@@ -0,0 +1,9 @@
+@if (unavailable()) {
+  <div class="no-source-overlay" role="group" [attr.aria-label]="sourceName() + ' — source unavailable'">
+    <p class="no-source-name">{{ sourceName() }}</p>
+    <p class="no-source-message">{{ message() }}</p>
+    <button matButton="elevated" type="button" class="primary" (click)="connect.emit()">{{ ctaLabel() }}</button>
+  </div>
+} @else if (content(); as tpl) {
+  <ng-container [ngTemplateOutlet]="tpl"></ng-container>
+}

package/src/component/dashboard/no_source_overlay.ts

@@ -0,0 +1,21 @@
+import { NgTemplateOutlet } from '@angular/common';
+import { ChangeDetectionStrategy, Component, TemplateRef, ViewEncapsulation, contentChild, input, output } from '@angular/core';
+import { MatButtonModule } from '@angular/material/button';
+
+/** Source-readiness sibling of LockedOverlayComponent: the template is never instantiated while unavailable. */
+@Component({
+  selector: 'sail-no-source-overlay',
+  templateUrl: './no_source_overlay.html',
+  changeDetection: ChangeDetectionStrategy.OnPush,
+  encapsulation: ViewEncapsulation.None,
+  imports: [NgTemplateOutlet, MatButtonModule],
+})
+export class NoSourceOverlayComponent {
+  readonly unavailable = input.required<boolean>();
+  readonly sourceName = input.required<string>();
+  readonly message = input<string>('Connect this data source to continue.');
+  readonly ctaLabel = input<string>('Connect');
+  readonly connect = output<void>();
+
+  readonly content = contentChild(TemplateRef);
+}

package/src/component/table/before_after_diff.html

@@ -0,0 +1 @@
+<pre class="before-after-diff">@for (token of tokens(); track $index) {@switch (token.kind) {@case ('add') {<ins class="diff-add">{{ token.text }}</ins>}@case ('del') {<del class="diff-del">{{ token.text }}</del>}@default {<span class="diff-same">{{ token.text }}</span>}}}</pre>

package/src/component/table/before_after_diff.ts

@@ -0,0 +1,54 @@
+import { ChangeDetectionStrategy, Component, ViewEncapsulation, computed, input } from '@angular/core';
+
+export type DiffTokenKind = 'same' | 'add' | 'del';
+
+export interface DiffToken {
+  text: string;
+  kind: DiffTokenKind;
+}
+
+/** Whitespace-preserving word-level LCS diff with a bounded work limit. */
+export function wordDiff(before: string, after: string, maxTokens = 2000): DiffToken[] {
+  const left = before.split(/(\s+)/).filter((token) => token.length > 0);
+  const right = after.split(/(\s+)/).filter((token) => token.length > 0);
+  if (left.length > maxTokens || right.length > maxTokens) return [{ text: after, kind: 'add' }];
+
+  const matrix = Array.from({ length: left.length + 1 }, () => new Uint32Array(right.length + 1));
+  for (let i = left.length - 1; i >= 0; i--) {
+    for (let j = right.length - 1; j >= 0; j--) {
+      matrix[i][j] = left[i] === right[j]
+        ? matrix[i + 1][j + 1] + 1
+        : Math.max(matrix[i + 1][j], matrix[i][j + 1]);
+    }
+  }
+
+  const tokens: DiffToken[] = [];
+  let i = 0;
+  let j = 0;
+  while (i < left.length && j < right.length) {
+    if (left[i] === right[j]) {
+      tokens.push({ text: left[i++], kind: 'same' });
+      j++;
+    } else if (matrix[i + 1][j] >= matrix[i][j + 1]) {
+      tokens.push({ text: left[i++], kind: 'del' });
+    } else {
+      tokens.push({ text: right[j++], kind: 'add' });
+    }
+  }
+  while (i < left.length) tokens.push({ text: left[i++], kind: 'del' });
+  while (j < right.length) tokens.push({ text: right[j++], kind: 'add' });
+  return tokens;
+}
+
+@Component({
+  selector: 'sail-before-after-diff',
+  templateUrl: './before_after_diff.html',
+  changeDetection: ChangeDetectionStrategy.OnPush,
+  encapsulation: ViewEncapsulation.None,
+})
+export class BeforeAfterDiffComponent {
+  readonly before = input.required<string>();
+  readonly after = input.required<string>();
+  readonly maxTokens = input<number>(2000);
+  readonly tokens = computed(() => wordDiff(this.before(), this.after(), this.maxTokens()));
+}

package/src/component/table/grouped_bulk_action.html

@@ -0,0 +1,36 @@
+@if (message(); as outcome) {
+  <p class="grouped-bulk-action__message"
+     [class.grouped-bulk-action__message--partial]="outcome.kind === 'partial'"
+     [class.grouped-bulk-action__message--error]="outcome.kind === 'error'"
+     role="alert">{{ outcome.text }}</p>
+}
+
+@for (group of groups(); track group.key) {
+  <section class="grouped-bulk-action" [attr.data-group-key]="group.key">
+    <header class="grouped-bulk-action__header">
+      <div class="grouped-bulk-action__heading" role="heading" [attr.aria-level]="headingLevel()">{{ heading()(group) }}</div>
+      <button matButton="filled" type="button"
+              [disabled]="busyKey() !== null"
+              (click)="run(group)">
+        {{ actionLabel()(group, busyKey() === group.key) }}
+      </button>
+    </header>
+
+    @if (description()(group); as text) {
+      <p class="grouped-bulk-action__description">{{ text }}</p>
+    }
+
+    @if (sampleTemplate(); as template) {
+      <div class="grouped-bulk-action__sample">
+        @for (row of group.sample; track $index) {
+          <ng-container [ngTemplateOutlet]="template"
+                        [ngTemplateOutletContext]="{ $implicit: row, group: group }"></ng-container>
+        }
+      </div>
+    }
+
+    @if (group.count > group.sample.length) {
+      <p class="grouped-bulk-action__remainder">{{ remainderLabel()(group.count - group.sample.length, group) }}</p>
+    }
+  </section>
+}

package/src/component/table/grouped_bulk_action.ts

@@ -0,0 +1,120 @@
+import { NgTemplateOutlet } from '@angular/common';
+import { ChangeDetectionStrategy, Component, DestroyRef, TemplateRef, ViewEncapsulation, computed, contentChild, inject, input, output, signal } from '@angular/core';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { MatButtonModule } from '@angular/material/button';
+import { finalize, Observable } from 'rxjs';
+
+export type BulkGroupKey = string | number;
+
+export interface BulkActionGroup<T> {
+  key: BulkGroupKey;
+  rows: readonly T[];
+  sample: readonly T[];
+  count: number;
+}
+
+/** Generic outcome used to detect and report partial completion. */
+export interface BulkActionResult {
+  attempted: number;
+  succeeded: number;
+}
+
+export interface BulkActionCompletion<T> {
+  group: BulkActionGroup<T>;
+  result: BulkActionResult;
+}
+
+interface OutcomeMessage {
+  text: string;
+  kind: 'partial' | 'error';
+}
+
+/** The projected template receives each sample row as `$implicit` and its group as `group`. */
+@Component({
+  selector: 'sail-grouped-bulk-action',
+  templateUrl: './grouped_bulk_action.html',
+  changeDetection: ChangeDetectionStrategy.OnPush,
+  encapsulation: ViewEncapsulation.None,
+  imports: [NgTemplateOutlet, MatButtonModule],
+})
+export class GroupedBulkActionComponent<T> {
+  readonly rows = input.required<readonly T[]>();
+  readonly groupBy = input.required<(row: T) => BulkGroupKey | null | undefined>();
+  readonly eligible = input<(row: T) => boolean>(() => true);
+  readonly sampleSize = input.required<number>();
+  readonly minimumGroupSize = input<number>(2);
+  readonly execute = input.required<(group: BulkActionGroup<T>) => Observable<BulkActionResult>>();
+
+  readonly heading = input.required<(group: BulkActionGroup<T>) => string>();
+  readonly headingLevel = input<number>(3);
+  readonly description = input<(group: BulkActionGroup<T>) => string>(() => '');
+  readonly actionLabel = input.required<(group: BulkActionGroup<T>, busy: boolean) => string>();
+  readonly remainderLabel = input.required<(remaining: number, group: BulkActionGroup<T>) => string>();
+  readonly partialSuccessMessage = input.required<(result: BulkActionResult, group: BulkActionGroup<T>) => string>();
+  readonly failureMessage = input.required<(error: unknown, group: BulkActionGroup<T>) => string>();
+  readonly sortGroups = input<(left: BulkActionGroup<T>, right: BulkActionGroup<T>) => number>(() => 0);
+
+  readonly finished = output<BulkActionCompletion<T>>();
+  readonly failed = output<{ group: BulkActionGroup<T>; error: unknown }>();
+
+  readonly busyKey = signal<BulkGroupKey | null>(null);
+  /** Held outside the groups: a refresh after the action usually removes the group it concerns. */
+  readonly message = signal<OutcomeMessage | null>(null);
+  readonly sampleTemplate = contentChild<TemplateRef<unknown>>(TemplateRef);
+  readonly groups = computed(() => this.buildGroups());
+
+  private readonly destroyRef = inject(DestroyRef);
+
+  run(group: BulkActionGroup<T>): void {
+    if (this.busyKey() !== null) return;
+    this.busyKey.set(group.key);
+    this.message.set(null);
+    let request: Observable<BulkActionResult>;
+    try {
+      request = this.execute()(group);
+    } catch (error) {
+      this.handleFailure(group, error);
+      return;
+    }
+    request.pipe(
+      takeUntilDestroyed(this.destroyRef),
+      finalize(() => this.busyKey.set(null)),
+    ).subscribe({
+      next: (result) => {
+        if (result.succeeded < result.attempted) {
+          this.message.set({ text: this.partialSuccessMessage()(result, group), kind: 'partial' });
+        }
+        this.finished.emit({ group, result });
+      },
+      error: (error: unknown) => this.handleFailure(group, error),
+    });
+  }
+
+  private buildGroups(): BulkActionGroup<T>[] {
+    const grouped = new Map<BulkGroupKey, T[]>();
+    for (const row of this.rows()) {
+      if (!this.eligible()(row)) continue;
+      const key = this.groupBy()(row);
+      if (key === null || key === undefined || key === '') continue;
+      const groupRows = grouped.get(key) ?? [];
+      groupRows.push(row);
+      grouped.set(key, groupRows);
+    }
+    const sampleSize = Math.max(0, this.sampleSize());
+    return [...grouped.entries()]
+      .filter(([, groupRows]) => groupRows.length >= this.minimumGroupSize())
+      .map(([key, groupRows]) => ({
+        key,
+        rows: groupRows,
+        sample: groupRows.slice(0, sampleSize),
+        count: groupRows.length,
+      }))
+      .sort(this.sortGroups());
+  }
+
+  private handleFailure(group: BulkActionGroup<T>, error: unknown): void {
+    this.busyKey.set(null);
+    this.message.set({ text: this.failureMessage()(error, group), kind: 'error' });
+    this.failed.emit({ group, error });
+  }
+}

package/src/index.ts

@@ -10,6 +10,7 @@ export * from './component/abstract/base_table';
 export * from './component/dashboard/dashboard_shell';
 export * from './component/dashboard/data_card';
 export * from './component/dashboard/locked_overlay';
+export * from './component/dashboard/no_source_overlay';
 export * from './component/dashboard/action_center';
 export * from './component/dashboard/entity_selector';
 export * from './component/dashboard/verification_flow';
@@ -26,6 +27,8 @@ export * from './component/table/table_edit';
 export * from './component/table/table_detail';
 export * from './component/table/table_lookup';
 export * from './component/table/table_report';
+export * from './component/table/grouped_bulk_action';
+export * from './component/table/before_after_diff';
 export * from './component/navigation/navigation';
 export * from './component/login/login_component';
 export * from './component/login/register_component';

package/src/model/dashboard.ts

@@ -1,5 +1,5 @@
 /** Lifecycle state of a data/chart card (sail-data-card). */
-export type DataCardState = 'loading' | 'ready' | 'empty' | 'error' | 'locked';
+export type DataCardState = 'loading' | 'ready' | 'empty' | 'error' | 'locked' | 'no-source';
 
 /** A prioritized, completable next-best-action (sail-action-center, FR-008). */
 export interface ActionItem {

package/src/service/base_rest.service.ts

@@ -1,6 +1,6 @@
 import { HttpClient, HttpParams } from '@angular/common/http';
 import { inject } from '@angular/core';
-import { Observable } from 'rxjs';
+import { map, Observable } from 'rxjs';
 import { RestURL } from './rest_url';
 
 /**
@@ -22,10 +22,45 @@ export abstract class BaseRestService {
   /** GET an analytic endpoint (`{host}{api_prefix}analytic/<endpoint>`), returning
    * its rows. Optional flat string params become the query string. */
   protected analytic<T>(endpoint: string, params?: Record<string, string>): Observable<T[]> {
-    let p = new HttpParams();
-    for (const k in params) {
-      if (Object.prototype.hasOwnProperty.call(params, k)) p = p.set(k, params[k]);
+    return this.http.get<T[]>(this.analyticUrl(endpoint), { params: this.analyticParams(params) });
+  }
+
+  /** `analytic()` plus the `X-Data-Source-Status` / `X-Data-Source` response headers, so an
+   * empty result can be told apart from a missing source. `analytic()` stays array-valued. */
+  protected analyticWithStatus<T>(endpoint: string, params?: Record<string, string>): Observable<AnalyticResult<T>> {
+    return this.http.get<T[]>(this.analyticUrl(endpoint), {
+      params: this.analyticParams(params),
+      observe: 'response',
+    }).pipe(
+      map((response) => ({
+        rows: response.body ?? [],
+        source: {
+          status: response.headers.get('X-Data-Source-Status'),
+          id: response.headers.get('X-Data-Source'),
+        },
+      })),
+    );
+  }
+
+  private analyticUrl(endpoint: string): string {
+    return this.url(RestURL.api_prefix + 'analytic/' + endpoint);
+  }
+
+  private analyticParams(params?: Record<string, string>): HttpParams {
+    let result = new HttpParams();
+    for (const key in params) {
+      if (Object.prototype.hasOwnProperty.call(params, key)) result = result.set(key, params[key]);
     }
-    return this.http.get<T[]>(this.url(RestURL.api_prefix + 'analytic/' + endpoint), { params: p });
+    return result;
   }
 }
+
+export interface AnalyticResult<T> {
+  rows: T[];
+  source: AnalyticSourceStatus;
+}
+
+export interface AnalyticSourceStatus {
+  status: string | null;
+  id: string | null;
+}