@awi-protocol/sdk 0.1.0

package/dist/index.mjs

@@ -0,0 +1,733 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/client.ts
+import fetch from "cross-fetch";
+var AWIError = class extends Error {
+  code;
+  statusCode;
+  details;
+  constructor(code, message, statusCode, details) {
+    super(message);
+    this.name = "AWIError";
+    this.code = code;
+    this.statusCode = statusCode;
+    this.details = details;
+  }
+};
+var AWIClient = class {
+  endpoint;
+  certificate;
+  timeout;
+  retries;
+  constructor(options) {
+    this.endpoint = options.endpoint.replace(/\/$/, "");
+    this.certificate = options.certificate;
+    this.timeout = options.timeout || 3e4;
+    this.retries = options.retries || 3;
+  }
+  /**
+   * Execute a recipe in proxy mode.
+   * The server runs the browser and returns structured data.
+   */
+  async execute(request) {
+    return this._request("/v1/execute", {
+      ...request,
+      mode: "proxy"
+    });
+  }
+  /**
+   * Get advisory blueprint for agent-side execution.
+   * Returns the recipe structure without running the browser.
+   */
+  async getAdvisory(target) {
+    return this._request("/v1/advisory", {
+      target
+    });
+  }
+  /**
+   * Execute in advisory mode - get blueprint then run locally.
+   * This is useful when you want to control the browser yourself.
+   */
+  async executeAdvisory(request, localExecutor) {
+    const advisory = await this.getAdvisory(request.target);
+    if (!advisory.success || !advisory.data) {
+      return {
+        ...advisory,
+        data: null
+      };
+    }
+    const startTime = Date.now();
+    try {
+      const data = await localExecutor(advisory.data, request.params);
+      const latency = Date.now() - startTime;
+      return {
+        success: true,
+        data,
+        errors: [],
+        metadata: {
+          ...advisory.metadata,
+          latency_ms: latency,
+          mode: "advisory-local"
+        },
+        execution_path: ["advisory", "local-execution"],
+        axir_intent: advisory.axir_intent
+      };
+    } catch (error) {
+      return {
+        success: false,
+        data: null,
+        errors: [{
+          code: "LOCAL_EXECUTION_ERROR",
+          message: error instanceof Error ? error.message : "Unknown error"
+        }],
+        metadata: advisory.metadata,
+        execution_path: ["advisory", "local-execution-failed"]
+      };
+    }
+  }
+  /**
+   * Submit feedback on execution quality.
+   */
+  async feedback(request) {
+    return this._request("/v1/feedback", request);
+  }
+  /**
+   * Explore an unknown domain and generate a recipe.
+   */
+  async explore(domain, action, resource) {
+    const target = `awi://${domain}/${resource || action}/${action}/v1`;
+    return this._request("/v1/execute", {
+      target,
+      params: {},
+      mode: "proxy",
+      options: { explore: true }
+    });
+  }
+  /**
+   * List supported sites in the registry.
+   */
+  async listRegistry(options) {
+    const params = new URLSearchParams();
+    if (options?.category) params.set("category", options.category);
+    if (options?.certifiedOnly) params.set("certified_only", "true");
+    if (options?.minConfidence) params.set("min_confidence", String(options.minConfidence));
+    if (options?.search) params.set("search", options.search);
+    if (options?.limit) params.set("limit", String(options.limit));
+    return this._request(`/v1/registry?${params.toString()}`, void 0, "GET");
+  }
+  /**
+   * Search registry.
+   */
+  async searchRegistry(query, limit) {
+    const params = new URLSearchParams();
+    params.set("q", query);
+    if (limit) params.set("limit", String(limit));
+    return this._request(`/v1/registry/search?${params.toString()}`, void 0, "GET");
+  }
+  /**
+   * Delegate execution to another agent.
+   */
+  async delegate(request) {
+    return this._request("/v1/delegate", request);
+  }
+  /**
+   * Join a multi-agent session.
+   */
+  async joinSession(sessionId) {
+    return this._request("/v1/session/join", { session_id: sessionId });
+  }
+  /**
+   * Check server health.
+   */
+  async health() {
+    const response = await fetch(`${this.endpoint}/health`, {
+      method: "GET",
+      headers: {
+        "Accept": "application/json"
+      }
+    });
+    if (!response.ok) {
+      throw new AWIError("HEALTH_CHECK_FAILED", "Server health check failed", response.status);
+    }
+    return response.json();
+  }
+  /**
+   * Get execution metrics from a response.
+   */
+  getMetrics(response) {
+    return {
+      latency_ms: response.metadata?.latency_ms || 0,
+      fallback_count: response.metadata?.fallback_count || 0,
+      selectors_used: response.metadata?.selectors_used || [],
+      cache_status: response.metadata?.cache_status || "miss"
+    };
+  }
+  async _request(path2, body, method = "POST") {
+    const url = `${this.endpoint}${path2}`;
+    const headers = {
+      "Content-Type": "application/json",
+      "Accept": "application/json",
+      "AWI-Agent-Certificate": this.certificate
+    };
+    let lastError;
+    for (let attempt = 0; attempt < this.retries; attempt++) {
+      try {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        const response = await fetch(url, {
+          method,
+          headers,
+          body: body ? JSON.stringify(body) : void 0,
+          signal: controller.signal
+        });
+        clearTimeout(timeoutId);
+        if (!response.ok) {
+          const errorData = await response.json().catch(() => ({}));
+          throw new AWIError(
+            errorData.errors?.[0]?.code || "REQUEST_FAILED",
+            errorData.errors?.[0]?.message || `HTTP ${response.status}`,
+            response.status,
+            errorData
+          );
+        }
+        return response.json();
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error));
+        if (error instanceof AWIError && error.statusCode >= 400 && error.statusCode < 500) {
+          throw error;
+        }
+        if (attempt < this.retries - 1) {
+          await new Promise((resolve) => setTimeout(resolve, Math.pow(2, attempt) * 1e3));
+        }
+      }
+    }
+    throw lastError || new AWIError("MAX_RETRIES", "Max retries exceeded", 502);
+  }
+};
+var client_default = AWIClient;
+
+// src/advisory-executor.ts
+var AdvisoryExecutor = class {
+  context;
+  metrics;
+  constructor(context) {
+    this.context = context;
+    this.metrics = {
+      latency_ms: 0,
+      fallback_count: 0,
+      selectors_used: [],
+      cache_status: "bypass"
+    };
+  }
+  /**
+   * Execute a recipe blueprint locally.
+   */
+  async execute(recipe, params) {
+    const startTime = Date.now();
+    const errors = [];
+    const executionPath = [];
+    try {
+      for (const step of recipe.steps) {
+        const stepResult = await this._executeStep(step, params, recipe);
+        if (stepResult.error) {
+          errors.push(stepResult.error);
+          break;
+        }
+        executionPath.push(`${step.type}:${step.name || "unnamed"}`);
+      }
+      let data = null;
+      if (errors.length === 0 && recipe.extraction) {
+        data = await this._extractData(recipe);
+      }
+      this.metrics.latency_ms = Date.now() - startTime;
+      return {
+        success: errors.length === 0,
+        data,
+        errors,
+        metrics: { ...this.metrics }
+      };
+    } catch (error) {
+      return {
+        success: false,
+        data: null,
+        errors: [{
+          code: "EXECUTION_ERROR",
+          message: error instanceof Error ? error.message : "Unknown error"
+        }],
+        metrics: { ...this.metrics }
+      };
+    }
+  }
+  async _executeStep(step, params, recipe) {
+    try {
+      switch (step.type) {
+        case "navigate":
+          if (step.url) {
+            const url = this._interpolate(step.url, params);
+            this.context.window.location.href = url;
+          }
+          break;
+        case "wait":
+          if (step.selector) {
+            const selectorSet = recipe.selectors[step.selector];
+            if (selectorSet) {
+              await this._waitForSelector(selectorSet);
+            }
+          } else {
+            await this._sleep(1e3);
+          }
+          break;
+        case "click":
+          if (step.selector) {
+            const element = this._resolveSelector(recipe.selectors[step.selector]);
+            if (element) {
+              element.click();
+            } else {
+              return { error: { code: "CLICK_FAILED", message: `Selector not found: ${step.selector}` } };
+            }
+          }
+          break;
+        case "type":
+          if (step.selector && step.value) {
+            const element = this._resolveSelector(recipe.selectors[step.selector]);
+            if (element) {
+              const value = this._interpolate(step.value, params);
+              element.value = value;
+              element.dispatchEvent(new Event("input", { bubbles: true }));
+            } else {
+              return { error: { code: "TYPE_FAILED", message: `Selector not found: ${step.selector}` } };
+            }
+          }
+          break;
+        case "scroll":
+          const amount = step.amount || 500;
+          this.context.window.scrollBy(0, amount);
+          break;
+        case "extract_list":
+        case "extract_one":
+          break;
+      }
+      return {};
+    } catch (error) {
+      return {
+        error: {
+          code: "STEP_ERROR",
+          message: error instanceof Error ? error.message : "Unknown step error"
+        }
+      };
+    }
+  }
+  async _extractData(recipe) {
+    const extraction = recipe.extraction;
+    if (!extraction) return null;
+    const containerSet = recipe.selectors[extraction.container];
+    if (!containerSet) return null;
+    const container = this._resolveSelector(containerSet);
+    if (!container) return null;
+    const items = extraction.mode === "list" ? Array.from(container.children) : [container];
+    const results = [];
+    for (const item of items) {
+      const record = {};
+      for (const field of extraction.fields) {
+        const fieldSet = recipe.selectors[field.selector];
+        if (fieldSet) {
+          const fieldElement = this._resolveSelectorWithin(item, fieldSet);
+          if (fieldElement) {
+            let value = fieldElement.textContent || "";
+            if (field.transform) {
+              value = String(this._applyTransform(value, field.transform));
+            }
+            record[field.name] = value;
+          } else {
+            record[field.name] = null;
+          }
+        }
+      }
+      results.push(record);
+    }
+    return extraction.mode === "one" ? results[0] : results;
+  }
+  _resolveSelector(selectorSet) {
+    for (const selector of selectorSet.selectors) {
+      const element = this._trySelector(selector.type, selector.value);
+      if (element) {
+        this.metrics.selectors_used.push(selectorSet.name);
+        return element;
+      }
+      this.metrics.fallback_count++;
+    }
+    return null;
+  }
+  _resolveSelectorWithin(parent, selectorSet) {
+    for (const selector of selectorSet.selectors) {
+      try {
+        const element = parent.querySelector(selector.value);
+        if (element) {
+          this.metrics.selectors_used.push(selectorSet.name);
+          return element;
+        }
+      } catch {
+      }
+    }
+    return null;
+  }
+  _trySelector(type, value) {
+    try {
+      switch (type) {
+        case "css":
+          return this.context.document.querySelector(value);
+        case "semantic":
+          return this.context.document.querySelector(`[data-testid="${value}"]`);
+        case "text":
+          const xpath = `//*[contains(text(), "${value}")]`;
+          const result = this.context.document.evaluate(
+            xpath,
+            this.context.document,
+            null,
+            XPathResult.FIRST_ORDERED_NODE_TYPE,
+            null
+          );
+          return result.singleNodeValue;
+        case "attribute":
+          return this.context.document.querySelector(`[${value}]`);
+        default:
+          return null;
+      }
+    } catch {
+      return null;
+    }
+  }
+  async _waitForSelector(selectorSet, timeout = 1e4) {
+    const start = Date.now();
+    while (Date.now() - start < timeout) {
+      if (this._resolveSelector(selectorSet)) {
+        return;
+      }
+      await this._sleep(100);
+    }
+    throw new Error(`Timeout waiting for selector: ${selectorSet.name}`);
+  }
+  _interpolate(template, params) {
+    return template.replace(/\{([^}]+)\}/g, (match, key) => {
+      const value = params[key];
+      return value !== void 0 ? String(value) : match;
+    });
+  }
+  _applyTransform(value, transform) {
+    switch (transform) {
+      case "strip":
+        return value.trim();
+      case "strip_currency":
+        return value.replace(/[$€,\s]/g, "").trim();
+      case "number":
+        const digits = value.replace(/[^0-9.]/g, "");
+        return digits.includes(".") ? parseFloat(digits) : parseInt(digits, 10);
+      case "lower":
+        return value.toLowerCase();
+      case "upper":
+        return value.toUpperCase();
+      default:
+        return value;
+    }
+  }
+  _sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+
+// src/compiler/local-axir.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import * as https from "https";
+import * as http from "http";
+
+// src/compiler/grammar/axir-schema.gbnf
+var axir_schema_default = 'root ::= "{" ws axir-fields ws "}"\n\naxir-fields ::=\n  "\\"workflow\\"" ":" workflow ws ","\n  ws "\\"intents\\"" ":" intents ws ","\n  ws "\\"selectors\\"" ":" selectors ws ","\n  ws "\\"fields\\"" ":" fields\n  ["," ws "\\"container\\"" ":" string]\n  ["," ws "\\"model_used\\"" ":" string]\n  ["," ws "\\"tokens_used\\"" ":" number]\n  ["," ws "\\"compilation_time_ms\\"" ":" number]\n\nworkflow ::=\n  "{" ws\n    "\\"nodes\\"" ":" "{" ws node-list ws "}" ws ","\n    ws "\\"edges\\"" ":" "[" ws edge-list ws "]" ws ","\n    ws "\\"entry_points\\"" ":" "[" ws string-list ws "]" ws ","\n    ws "\\"exit_points\\"" ":" "[" ws string-list ws "]" ws ","\n    ws "\\"domain\\"" ":" string ws ","\n    ws "\\"page_type\\"" ":" page-type\n    ["," ws "\\"structure_hash\\"" ":" string]\n  ws "}"\n\nnode-list ::= [node-pair ("," ws node-pair)*]\nnode-pair ::= string ":" "{" ws\n  "\\"element_type\\"" ":" element-type ws ","\n  ws "\\"semantic_role\\"" ":" string ws ","\n  ws "\\"intent\\"" ":" string ws ","\n  ws "\\"tag\\"" ":" string ws ","\n  ws "\\"selector_candidates\\"" ":" "[" ws selector-list ws "]"\n  ["," ws "\\"parent_id\\"" ":" string]\n  ["," ws "\\"children_ids\\"" ":" "[" ws string-list ws "]"]\n  ["," ws "\\"aria_label\\"" ":" string]\n  ["," ws "\\"aria_role\\"" ":" string]\n  ["," ws "\\"text_content\\"" ":" string]\n  "," ws "\\"confidence\\"" ":" number\n  ["," ws "\\"reasoning\\"" ":" string]\nws "}"\n\nelement-type ::=\n  "\\"button\\"" | "\\"link\\"" | "\\"input\\"" | "\\"form\\"" |\n  "\\"navigation\\"" | "\\"search\\"" | "\\"filter\\"" | "\\"sort\\"" |\n  "\\"pagination\\"" | "\\"container\\"" | "\\"list\\"" | "\\"item\\"" |\n  "\\"heading\\"" | "\\"text\\"" | "\\"image\\"" | "\\"unknown\\""\n\npage-type ::=\n  "\\"landing\\"" | "\\"search\\"" | "\\"listing\\"" | "\\"detail\\"" |\n  "\\"form\\"" | "\\"checkout\\"" | "\\"dashboard\\"" | "\\"unknown\\""\n\nedge-list ::= [edge ("," ws edge)*]\nedge ::= "{" ws\n  "\\"from_node\\"" ":" string ws ","\n  ws "\\"to_node\\"" ":" string ws ","\n  ws "\\"action\\"" ":" string\n  ["," ws "\\"condition\\"" ":" string]\n  ["," ws "\\"probability\\"" ":" number]\nws "}"\n\nselector-list ::= [selector ("," ws selector)*]\nselector ::= "{" ws\n  "\\"type\\"" ":" selector-type ws ","\n  ws "\\"value\\"" ":" string ws ","\n  ws "\\"priority\\"" ":" number\n  ["," ws "\\"confidence\\"" ":" number]\nws "}"\n\nselector-type ::= "\\"css\\"" | "\\"semantic\\"" | "\\"text\\"" | "\\"attribute\\""\n\nintents ::= "[" ws [intent ("," ws intent)*] ws "]"\nintent ::= "{" ws\n  "\\"intent\\"" ":" string ws ","\n  ws "\\"action\\"" ":" string ws ","\n  ws "\\"parameters\\"" ":" "[" ws [string ("," ws string)*] ws "]" ws ","\n  ws "\\"context\\"" ":" string\nws "}"\n\nfields ::= "[" ws [field ("," ws field)*] ws "]"\nfield ::= "{" ws\n  "\\"name\\"" ":" string ws ","\n  ws "\\"selector\\"" ":" string\n  ["," ws "\\"transform\\"" ":" string]\n  ["," ws "\\"required\\"" ":" boolean]\nws "}"\n\nselectors ::= "{" ws [selector-pair ("," ws selector-pair)*] ws "}"\nselector-pair ::= string ":" "[" ws selector-list ws "]"\n\nstring-list ::= [string ("," ws string)*]\n\nstring ::= "\\"" char* "\\""\nchar ::= [^"\\\\] | "\\\\" (["\\\\/bfnrt] | "u" [0-9a-fA-F]{4})\n\nnumber ::= ["-"]? ("0" | [1-9] [0-9]*) ([.] [0-9]+)? ([eE] ["-"]? [0-9]+)?\n\nboolean ::= "true" | "false"\n\nws ::= [ \\t\\n\\r]*\n';
+
+// src/compiler/local-axir.ts
+var nativeAvailable = false;
+var getLlama;
+try {
+  const llama = __require("node-llama-cpp");
+  getLlama = llama.getLlama;
+  nativeAvailable = true;
+} catch {
+  nativeAvailable = false;
+}
+var DEFAULT_MODEL_URL = "https://huggingface.co/bartowski/Phi-3-mini-128k-instruct-GGUF/resolve/main/Phi-3-mini-128k-instruct-Q4_K_M.gguf";
+var DEFAULT_MODEL_FILENAME = "phi3-128k-q4.gguf";
+var LocalAXIRCompiler = class {
+  modelPath;
+  modelUrl;
+  contextSize;
+  gpuLayers;
+  onDownloadProgress;
+  onStatus;
+  model = null;
+  context = null;
+  grammar = null;
+  ready = false;
+  constructor(options = {}) {
+    if (!nativeAvailable) {
+      throw new Error(
+        "Local AXIR compilation requires node-llama-cpp.\nInstall it:  npm install node-llama-cpp\nNote: this package contains native C++ bindings and needs build tools.\n  * macOS: Xcode Command Line Tools (xcode-select --install)\n  * Linux: build-essential / gcc-c++ / python3\n  * Windows: Visual Studio Build Tools or windows-build-tools npm package\nDocs: https://github.com/withcatai/node-llama-cpp#installation"
+      );
+    }
+    const cacheDir = path.join(os.homedir(), ".awi", "models");
+    this.modelPath = options.modelPath || path.join(cacheDir, DEFAULT_MODEL_FILENAME);
+    this.modelUrl = options.modelUrl || DEFAULT_MODEL_URL;
+    this.contextSize = options.contextSize || 32768;
+    this.gpuLayers = options.gpuLayers;
+    this.onDownloadProgress = options.onDownloadProgress;
+    this.onStatus = options.onStatus;
+  }
+  // -------------------------------------------------------------------------
+  // Public API
+  // -------------------------------------------------------------------------
+  async compile(domHTML, a11yTree, intent, params) {
+    await this._ensureModel();
+    await this._ensureGrammar();
+    const prompt = this._buildCompilePrompt(domHTML, a11yTree, intent, params);
+    const start = Date.now();
+    this._status("Compiling AXIR locally...");
+    const resultText = await this._complete(prompt, 4096, 0.3);
+    const parsed = JSON.parse(resultText);
+    parsed.model_used = "phi-3-mini-128k-q4-local";
+    parsed.tokens_used = this._estimateTokens(prompt, resultText);
+    parsed.compilation_time_ms = Date.now() - start;
+    this._status(`AXIR compiled in ${parsed.compilation_time_ms}ms`);
+    return parsed;
+  }
+  async heal(domHTML, brokenSelector, semanticIntent) {
+    await this._ensureModel();
+    const prompt = this._buildHealPrompt(domHTML, brokenSelector, semanticIntent);
+    const start = Date.now();
+    this._status("Healing selector locally...");
+    const resultText = await this._complete(prompt, 256, 0.1);
+    let selector;
+    let confidence = 0.85;
+    let reasoning;
+    try {
+      const parsed = JSON.parse(resultText);
+      selector = parsed.selector ?? parsed;
+      confidence = parsed.confidence ?? 0.85;
+      reasoning = parsed.reasoning;
+    } catch {
+      selector = resultText.trim().replace(/^["']|["']$/g, "");
+    }
+    this._status(`Selector healed in ${Date.now() - start}ms`);
+    return { selector, confidence, reasoning };
+  }
+  isModelCached() {
+    return fs.existsSync(this.modelPath);
+  }
+  clearCache() {
+    if (fs.existsSync(this.modelPath)) {
+      fs.unlinkSync(this.modelPath);
+      this.model = null;
+      this.context = null;
+      this.grammar = null;
+      this.ready = false;
+    }
+  }
+  // -------------------------------------------------------------------------
+  // Model lifecycle
+  // -------------------------------------------------------------------------
+  async _ensureModel() {
+    if (this.ready) return;
+    if (!fs.existsSync(this.modelPath)) {
+      await this._downloadModel();
+    }
+    this._status("Loading local model...");
+    const llama = await getLlama();
+    const gpuLayers = this.gpuLayers ?? this._autoDetectGPULayers();
+    this.model = new llama.LlamaModel({
+      modelPath: this.modelPath,
+      gpuLayers
+    });
+    this.context = await this.model.createContext({
+      contextSize: this.contextSize
+    });
+    this.ready = true;
+    this._status("Local model ready.");
+  }
+  async _ensureGrammar() {
+    if (this.grammar) return;
+    const llama = await getLlama();
+    this.grammar = new llama.LlamaGrammar({
+      grammar: axir_schema_default
+    });
+  }
+  _autoDetectGPULayers() {
+    if (process.env.AWI_GPU_LAYERS) {
+      return parseInt(process.env.AWI_GPU_LAYERS, 10);
+    }
+    return 0;
+  }
+  // -------------------------------------------------------------------------
+  // Resumable model download
+  // -------------------------------------------------------------------------
+  async _downloadModel() {
+    const dir = path.dirname(this.modelPath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    const tempPath = `${this.modelPath}.tmp`;
+    const urlObj = new URL(this.modelUrl);
+    const protocol = urlObj.protocol === "https:" ? https : http;
+    let startByte = 0;
+    if (fs.existsSync(tempPath)) {
+      startByte = fs.statSync(tempPath).size;
+      this._status(`Resuming download from ${startByte} bytes...`);
+    } else {
+      this._status("Downloading local compiler model (2.7GB, one-time)...");
+    }
+    return new Promise((resolve, reject) => {
+      const headers = {
+        "User-Agent": "AWI-SDK/1.0"
+      };
+      if (startByte > 0) {
+        headers["Range"] = `bytes=${startByte}-`;
+      }
+      const request = protocol.get(
+        urlObj,
+        { headers },
+        (response) => {
+          if (response.statusCode === 301 || response.statusCode === 302) {
+            if (response.headers.location) {
+              this.modelUrl = response.headers.location;
+              return this._downloadModel().then(resolve).catch(reject);
+            }
+          }
+          if (response.statusCode !== 200 && response.statusCode !== 206) {
+            return reject(
+              new Error(`Model download failed: HTTP ${response.statusCode}`)
+            );
+          }
+          const total = parseInt(
+            response.headers["content-length"] || "0",
+            10
+          );
+          const append = startByte > 0 && response.statusCode === 206;
+          const file = fs.createWriteStream(tempPath, { flags: append ? "a" : "w" });
+          let downloaded = startByte;
+          response.on("data", (chunk) => {
+            downloaded += chunk.length;
+            this.onDownloadProgress?.(downloaded, total + startByte);
+          });
+          response.pipe(file);
+          file.on("finish", () => {
+            file.close();
+            fs.renameSync(tempPath, this.modelPath);
+            this._status("Model download complete.");
+            resolve();
+          });
+          file.on("error", (err) => {
+            fs.unlinkSync(tempPath);
+            reject(err);
+          });
+        }
+      );
+      request.on("error", reject);
+      request.setTimeout(3e5, () => {
+        request.destroy();
+        reject(new Error("Model download timed out after 5 minutes"));
+      });
+    });
+  }
+  // -------------------------------------------------------------------------
+  // Inference
+  // -------------------------------------------------------------------------
+  async _complete(prompt, maxTokens, temperature) {
+    if (!this.context) throw new Error("Model not loaded");
+    const sequence = this.context.getSequence();
+    await sequence.evaluate(prompt);
+    const response = await sequence.generateResponse(maxTokens, {
+      temperature,
+      grammar: this.grammar
+    });
+    let text = "";
+    for await (const token of response) {
+      text += token;
+    }
+    return text;
+  }
+  // -------------------------------------------------------------------------
+  // Prompt builders
+  // -------------------------------------------------------------------------
+  _buildCompilePrompt(domHTML, a11yTree, intent, params) {
+    const paramsJson = params ? JSON.stringify(params, null, 2) : "{}";
+    return [
+      `<|system|>`,
+      `You are an expert web-scraping analyst. Your job is to read a simplified DOM and accessibility tree, then output a structured JSON object describing the page layout, interactive elements, and data extraction plan.`,
+      ``,
+      `Output MUST be valid JSON matching this schema:`,
+      `- workflow.nodes: map of node_id -> {element_type, semantic_role, intent, tag, selector_candidates[], parent_id?, children_ids?, aria_label?, aria_role?, text_content?, confidence, reasoning?}`,
+      `- workflow.edges: list of {from_node, to_node, action, condition?, probability}`,
+      `- workflow.entry_points: list of starting node_ids`,
+      `- workflow.exit_points: list of terminal node_ids`,
+      `- workflow.domain: the domain name`,
+      `- workflow.page_type: one of landing|search|listing|detail|form|checkout|dashboard|unknown`,
+      `- intents: list of {intent, action, parameters[], context}`,
+      `- selectors: map of selector_name -> list of {type, value, priority}`,
+      `- fields: list of {name, selector, transform?, required}`,
+      `- container?: string (optional container selector name)`,
+      ``,
+      `Element types: button, link, input, form, navigation, search, filter, sort, pagination, container, list, item, heading, text, image, unknown.`,
+      `Selector types: css, semantic, text, attribute.`,
+      `<|user|>`,
+      `Intent: ${intent}`,
+      `Parameters: ${paramsJson}`,
+      ``,
+      `Simplified DOM:`,
+      `${this._truncate(domHTML, 4e4)}`,
+      ``,
+      `Accessibility Tree:`,
+      `${this._truncate(a11yTree, 8e3)}`,
+      ``,
+      `Compile AXIR:`,
+      `<|assistant|>`
+    ].join("\n");
+  }
+  _buildHealPrompt(domHTML, brokenSelector, semanticIntent) {
+    return [
+      `<|system|>`,
+      `You are a CSS selector repair tool. Given a broken selector and the current DOM, output the new CSS selector that targets the same semantic element.`,
+      ``,
+      `Output JSON: {"selector": "...", "confidence": 0.0-1.0, "reasoning": "..."}`,
+      `<|user|>`,
+      `Broken selector: ${brokenSelector}`,
+      `Semantic intent: ${semanticIntent}`,
+      ``,
+      `Current DOM (truncated):`,
+      `${this._truncate(domHTML, 2e4)}`,
+      ``,
+      `New selector:`,
+      `<|assistant|>`
+    ].join("\n");
+  }
+  _truncate(text, maxChars) {
+    if (text.length <= maxChars) return text;
+    return text.slice(0, maxChars) + "\n[...truncated...]";
+  }
+  _estimateTokens(prompt, response) {
+    return Math.ceil((prompt.length + response.length) / 4);
+  }
+  _status(message) {
+    this.onStatus?.(message);
+  }
+};
+export {
+  AWIClient,
+  AWIError,
+  AdvisoryExecutor,
+  LocalAXIRCompiler,
+  client_default as default
+};
+//# sourceMappingURL=index.mjs.map