handhold-sdk 1.0.0

package/src/agent-mode/AgentMode.js

@@ -0,0 +1,429 @@
+/**
+ * Hand Hold SDK - AgentMode (Task H5)
+ *
+ * Thin bridge between Handhold (Config/EventBus/HelpWidget/UICoach) and the
+ * vendored trusted-page-agent engine. AgentMode owns the engine lifecycle for
+ * "Do it for me" runs; the widget renders what the engine reports and answers
+ * its confirm prompts. Feature-flagged: HandHold only constructs this when
+ * `config.agentMode` is true (SDK default false) — "Show me"/"Explain" paths
+ * are untouched.
+ *
+ * Security posture (inherits the engine's guarantees — never weaken here):
+ *  - Model calls ride the Handhold backend proxy (`/api/v1/agent/llm`) using
+ *    the tenant apiKey the SDK already has. No LLM provider key in the browser.
+ *  - `allowedOrigins` is pinned to the current origin.
+ *  - onConfirm stays fail-closed: the returned promise only resolves when the
+ *    user answers a confirm card; anything except an explicit `true` denies.
+ *  - The widget's own DOM (#handhold-container and every descendant) is
+ *    blacklisted from engine snapshots, so the agent can never "see" or click
+ *    Handhold's own UI (no self-driving loops, no Allow-button self-clicks).
+ *
+ * Events (per plan H5):
+ *  in:  'agent:start' (agent_plan from the widget button), 'agent:stop'
+ *  out: 'agent:activity' (engine activity, executing events enriched with a
+ *       best-effort targetSelector for UICoach), 'agent:confirm'
+ *       ({pending, respond}), 'agent:ask' ({question, respond}),
+ *       'agent:done' ({success, text, steps})
+ */
+import { generateSelector } from '../utils/domUtils.js';
+
+const WIDGET_CONTAINER_ID = 'handhold-container';
+const LLM_PROXY_PATH = '/api/v1/agent/llm';
+
+class AgentMode {
+  /**
+   * @param {Object} deps
+   * @param {Object} deps.config        Config instance (or stub with get())
+   * @param {Object} deps.eventBus      Handhold event bus
+   * @param {Object} [deps.sessionManager]  SessionManager — carries the agent
+   *        checkpoint across full page loads (H7). Optional: without it runs
+   *        work but do not survive reloads.
+   * @param {(url:string)=>void} [deps.navigateImpl]  performs the actual
+   *        navigation after checkpointing (default location.assign; test seam)
+   * @param {(cfg:Object)=>Object} [deps.engineFactory]
+   *        Test seam: receives the exact TrustedPageAgent config and returns an
+   *        engine ({run, stop, getAuditLog}). Default lazily imports the
+   *        vendored engine — lazy so environments that never start a run
+   *        (and jest, which fakes the engine) never load it.
+   */
+  constructor({ config, eventBus, sessionManager, navigateImpl, engineFactory } = {}) {
+    if (!config) throw new Error('[HandHold AgentMode] config is required');
+    this.config = config;
+    this.eventBus = eventBus || null;
+    this.sessionManager = sessionManager || null;
+    this._navigate = navigateImpl || ((url) => globalThis.window?.location?.assign(url));
+    this._customFactory = typeof engineFactory === 'function';
+    this.engineFactory = this._customFactory
+      ? engineFactory
+      : async (cfg) => {
+          const { default: TrustedPageAgent } = await import(
+            /* webpackMode: "eager" */ '../agent/index.js'
+          );
+          return new TrustedPageAgent(cfg);
+        };
+    this.engine = null;
+    this.running = false;
+    this._currentTask = null;
+    this._abort = null; // per-run AbortController (H9: responsive Stop)
+    this._engineMod = null; // vendored module, preloaded for spotlight resolution
+    this._manifestPromise = null; // one fetch per AgentMode instance (H6)
+
+    if (this.eventBus) {
+      this.eventBus.on('agent:start', (plan) => {
+        this.start(plan);
+      });
+      this.eventBus.on('agent:stop', () => this.stop());
+      // SPA settle only (H7): in-app route changes keep this JS context alive,
+      // so a running engine simply continues — resume is BOOT-ONLY (a full
+      // reload destroyed the context). Never resume from here.
+      this.eventBus.on('navigation:changed', () => {});
+    }
+  }
+
+  _get(key) {
+    return typeof this.config.get === 'function' ? this.config.get(key) : this.config[key];
+  }
+
+  _emit(name, payload) {
+    if (this.eventBus) this.eventBus.emit(name, payload);
+  }
+
+  /**
+   * The Handhold-UI blacklist: a function re-evaluated on every engine snapshot,
+   * returning every Handhold widget element + ALL descendants so the agent can
+   * never see or click its own UI (the engine matches exact elements — see
+   * resolveElementList in the vendored serializer).
+   *
+   * Covers BOTH the SDK's own container (`#handhold-container`) AND any host-
+   * rendered Handhold UI marked `data-handhold-ui`. The demo replaces the
+   * legacy widget with its own React panels; without the marker those panels
+   * were visible to the agent, which then mis-clicked its own controls.
+   */
+  _widgetBlacklist() {
+    return [
+      () => {
+        const roots = [
+          document.getElementById(WIDGET_CONTAINER_ID),
+          ...document.querySelectorAll('[data-handhold-ui]'),
+        ].filter(Boolean);
+        const out = [];
+        for (const root of roots) {
+          out.push(root, ...root.querySelectorAll('*'));
+        }
+        return out;
+      },
+    ];
+  }
+
+  /**
+   * Fetch the tenant's site manifest once and cache it (H6). The server only
+   * serves reviewed manifests (404 otherwise); reviewed===true is re-checked
+   * here anyway, and the engine's loadSiteManifest enforces it a third time at
+   * construction — an unreviewed map must never steer the agent. Any failure
+   * (404, network, bad JSON) degrades to null: single-page mode, run proceeds.
+   */
+  _getSiteManifest() {
+    if (!this._manifestPromise) {
+      this._manifestPromise = (async () => {
+        try {
+          const res = await globalThis.fetch(`${this._get('baseUrl')}/api/v1/manifest`, {
+            headers: { Authorization: `Bearer ${this._get('apiKey')}` },
+          });
+          if (!res || !res.ok) return null;
+          const json = await res.json();
+          return json && json.reviewed === true ? json : null;
+        } catch (e) {
+          return null;
+        }
+      })();
+    }
+    return this._manifestPromise;
+  }
+
+  /** The exact TrustedPageAgent config (also what tests assert against). */
+  _engineConfig() {
+    return {
+      llm: {
+        provider: 'openai-compatible',
+        baseURL: `${this._get('baseUrl')}${LLM_PROXY_PATH}`,
+        apiKey: this._get('apiKey'),
+        model: 'tenant-default', // hint only — the backend proxy picks the real model
+      },
+      allowedOrigins: [window.location.origin],
+      onConfirm: (pending) =>
+        new Promise((resolve) => {
+          let settled = false;
+          const respond = (allowed) => {
+            if (settled) return;
+            settled = true;
+            resolve(allowed === true); // fail-closed: only explicit true allows
+          };
+          this._emit('agent:confirm', { pending, respond });
+        }),
+      onAskUser: (question) =>
+        new Promise((resolve, reject) => {
+          let settled = false;
+          this._emit('agent:ask', {
+            question,
+            respond: (answer) => {
+              if (settled) return;
+              settled = true;
+              resolve(String(answer ?? ''));
+            },
+            cancel: () => {
+              if (settled) return;
+              settled = true;
+              reject(new Error('dismissed'));
+            },
+          });
+        }),
+      onActivity: (ev) => this._onEngineActivity(ev),
+      domConfig: { interactiveBlacklist: this._widgetBlacklist() },
+      // H7: every engine navigation checkpoints first, then really navigates
+      navigateImpl: (url) => this._checkpointAndNavigate(url),
+      maxSteps: 25,
+    };
+  }
+
+  /**
+   * Write the run checkpoint, then navigate (H7). Called by the engine's
+   * controller AFTER the guard allowed the navigation. The checkpoint is
+   * best-effort — a failure to save must never block the navigation itself.
+   * The in-flight navigate step is not in engine history yet (the loop pushes
+   * after the action), so a synthetic marker entry records where we headed.
+   */
+  async _checkpointAndNavigate(url) {
+    try {
+      if (this.sessionManager && this.engine && typeof this.engine.getRunState === 'function') {
+        const st = this.engine.getRunState() || {};
+        const history = (st.history ?? []).slice(-50).map(String);
+        history.push(`<step_${st.stepsUsed ?? '?'}> navigate → heading to ${url} (checkpoint saved)`);
+        const checkpoint = {
+          v: 1,
+          task: this._currentTask ?? '',
+          stepsUsed: Number.isInteger(st.stepsUsed) ? st.stepsUsed : 0,
+          history: history.slice(-50),
+          audit: (st.audit ?? []).slice(-50),
+          savedAt: Date.now(),
+        };
+        // size caps write-side too: drop audit first, then trim history harder
+        if (JSON.stringify(checkpoint).length > 40000) checkpoint.audit = [];
+        if (JSON.stringify(checkpoint).length > 40000) checkpoint.history = checkpoint.history.slice(-20);
+        this.sessionManager.saveAgentCheckpoint(checkpoint);
+      }
+    } catch (e) {
+      /* checkpoint is best-effort; navigation must proceed */
+    }
+    return this._navigate(url);
+  }
+
+  /**
+   * Restore-side checkpoint validation (spec §7). Returns a human-readable
+   * problem string, or null when the checkpoint is safe to resume.
+   */
+  _checkpointProblem(cp) {
+    if (!cp || typeof cp !== 'object') return 'malformed (not an object)';
+    if (cp.v !== 1) return `malformed (unsupported checkpoint version ${cp.v})`;
+    if (typeof cp.task !== 'string' || !cp.task.trim()) return 'malformed (missing task)';
+    if (!Array.isArray(cp.history) || cp.history.some((h) => typeof h !== 'string')) {
+      return 'malformed (history must be an array of strings)';
+    }
+    if (!Number.isInteger(cp.stepsUsed) || cp.stepsUsed < 0) return 'malformed (bad stepsUsed)';
+    if (typeof cp.savedAt !== 'number') return 'malformed (bad savedAt)';
+    if (Date.now() - cp.savedAt > 10 * 60 * 1000) return 'stale (older than 10 minutes)';
+    if (cp.history.length > 50) return 'oversized (history exceeds 50 entries)';
+    try {
+      if (JSON.stringify(cp).length > 40000) return 'oversized (exceeds 40 kB)';
+    } catch {
+      return 'malformed (not serializable)';
+    }
+    return null;
+  }
+
+  /**
+   * Boot-time resume (H7): if the active session carries a checkpoint, either
+   * resume it (restored history + remaining step budget) or discard it with an
+   * audited reason. SPA route changes never reach this — resume is boot-only.
+   * @returns {Promise<{resumed:boolean, reason?:string, result?:Object}>}
+   */
+  async resumeIfCheckpointed() {
+    const sm = this.sessionManager;
+    if (!sm || typeof sm.getAgentCheckpoint !== 'function') return { resumed: false };
+    const cp = sm.getAgentCheckpoint();
+    if (!cp) return { resumed: false };
+
+    const reason = this._checkpointProblem(cp);
+    if (reason) {
+      try {
+        sm.clearAgentCheckpoint();
+      } catch (e) {
+        /* discard is best-effort */
+      }
+      this._emit('agent:activity', { type: 'checkpoint_discarded', reason });
+      return { resumed: false, reason };
+    }
+
+    // Start the resumed run in the BACKGROUND so boot completes promptly (the
+    // run may be long and may navigate again). The run clears the checkpoint
+    // when it finishes. runPromise is exposed for callers/tests that want to
+    // await completion.
+    const runPromise = this._run(
+      cp.task,
+      { restoredHistory: cp.history, stepsUsed: cp.stepsUsed },
+      { type: 'resuming', task: cp.task }
+    );
+    return { resumed: true, runPromise };
+  }
+
+  _onEngineActivity(ev) {
+    const enriched = { ...ev };
+    if (ev && ev.type === 'executing' && ev.input && typeof ev.input.index === 'number') {
+      enriched.targetSelector = this._resolveTargetSelector(ev.input.index);
+    }
+    this._emit('agent:activity', enriched);
+  }
+
+  /**
+   * Best-effort: map the engine-reported element index back to a selector so
+   * UICoach can spotlight what is about to be acted on. A fresh snapshot with
+   * the same domConfig yields the same indices in practice; any failure (e.g.
+   * no layout engine) degrades to null — never blocks the run.
+   */
+  _resolveTargetSelector(index) {
+    try {
+      if (!this._engineMod) return null;
+      const snapshot = this._engineMod.domSnapshotProvider({
+        interactiveBlacklist: this._widgetBlacklist(),
+      })();
+      const el = snapshot.selectorMap.get(index)?.ref;
+      return el ? generateSelector(el) : null;
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Frame the run task from the guidance agent_plan. The plan is trusted
+   * backend output (a restatement of the reviewed KB), unlike page content.
+   */
+  buildTask(plan = {}) {
+    const goal = String(plan.goal || '').trim() || 'Complete the task the user requested.';
+    const lines = [goal];
+    if (Array.isArray(plan.hints) && plan.hints.length) {
+      lines.push('', 'Guidance from the help article (trusted):');
+      for (const hint of plan.hints.slice(0, 7)) lines.push(`- ${hint}`);
+    }
+    if (plan.target_page_path) {
+      lines.push(
+        '',
+        `This task is normally performed on the page at ${plan.target_page_path}. ` +
+          'If the current page is not that page, work with what is visible or ' +
+          'report what is missing — never guess URLs.'
+      );
+    }
+    // Behavioral rules surfaced by live testing (see feedback memory):
+    // (1) stop when done — the model was completing tasks but not calling done,
+    //     looping to the step cap; (2) ask, never invent, missing input values.
+    lines.push(
+      '',
+      'Rules for this task:',
+      '- The moment the objective above is achieved, call done(success=true) with a ' +
+        'one-line summary. Do NOT keep acting once the goal is met, and do not ' +
+        're-verify by repeating actions.',
+      '- If a field needs a value you were not given (a title, name, amount, date, ' +
+        'email, or similar), call ask_user FIRST and WAIT for the answer, THEN type ' +
+        'EXACTLY what the person said. Do NOT type a value before asking, and never ' +
+        'invent, guess, use a placeholder, or copy an unrelated value from the page ' +
+        '(e.g. an existing row) into an input field.',
+      '- Ask for a given value only ONCE. After the person answers, immediately use ' +
+        'their exact answer in your next action — never ask the same thing again.',
+      '- If a form needs SEVERAL values you do not have (e.g. first name, last name, ' +
+        'email), ask for them ALL in ONE ask_user question (list them) rather than ' +
+        'one at a time, then fill each field with the matching answer.',
+      '- After each action, check the Current page and the visible elements to ' +
+        'confirm it had the effect you intended BEFORE moving on. If the page did ' +
+        'not change when you expected navigation, the element was wrong — pick a ' +
+        'different element or use the navigate tool; do not assume it worked.',
+      '- If you are blocked or an action is denied, call done(success=false) and ' +
+        'explain — do not retry a blocked action.'
+    );
+    return lines.join('\n');
+  }
+
+  /**
+   * Start a run from an agent_plan. One run at a time.
+   * @returns {Promise<{success:boolean, text:string, steps:number}|null>}
+   */
+  async start(plan) {
+    const task = this.buildTask(plan);
+    return this._run(task, {}, { type: 'run_start', goal: plan?.goal ?? task });
+  }
+
+  /**
+   * Shared run path for fresh starts and checkpoint resumes.
+   * @param {string} task
+   * @param {Object} engineOpts    {restoredHistory?, stepsUsed?} on resume
+   * @param {Object} startActivity emitted once the engine is ready
+   */
+  async _run(task, engineOpts, startActivity) {
+    if (this.running) {
+      this._emit('agent:activity', { type: 'info', message: 'Agent is already running.' });
+      return null;
+    }
+    this.running = true;
+    this._currentTask = task;
+    let result;
+    try {
+      if (!this._customFactory && !this._engineMod) {
+        // preload once for spotlight index->selector resolution
+        this._engineMod = await import(/* webpackMode: "eager" */ '../agent/index.js');
+      }
+      // Whole-site (H6): reviewed manifest -> engine siteManifest (null = single-page)
+      const siteManifest = await this._getSiteManifest();
+      this.engine = await this.engineFactory({ ...this._engineConfig(), siteManifest });
+      this._emit('agent:activity', startActivity);
+      // H9: pass an abort signal so Stop cancels the in-flight LLM call
+      // immediately instead of waiting for the next step boundary.
+      this._abort = new AbortController();
+      result = await this.engine.run(task, { ...engineOpts, signal: this._abort.signal });
+    } catch (e) {
+      result = { success: false, text: `Agent error: ${e.message}`, steps: 0 };
+    } finally {
+      this.running = false;
+    }
+    // The run finished IN THIS CONTEXT (done / error / SPA-continued): any
+    // checkpoint is now obsolete. A real full-page unload never reaches this
+    // line — the checkpoint survives for the boot-time resume (H7).
+    try {
+      if (this.sessionManager) this.sessionManager.clearAgentCheckpoint();
+    } catch (e) {
+      /* best-effort */
+    }
+    this._emit('agent:done', result);
+    return result;
+  }
+
+  /**
+   * Stop the current run. Aborts the in-flight LLM call (so it halts within
+   * the current step, not after it) AND sets the engine's cooperative stop
+   * flag. Emits immediate feedback so the UI acknowledges the click.
+   */
+  stop() {
+    if (!this.running) return;
+    this._emit('agent:activity', { type: 'info', message: 'Stopping…' });
+    try {
+      if (this._abort) this._abort.abort();
+    } catch (e) {
+      /* noop */
+    }
+    if (this.engine && typeof this.engine.stop === 'function') this.engine.stop();
+  }
+
+  getAuditLog() {
+    return this.engine && typeof this.engine.getAuditLog === 'function'
+      ? this.engine.getAuditLog()
+      : [];
+  }
+}
+
+export default AgentMode;

package/src/api/APIClient.js

@@ -0,0 +1,258 @@
+/**
+ * Hand Hold SDK - API Communication Layer
+ * Handles all HTTP communication with the Hand Hold backend
+ */
+
+class APIClient {
+  constructor(config) {
+    this.config = config;
+    this.baseUrl = config.baseUrl;
+    this.apiKey = config.apiKey;
+    this.timeout = config.apiTimeout || 30000;
+    this.retryAttempts = config.retryAttempts || 3;
+    this.retryDelay = config.retryDelay || 1000;
+  }
+
+  /**
+   * Make HTTP request with retry logic
+   */
+  async _request(endpoint, options = {}) {
+    const url = `${this.baseUrl}${endpoint}`;
+    
+    const defaultHeaders = {
+      'Content-Type': 'application/json',
+      'Authorization': `Bearer ${this.apiKey}`,
+    };
+
+    const config = {
+      ...options,
+      headers: {
+        ...defaultHeaders,
+        ...options.headers,
+      },
+    };
+
+    let lastError;
+    
+    for (let attempt = 1; attempt <= this.retryAttempts; attempt++) {
+      try {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+
+        const response = await fetch(url, {
+          ...config,
+          signal: controller.signal,
+        });
+
+        clearTimeout(timeoutId);
+
+        if (!response.ok) {
+          const errorData = await response.json().catch(() => ({}));
+          const error = new Error(errorData.detail || `HTTP ${response.status}`);
+          error.status = response.status;
+          error.data = errorData;
+          
+          // Don't retry on client errors (4xx) except 429
+          if (response.status >= 400 && response.status < 500 && response.status !== 429) {
+            throw error;
+          }
+          
+          // Handle rate limiting
+          if (response.status === 429) {
+            const retryAfter = response.headers.get('Retry-After') || 5;
+            await this._delay(parseInt(retryAfter, 10) * 1000);
+            continue;
+          }
+          
+          throw error;
+        }
+
+        return await response.json();
+      } catch (error) {
+        lastError = error;
+        
+        if (error.name === 'AbortError') {
+          lastError = new Error('Request timeout');
+        }
+        
+        // Don't retry on client errors
+        if (error.status >= 400 && error.status < 500) {
+          throw error;
+        }
+
+        if (attempt < this.retryAttempts) {
+          await this._delay(this.retryDelay * attempt);
+        }
+      }
+    }
+
+    throw lastError;
+  }
+
+  /**
+   * Delay utility
+   */
+  _delay(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+  }
+
+  /**
+   * POST request helper
+   */
+  async _post(endpoint, data) {
+    return this._request(endpoint, {
+      method: 'POST',
+      body: JSON.stringify(data),
+    });
+  }
+
+  /**
+   * GET request helper
+   */
+  async _get(endpoint, params = {}) {
+    const queryString = new URLSearchParams(params).toString();
+    const url = queryString ? `${endpoint}?${queryString}` : endpoint;
+    return this._request(url, { method: 'GET' });
+  }
+
+  // ============================================
+  // Intent APIs
+  // ============================================
+
+  /**
+   * Infer intents from UI elements (server validation/caching)
+   * @param {Object} data - { route, page_title, ui_elements }
+   * @returns {Promise<Object>} - { intents, cached, cache_key }
+   */
+  async inferIntents(data) {
+    return this._post('/api/v1/intents/infer', data);
+  }
+
+  /**
+   * Extract intent from free-text query (LLM-based)
+   * @param {Object} data - { user_query, route, available_intents }
+   * @returns {Promise<Object>} - { intent, confidence, clarifying_question }
+   */
+  async extractIntent(data) {
+    return this._post('/api/v1/intents/extract', data);
+  }
+
+  // ============================================
+  // Guidance APIs
+  // ============================================
+
+  /**
+   * Get step-by-step guidance for an intent
+   * @param {Object} data - { intent, route, page_context, ui_elements, session_id }
+   * @returns {Promise<Object>} - Full guidance response with steps
+   */
+  async getGuidance(data) {
+    return this._post('/api/v1/guidance', data);
+  }
+
+  /**
+   * Re-match element on a new page (multi-page flow tracking)
+   * @param {Object} data - { step_description, original_selector, route, ui_elements, session_id }
+   * @returns {Promise<Object>} - { selector, confidence, match_type, found, fallback_message }
+   */
+  async matchElement(data) {
+    return this._post('/api/v1/guidance/match-element', data);
+  }
+
+  /**
+   * Check page status for active session
+   * @param {Object} data - { session_id, route, ui_elements }
+   * @returns {Promise<Object>} - { status, action, step_info }
+   */
+  async checkPageStatus(data) {
+    return this._post('/api/v1/guidance/check-page', data);
+  }
+
+  /**
+   * Update guidance session status
+   * @param {Object} data - { session_id, status, current_step, total_steps }
+   * @returns {Promise<Object>} - { session_id, status, updated_at }
+   */
+  async updateSession(data) {
+    try {
+      return await this._post('/api/v1/guidance/sessions/update', data);
+    } catch (error) {
+      if (error.status === 404) {
+        // Session already gone on backend, treat as success/cleanup
+        return { status: 'session_not_found', session_id: data.session_id };
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Get session details
+   * @param {string} sessionId - Session ID
+   * @returns {Promise<Object>} - Session details
+   */
+  async getSession(sessionId) {
+    return this._get(`/api/v1/guidance/sessions/${sessionId}`);
+  }
+
+  /**
+   * Explain a selected term
+   * @param {Object} data - { text, route, page_title, context }
+   * @returns {Promise<Object>} - { term, explanation, related_articles, confidence }
+   */
+  async explainTerm(data) {
+    return this._post('/api/v1/explain/term', data);
+  }
+
+  // ============================================
+  // Knowledge Base APIs
+  // ============================================
+
+  /**
+   * Search knowledge base
+   * @param {string} query - Search query
+   * @param {Object} options - { limit, intent, route }
+   * @returns {Promise<Object>} - { query, results, total }
+   */
+  async searchKB(query, options = {}) {
+    return this._get('/api/v1/kb/search', {
+      q: query,
+      ...options,
+    });
+  }
+
+  /**
+   * Get KB article by ID
+   * @param {string} articleId - Article ID
+   * @returns {Promise<Object>} - Article details
+   */
+  async getArticle(articleId) {
+    return this._get(`/api/v1/kb/${articleId}`);
+  }
+
+  // ============================================
+  // Health Check
+  // ============================================
+
+  /**
+   * Check backend health
+   * @returns {Promise<Object>} - Health status
+   */
+  async healthCheck() {
+    return this._get('/health');
+  }
+
+  /**
+   * Check if backend is available
+   * @returns {Promise<boolean>}
+   */
+  async isAvailable() {
+    try {
+      await this.healthCheck();
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+}
+
+export default APIClient;