android-midscene-automation 0.2.4 → 1.1.0

package/artemis-main/apps/showcase_ui/src/app/core/models/markdown.model.ts

@@ -0,0 +1,43 @@
+/**
+ * Copyright 2026 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+export interface MarkdownSegment {
+  text: string;
+  bold: boolean;
+  code?: boolean;
+}
+
+export interface MarkdownLine {
+  type: 'h1' | 'h2' | 'h3' | 'checked' | 'progress' | 'unchecked' | 'list-item' | 'verify' | 'assert' | 'finding' | 'text' | 'empty';
+  segments: MarkdownSegment[];
+  indent: number;
+  checkKind?: 'verify' | 'assert' | 'finding';
+  atEnd?: boolean;
+}
+
+export interface NoteMilestone {
+  index: number;
+  type: 'checked' | 'progress' | 'unchecked';
+  segments: MarkdownSegment[];
+  subSteps: MarkdownLine[];
+  checks: MarkdownLine[];
+}
+
+export interface ParsedNote {
+  title: string | null;
+  milestones: NoteMilestone[];
+  otherLines: MarkdownLine[];
+}

package/artemis-main/apps/showcase_ui/src/app/core/models/pro-tuning.model.spec.ts

@@ -0,0 +1,47 @@
+import {
+  DEFAULT_EXPLORER_MODE,
+  DEFAULT_VERIFICATION_LEVEL,
+  EXPLORER_MODES,
+  VERIFICATION_LEVELS,
+  levelIndex,
+  notchPercent
+} from './pro-tuning.model';
+
+describe('pro tuning ladders', () => {
+  it('keeps every notch id and label unique within its ladder', () => {
+    for (const ladder of [VERIFICATION_LEVELS, EXPLORER_MODES]) {
+      expect(new Set(ladder.map((l) => l.id)).size).toBe(ladder.length);
+      expect(new Set(ladder.map((l) => l.label)).size).toBe(ladder.length);
+    }
+  });
+
+  it('mirrors the backend wire values', () => {
+    expect(VERIFICATION_LEVELS.map((l) => l.id)).toEqual(['off', 'final', 'checkpoints', 'strict']);
+    expect(EXPLORER_MODES.map((l) => l.id)).toEqual(['flash', 'pro', 'ultra']);
+    expect(VERIFICATION_LEVELS.map((l) => l.id)).toContain(DEFAULT_VERIFICATION_LEVEL);
+    expect(EXPLORER_MODES.map((l) => l.id)).toContain(DEFAULT_EXPLORER_MODE);
+  });
+
+  it('every level explains itself', () => {
+    for (const level of [...VERIFICATION_LEVELS, ...EXPLORER_MODES]) {
+      expect(level.tagline.length).toBeGreaterThan(10);
+      expect(level.latency.length).toBeGreaterThan(0);
+      expect(level.runs.length).toBeGreaterThan(0);
+      expect(level.bestFor.length).toBeGreaterThan(10);
+    }
+  });
+
+  it('resolves ids case-insensitively and falls back to the default', () => {
+    expect(levelIndex(VERIFICATION_LEVELS, ' STRICT ', DEFAULT_VERIFICATION_LEVEL)).toBe(3);
+    expect(levelIndex(VERIFICATION_LEVELS, 'nope', DEFAULT_VERIFICATION_LEVEL)).toBe(1);
+    expect(levelIndex(EXPLORER_MODES, null, DEFAULT_EXPLORER_MODE)).toBe(0);
+  });
+
+  it('maps notches onto the track', () => {
+    expect(notchPercent(0, 4)).toBe(0);
+    expect(notchPercent(3, 4)).toBe(100);
+    expect(notchPercent(1, 3)).toBe(50);
+    expect(notchPercent(9, 3)).toBe(100);
+    expect(notchPercent(0, 1)).toBe(0);
+  });
+});

package/artemis-main/apps/showcase_ui/src/app/core/models/pro-tuning.model.ts

@@ -0,0 +1,165 @@
+/**
+ * Copyright 2026 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Launcher options for `/api/run` (`verification_level`, `explorer_mode`).
+ * Keep ids in sync with `VERIFICATION_LEVEL_PRESETS` in `artemis/config/agent.py`
+ * and `EXPLORER_TIERS` in `artemis/agents/explorer/tiers.py`.
+ */
+
+export type VerificationLevelId = 'off' | 'final' | 'checkpoints' | 'strict';
+export type ExplorerModeId = 'flash' | 'pro' | 'ultra';
+
+/** One notch on a tuning slider. */
+export interface TuningLevel<TId extends string = string> {
+  /** Wire value sent to the backend. */
+  id: TId;
+  /** Short name shown next to the slider title and as the hover card heading. */
+  label: string;
+  /** One-sentence summary shown in the hover card. */
+  tagline: string;
+  /** Plain-language time cost, e.g. "no extra time". */
+  latency: string;
+  /** Checks or searches performed at this level. */
+  runs: string[];
+  /** Checks or searches omitted at this level. */
+  skips?: string[];
+  /** When to pick this level. */
+  bestFor: string;
+}
+
+export const VERIFICATION_LEVELS: readonly TuningLevel<VerificationLevelId>[] = [
+  {
+    id: 'off',
+    label: 'Off',
+    tagline: 'No checking. The run ends as soon as the task looks done.',
+    latency: 'no extra time',
+    runs: [
+      'Each step is treated as finished the moment it is carried out.',
+      'You get the full action trace, but no pass / fail verdict.'
+    ],
+    skips: ['Nothing is double-checked and nothing is retried.'],
+    bestFor: 'Quick tries and demos, when you only want to watch what happens.'
+  },
+  {
+    id: 'final',
+    label: 'At the end',
+    tagline: 'One check of the finished result against your goal. This is the default.',
+    latency: 'adds about 20–60 s at the end',
+    runs: [
+      'When the task finishes, the final screen, the step history and the device state are compared with what you asked for.',
+      'If the result does not match, the task goes back and tries to fix it, up to 3 times.'
+    ],
+    skips: ['Nothing is checked while the task is still running.'],
+    bestFor: 'Everyday tasks: an honest pass / fail without slowing the run down.'
+  },
+  {
+    id: 'checkpoints',
+    label: 'Every step',
+    tagline: 'Each step is checked as soon as it is done, plus the final check.',
+    latency: 'a short check after each step, done in the background',
+    runs: [
+      'Every step is checked right after it completes, using the screenshots from that moment.',
+      'If a step went wrong, it gets fixed before moving on (up to 2 tries per step).',
+      'A failed test condition is written down and the task keeps going.',
+      'The final check still runs at the end.'
+    ],
+    bestFor: 'Long tasks where one early mistake would spoil everything after it.'
+  },
+  {
+    id: 'strict',
+    label: 'Strict',
+    tagline: 'Every step is checked, with more retries. The first failed test stops the run.',
+    latency: 'slowest: more checks and more retries',
+    runs: [
+      'Each check takes longer and gets more attempts: 4 fixes per step and 5 at the end.',
+      'The first failed test condition stops the run immediately, with the evidence attached.'
+    ],
+    bestFor: 'Release checks and regression runs, where a wrong pass is never acceptable.'
+  }
+];
+
+export const EXPLORER_MODES: readonly TuningLevel<ExplorerModeId>[] = [
+  {
+    id: 'flash',
+    label: 'Quick glance',
+    tagline: 'Finds buttons and text on the screen in a single look.',
+    latency: '1 look per search',
+    runs: [
+      'Something on screen is asked for by name, icon or colour and its position comes back straight away.',
+      'Several things can be looked up at once.'
+    ],
+    skips: ['No zooming in and no second try.'],
+    bestFor: 'Ordinary apps with clearly labelled buttons, icons and text.'
+  },
+  {
+    id: 'pro',
+    label: 'Second look',
+    tagline: 'Takes up to 3 looks, thinking in between, before answering.',
+    latency: 'up to 3 looks per search',
+    runs: [
+      'The screen layout is read first, then the picture is searched.',
+      'If the first try misses, a different approach is tried within the 3 looks.'
+    ],
+    skips: ['Still no zooming into small areas, to keep searches short.'],
+    bestFor: 'Things described by where they are ("the switch next to Wi-Fi") or with unclear labels.'
+  },
+  {
+    id: 'ultra',
+    label: 'Close-up',
+    tagline: 'Zooms into parts of the screen and takes up to 8 looks.',
+    latency: 'up to 8 looks per search (slowest)',
+    runs: [
+      'Parts of the screen can be cropped and magnified to read tiny text and crowded layouts piece by piece.',
+      'Later looks reuse the earlier ones, so they cost less time than they sound.'
+    ],
+    bestFor: 'Crowded screens, tiny targets, charts and drawings, and checks where exact placement matters.'
+  }
+];
+
+/** Per-run tuning sent with `/api/run` for the Pro profile. */
+export interface ProTuningOptions {
+  verificationLevel?: VerificationLevelId | string;
+  explorerMode?: ExplorerModeId | string;
+}
+
+/** Effective defaults reported by `GET /api/run/defaults`. */
+export interface ProTuningDefaults {
+  verification_level?: string | null;
+  explorer_mode?: string | null;
+}
+
+export const DEFAULT_VERIFICATION_LEVEL: VerificationLevelId = 'final';
+export const DEFAULT_EXPLORER_MODE: ExplorerModeId = 'flash';
+
+/** Index of a level id within its ladder; falls back to the default when unknown. */
+export function levelIndex<TId extends string>(
+  ladder: readonly TuningLevel<TId>[],
+  id: string | null | undefined,
+  fallback: TId
+): number {
+  const wanted = String(id ?? '').trim().toLowerCase();
+  const idx = ladder.findIndex((l) => l.id === wanted);
+  if (idx >= 0) return idx;
+  return Math.max(0, ladder.findIndex((l) => l.id === fallback));
+}
+
+/** Slider fill percentage for a notch index on a ladder of `count` notches. */
+export function notchPercent(index: number, count: number): number {
+  if (count <= 1) return 0;
+  const clamped = Math.min(Math.max(index, 0), count - 1);
+  return (clamped / (count - 1)) * 100;
+}

package/artemis-main/apps/showcase_ui/src/app/core/models/session.model.ts

@@ -0,0 +1,85 @@
+/**
+ * Copyright 2026 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+export interface ModelInfo {
+  name: string;
+  id: string;
+  provider: string;
+  architecture?: string;
+}
+
+export interface TaskQueueItem {
+  session_id: string;
+  goal: string;
+  profile?: string;
+  status: 'pending' | 'running' | 'paused' | 'completed' | 'failed' | 'cancelled';
+  created_at?: number;
+  start_time?: number;
+  device_serial?: string | null;
+  device_id?: string | null;
+}
+
+export interface Session {
+  session_id: string;
+  initial_goal: string;
+  start_time: number;
+  end_time?: number;
+  status?: string;
+  video_url?: string;
+  recording_status?: 'recording' | 'finalizing' | 'processing' | 'ready' | 'failed' | 'unavailable';
+  model_info?: ModelInfo;
+  device_serial?: string | null;
+  device_id?: string | null;
+  device_info?: any;
+}
+
+export interface AgentStatusResponse {
+  status: 'idle' | 'running' | 'paused' | 'completed' | 'offline';
+  session_id?: string | null;
+  goal?: string | null;
+  pid?: number | null;
+  queue?: (TaskQueueItem | string)[];
+  background_tasks?: any[];
+  model_info?: ModelInfo | null;
+  paused_error?: string | null;
+}
+
+/** Per-run Pro tuning persisted with the session (`device_info.run_tuning`). */
+export interface SessionRunTuning {
+  verification_level?: string | null;
+  explorer_mode?: string | null;
+}
+
+/** `GET /api/sessions/{id}/usage`: session-wide LLM usage and the live executor context. */
+export interface SessionUsage {
+  session_id: string;
+  llm_calls: number;
+  prompt_tokens: number;
+  completion_tokens: number;
+  total_tokens: number;
+  cached_tokens: number;
+  /** Prompt size of the latest Operator / Flash runner call; null before the first call. */
+  operator_context_tokens: number | null;
+  operator_context_window_tokens: number;
+  operator_context_updated_at?: number | null;
+  profile?: string | null;
+  run_tuning?: SessionRunTuning | null;
+}
+
+export type AgentStatus = 'idle' | 'running' | 'completed' | 'offline' | string;
+
+export type TaskStatus = 'running' | 'paused' | 'completed' | 'pending' | 'failed' | 'cancelled';
+

package/artemis-main/apps/showcase_ui/src/app/core/models/stream.model.ts

@@ -0,0 +1,246 @@
+/**
+ * Copyright 2026 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+export interface ActionParam {
+  key: string;
+  value: string;
+}
+
+export interface ActionExecution {
+  id?: string;
+  trace_id?: string;
+  agent?: string;
+  agent_name?: string;
+  action: string;
+  name?: string;
+  args?: Record<string, any>;
+  params?: Record<string, any>;
+  payload?: any;
+  pre_image_name?: string | null;
+  post_image_name?: string | null;
+  status?: 'success' | 'failed' | 'error' | 'running' | string;
+  duration?: number;
+  duration_ms?: number;
+  error?: string | null;
+  timestamp?: number;
+}
+
+export interface StepEvent {
+  type: 'thinking' | 'text' | 'action' | 'tool';
+  data: any;
+  timestamp?: number;
+}
+
+export interface LLMStreamEventData {
+  execution_id: string;
+  step_id?: string;
+  session_id?: string;
+  text?: string;
+  chunk?: string;
+  stream_type?: 'thinking' | 'text' | string;
+  isCompleted?: boolean;
+  isReset?: boolean;
+  resetMessage?: string;
+}
+
+export const DEFAULT_STREAM_RESET_MESSAGE =
+  'A request error occurred during output generation, typically caused by lower API priority. Retrying automatically...';
+
+export interface StreamResetNotice {
+  id: string;
+  message: string;
+  isWaiting: boolean;
+  streamType: string;
+}
+
+export interface LLMStreamResetEventData {
+  stream_exec_id?: string;
+  stream_execution_id?: string;
+  step_id?: string;
+  session_id?: string;
+  action?: 'discard' | string;
+  reason?: string;
+  category?: string;
+  error?: string;
+  message?: string;
+  retry_attempt?: number;
+  timestamp?: number;
+}
+
+export interface StepItemData {
+  step_id: string;
+  step_type?: string;
+  step_number: number;
+  session_id: string;
+  timestamp: number;
+  operator_native_thinking?: string;
+  operator_raw_thinking?: string;
+  action_taken?: any;
+  generic_tools?: any[];
+  last_execution_result?: any;
+  pre_image_name?: string;
+  post_image_name?: string;
+  extra_metadata?: any;
+  token_usage?: {
+    prompt_tokens?: number;
+    completion_tokens?: number;
+    total_tokens?: number;
+  };
+  total_tokens?: number;
+  duration?: number;
+}
+
+export interface StepBlock {
+  id: string;
+  type: 'llm_stream' | 'step' | 'checker';
+  timestamp: string;
+  data: any;
+}
+
+export interface PhaseBlock {
+  id: string;
+  durationSeconds: number;
+  tokens?: number;
+  promptTokens?: number;
+  completionTokens?: number;
+  blocks: StepBlock[];
+}
+
+/** One check item's verdict as booked by the Checker (ledger record shape). */
+export interface CheckerVerdict {
+  item_text: string;
+  kind: 'verify' | 'assert' | string;
+  status: 'passed' | 'failed' | 'inconclusive' | 'superseded' | 'unchecked' | string;
+  evidence: string;
+  suggestion?: string;
+}
+
+export interface CheckerCheckItem {
+  kind: string;
+  text: string;
+  when?: string;
+}
+
+/**
+ * One streamed LLM turn of a multi-turn agent (the Checker's tool loop):
+ * the text of one execution id with the time its first chunk arrived, so the
+ * timeline can interleave it with the tool calls that followed. Live sessions
+ * build these from `llm_stream` chunks; historical sessions rebuild them from
+ * the persisted transcript (`PersistedCheckerStream`).
+ */
+export interface StreamSegment {
+  execution_id: string;
+  stream_type: 'thinking' | 'text';
+  text: string;
+  timestamp: string;
+  isCompleted?: boolean;
+  isReset?: boolean;
+  resetMessage?: string;
+}
+
+/** One persisted segment of a Checker attempt's streamed reasoning (backend `check_streams.jsonl`). */
+export interface PersistedStreamSegment {
+  execution_id: string;
+  /** `thought` is the model's reasoning stream, `answer` its visible text. */
+  role: 'thought' | 'answer' | string;
+  /** Unix seconds of the segment's first chunk. */
+  when: number;
+  text: string;
+}
+
+/**
+ * One Checker attempt's persisted transcript as served by
+ * `GET /api/sessions/{id}/checks` (`streams[]`). Text is bounded server-side;
+ * `truncated` says the middle was cut out.
+ */
+export interface PersistedCheckerStream {
+  attempt_id: string;
+  checkpoint_id?: string;
+  phase?: string;
+  trace_id?: string | null;
+  ts?: number;
+  truncated?: boolean;
+  dropped_chars?: number;
+  segments: PersistedStreamSegment[];
+}
+
+/**
+ * Data of a `checker` timeline block: one Checker attempt (a midway checkpoint
+ * of a completed subgoal or the exit final review), or the run outcome
+ * (`phase: 'outcome'`). Streamed reasoning and tool traces land in the same
+ * `operator_*_thinking` / `generic_tools` fields as an Operator step so the
+ * timeline renders them with one code path.
+ */
+export interface CheckerBlockData {
+  event?: string;
+  attempt_id?: string;
+  checkpoint_id?: string;
+  phase: 'checkpoint' | 'final' | 'outcome' | string;
+  subgoal_text?: string;
+  status?: 'running' | 'done' | 'superseded' | 'unchecked' | 'error' | string;
+  trace_id?: string | null;
+  anchor_step_id?: string | null;
+  items?: CheckerCheckItem[];
+  verdicts?: CheckerVerdict[];
+  findings?: string[];
+  unmet_subgoals?: string[];
+  reverted?: boolean;
+  applicable?: boolean;
+  repairs_used?: number;
+  route?: string;
+  error?: string;
+  task_status?: 'completed' | 'partial' | 'blocked' | string;
+  tests?: { passed: number; failed: number; inconclusive: number; unchecked: number };
+  last_findings?: string[];
+  started_at?: number;
+  finished_at?: number;
+  duration?: number;
+  isCompleted?: boolean;
+  generic_tools?: any[];
+  /** Per-turn stream segments (live chunks or the persisted transcript); the flat fields below hold the joined text. */
+  stream_segments?: StreamSegment[];
+  operator_native_thinking?: string;
+  operator_raw_thinking?: string;
+  [key: string]: any;
+}
+
+/** @deprecated legacy JSON-in-stream checker verdict (pre-ledger); kept for the parser. */
+export interface CheckerResult {
+  success: boolean;
+  reason: string;
+}
+
+export interface StepReplayFrame {
+  index: number;
+  stepNumber: number;
+  rawStepNumber?: number;
+  stepId?: string;
+  title: string;
+  imageUrl: string;
+  preImageUrl?: string | null;
+  postImageUrl?: string | null;
+  action?: any;
+  actionType?: string;
+  actionText?: string;
+  targetText?: string;
+  coords?: string;
+  status?: 'dispatched' | 'failed' | string;
+  isPost?: boolean;
+  timestamp?: number;
+  phaseId?: string;
+  summary?: string;
+}
+

package/artemis-main/apps/showcase_ui/src/app/core/models/system.model.ts

@@ -0,0 +1,118 @@
+/**
+ * Copyright 2026 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+export type ProbeStatus = 'pass' | 'warn' | 'fail' | 'skipped';
+
+export type ProbeCategory = 'device' | 'auth' | 'toolchain' | 'runtime';
+
+export interface ProbeAction {
+  action_type: 'command' | 'hint' | 'link';
+  label: string;
+  payload: string;
+}
+
+export interface DeviceInfo {
+  serial: string;
+  state: string;
+  model: string | null;
+  product: string | null;
+  android_version: string | null;
+  screen_resolution: string | null;
+  is_locked: boolean | null;
+  is_emulator: boolean;
+  installed_packages?: string[];
+}
+
+export interface AdbServerEndpoint {
+  host: string;
+  port: number;
+  socket: string;
+  identity: string;
+  mode: 'local' | 'remote';
+  is_local_default: boolean;
+}
+
+export interface AdbServerDevice {
+  serial: string;
+  state: string;
+  model: string | null;
+  product: string | null;
+}
+
+export interface AdbServerStatus {
+  endpoint: AdbServerEndpoint;
+}
+
+export interface AdbServerConnectionResult {
+  success: boolean;
+  message: string;
+  endpoint: AdbServerEndpoint;
+  devices: AdbServerDevice[];
+  persisted?: boolean;
+  persistence_error?: string | null;
+  error_code?: string;
+  output?: string;
+}
+
+export interface AdbServerConnectionResponse {
+  connection_result: AdbServerConnectionResult;
+  report?: SystemReadinessReport;
+}
+
+export interface ProbeResult {
+  id: string;
+  category: ProbeCategory;
+  title: string;
+  status: ProbeStatus;
+  is_blocker: boolean;
+  summary: string;
+  description: string;
+  metadata: Record<string, any>;
+  actions: ProbeAction[];
+}
+
+export interface SystemReadinessReport {
+  overall_ready: boolean;
+  blocker_count: number;
+  passed_blocker_count: number;
+  probes: ProbeResult[];
+  active_device: DeviceInfo | null;
+  os_type?: 'linux' | 'darwin' | 'windows' | string;
+  timestamp: number;
+}
+
+export type EmulatorLaunchStage =
+  | 'idle'
+  | 'starting'
+  | 'waiting_for_adb'
+  | 'booting'
+  | 'ready'
+  | 'failed'
+  | 'stopped';
+
+export interface EmulatorLaunchState {
+  avd_name: string | null;
+  status: EmulatorLaunchStage;
+  pid: number | null;
+  serial: string | null;
+  stage_message: string;
+  progress_percent: number;
+  started_at: number | null;
+  elapsed_seconds: number;
+  error: string | null;
+  logs: string[];
+  can_retry: boolean;
+}