@wenathlan/extension 1.1.56 → 1.1.57

package/extension/dist/background.js

@@ -2615,6 +2615,119 @@ var sessionmemory = class {
   async setdryruntoggle(enabled) {
     return this.adapter.set("mcpdryruntoggle", enabled);
   }
+  /** Returns every user configured provider config of the 1.1.57 llm integration; the api keys stay behind their storage id references, never inside these records. */
+  async getproviders() {
+    return await this.adapter.get("llmproviders") ?? [];
+  }
+  /** Replaces the stored provider config set after one save, test or removal. */
+  async setproviders(providers) {
+    return this.adapter.set("llmproviders", providers);
+  }
+  /** Returns the user configured local model endpoint of the browser reachable inference. */
+  async getlocalmodel() {
+    return this.adapter.get("llmlocalmodel");
+  }
+  /** Stores the local model endpoint config after one save or health check. */
+  async setlocalmodel(config) {
+    return this.adapter.set("llmlocalmodel", config);
+  }
+  /** Returns every model route entry of the routing table, newest update first. */
+  async getmodelroutes() {
+    return await this.adapter.get("llmmodelroutes") ?? [];
+  }
+  /** Replaces the stored routing table after one route edit. */
+  async setmodelroutes(routes) {
+    return this.adapter.set("llmmodelroutes", routes);
+  }
+  /** Appends one revision entry to the model route revision history so every routing change stays queryable for audit. */
+  async addmodelrouterevision(route) {
+    await this.adapter.set("llmmodelroutehistory", [route, ...await this.adapter.get("llmmodelroutehistory") ?? []].slice(0, 200));
+  }
+  /** Returns the model route revision history, newest first. */
+  async getmodelroutehistory() {
+    return await this.adapter.get("llmmodelroutehistory") ?? [];
+  }
+  /** Records one usage entry of a model call with its run and step ids; the newest call reads first and an absent retention keeps every record. */
+  async addusagerecord(record2) {
+    await this.adapter.set("llmusage", [record2, ...await this.adapter.get("llmusage") ?? []]);
+  }
+  /** Returns every stored usage record of model calls, newest first. */
+  async getusagerecords() {
+    return await this.adapter.get("llmusage") ?? [];
+  }
+  /** Returns the token and cost totals per period: the run, the step, the since floor and the until ceiling stay optional filters over the stored usage records. */
+  async getusage(filter = {}) {
+    const records = (await this.getusagerecords()).filter((record2) => (filter.runid === void 0 || record2.runid === filter.runid) && (filter.stepid === void 0 || record2.stepid === filter.stepid) && (filter.since === void 0 || record2.at >= filter.since) && (filter.until === void 0 || record2.at <= filter.until));
+    return records.reduce((totals, record2) => ({ prompttokens: totals.prompttokens + record2.prompttokens, completiontokens: totals.completiontokens + record2.completiontokens, totaltokens: totals.totaltokens + record2.totaltokens, cost: totals.cost + record2.cost, calls: totals.calls + 1 }), { prompttokens: 0, completiontokens: 0, totaltokens: 0, cost: 0, calls: 0 });
+  }
+  /** Stores one model drafted plan for review and audit; newer drafts read first. */
+  async addplandraft(draft) {
+    await this.adapter.set("llmplandrafts", [draft, ...await this.adapter.get("llmplandrafts") ?? []]);
+  }
+  /** Replaces the stored draft set after one review decision. */
+  async setplandrafts(drafts) {
+    return this.adapter.set("llmplandrafts", drafts);
+  }
+  /** Returns every stored model drafted plan, newest first. */
+  async getplandrafts() {
+    return await this.adapter.get("llmplandrafts") ?? [];
+  }
+  /** Stores one replan record for the fresh review and the audit history; newer replans read first. */
+  async addreplan(replan) {
+    await this.adapter.set("llmreplans", [replan, ...await this.adapter.get("llmreplans") ?? []]);
+  }
+  /** Replaces the stored replan set after one fresh review decision. */
+  async setreplans(replans) {
+    return this.adapter.set("llmreplans", replans);
+  }
+  /** Returns every stored replan record, newest first. */
+  async getreplans() {
+    return await this.adapter.get("llmreplans") ?? [];
+  }
+  /** Stores one reflection note of an executed step under the recent note window of 100 records. */
+  async addreflectnote(note) {
+    await this.adapter.set("llmreflectnotes", [note, ...await this.adapter.get("llmreflectnotes") ?? []].slice(0, 100));
+  }
+  /** Returns the stored reflection notes, newest first. */
+  async getreflectnotes() {
+    return await this.adapter.get("llmreflectnotes") ?? [];
+  }
+  /** Replaces the stored prompt template library after one save or removal; every version with its change notes stays stored. */
+  async setprompttemplates(templates) {
+    return this.adapter.set("llmprompttemplates", templates);
+  }
+  /** Returns the stored prompt template library with every version, newest first. */
+  async getprompttemplates() {
+    return await this.adapter.get("llmprompttemplates") ?? [];
+  }
+  /** Returns the stored cost budget of the runs; the run scoped budget wins over the shared one when both exist. */
+  async getcostbudget(runid) {
+    const budgets = await this.adapter.get("llmcostbudgets") ?? [];
+    return budgets.find((budget) => runid !== void 0 && budget.runid === runid) ?? budgets.find((budget) => budget.runid === void 0);
+  }
+  /** Stores one cost budget; a run scoped budget replaces the earlier budget of its run while the shared budget replaces the shared one. */
+  async setcostbudget(budget) {
+    const budgets = await this.adapter.get("llmcostbudgets") ?? [];
+    const kept = budgets.filter((candidate) => candidate.runid !== budget.runid);
+    await this.adapter.set("llmcostbudgets", [budget, ...kept]);
+  }
+  /** Returns the latest parsed natural language command with its intent badge payload. */
+  async getcommandparse() {
+    return this.adapter.get("llmcommandparse");
+  }
+  /** Stores the latest parsed natural language command. */
+  async setcommandparse(parse) {
+    return this.adapter.set("llmcommandparse", parse);
+  }
+  /** Returns the recent guard refusal notices of invalid or refused model output, newest first under a window of 50. */
+  async getguardnotices() {
+    return await this.adapter.get("llmguardnotices") ?? [];
+  }
+  /** Records one guard refusal notice for the panel; the verdict reason explains the parse failure and its retries. */
+  async addguardnotice(output) {
+    if (output.verdict === "valid") return;
+    await this.adapter.set("llmguardnotices", [output, ...await this.getguardnotices()].slice(0, 50));
+  }
 };
 function mediakindof(record2) {
   if ("pages" in record2) return "pdf";
@@ -6875,8 +6988,8 @@ function validatetimelinegrammar(step, options) {
       watchwindow = reviewed.window;
     }
   }
-  const budgetcheck = debugwaitbudgetallowed(watchwindow, typeof options.wait === "number" ? options.wait : void 0);
-  if (!budgetcheck.allowed) return budgetcheck;
+  const budgetcheck2 = debugwaitbudgetallowed(watchwindow, typeof options.wait === "number" ? options.wait : void 0);
+  if (!budgetcheck2.allowed) return budgetcheck2;
   if (options.level !== void 0 && !loglevels.includes(options.level)) return { allowed: false, reason: `The reviewed level floor must be one of ${loglevels.join(", ")}.` };
   if (options.sources !== void 0) {
     if (!Array.isArray(options.sources) || options.sources.length === 0 || !options.sources.every((source) => timelinesources.includes(source))) return { allowed: false, reason: `The reviewed source filters must be a non-empty list of the reviewed timeline sources: ${timelinesources.join(", ")}.` };
@@ -7452,8 +7565,8 @@ function validatecdpgrammar(step, options) {
       const allowlist = cdpallowlistof(options.allowlist);
       if (!allowlist || !allowlist.domains.every((domain) => options.domains.includes(domain))) return { allowed: false, reason: "The reviewed method allowlist must stay inside the enabled domains of the attach." };
     }
-    const budgetcheck = debugwaitbudgetallowed(typeof options.wait === "number" ? options.wait : void 0, void 0);
-    if (!budgetcheck.allowed) return budgetcheck;
+    const budgetcheck2 = debugwaitbudgetallowed(typeof options.wait === "number" ? options.wait : void 0, void 0);
+    if (!budgetcheck2.allowed) return budgetcheck2;
     return { allowed: true };
   }
   if (kind === "detachcdp") return { allowed: true };
@@ -7477,8 +7590,8 @@ function validatecdpgrammar(step, options) {
       }
     }
     if (watchwindow === void 0) return { allowed: false, reason: "The event watch needs a reviewed lifetime window before any domain event is observed." };
-    const budgetcheck = debugwaitbudgetallowed(watchwindow, typeof options.wait === "number" ? options.wait : void 0);
-    if (!budgetcheck.allowed) return budgetcheck;
+    const budgetcheck2 = debugwaitbudgetallowed(watchwindow, typeof options.wait === "number" ? options.wait : void 0);
+    if (!budgetcheck2.allowed) return budgetcheck2;
     return { allowed: true };
   }
   if (kind === "setbreakpoint") {
@@ -7515,8 +7628,8 @@ function validateprofilegrammar(step, options) {
     if (flowspecof(options.flow) === void 0) return { allowed: false, reason: `The flow measurement needs a reviewed flow spec with its mark prefix, step window and metric list of the reviewed metric set: navigation, paint, lcp, fid, interaction, blocking.` };
     const watch = options.watch && typeof options.watch === "object" && !Array.isArray(options.watch) ? options.watch : {};
     if (typeof watch.window !== "number" || !Number.isFinite(watch.window) || watch.window < 0) return { allowed: false, reason: "The flow measurement needs a reviewed watch window of zero or more milliseconds." };
-    const budgetcheck = debugwaitbudgetallowed(watch.window, typeof options.wait === "number" ? options.wait : void 0);
-    if (!budgetcheck.allowed) return budgetcheck;
+    const budgetcheck2 = debugwaitbudgetallowed(watch.window, typeof options.wait === "number" ? options.wait : void 0);
+    if (!budgetcheck2.allowed) return budgetcheck2;
     return { allowed: true };
   }
   if (kind === "heapshot") {
@@ -7533,16 +7646,16 @@ function validateprofilegrammar(step, options) {
   if (kind === "profilecpu") {
     const profile = options.profile && typeof options.profile === "object" && !Array.isArray(options.profile) ? options.profile : void 0;
     if (!profile || typeof profile.duration !== "number" || !Number.isFinite(profile.duration) || profile.duration < 0) return { allowed: false, reason: "The cpu profile needs a reviewed duration of zero or more milliseconds." };
-    const budgetcheck = debugwaitbudgetallowed(profile.duration, typeof options.wait === "number" ? options.wait : void 0);
-    if (!budgetcheck.allowed) return budgetcheck;
+    const budgetcheck2 = debugwaitbudgetallowed(profile.duration, typeof options.wait === "number" ? options.wait : void 0);
+    if (!budgetcheck2.allowed) return budgetcheck2;
     return { allowed: true };
   }
   if (kind === "watchshifts") {
     const watch = options.watch && typeof options.watch === "object" && !Array.isArray(options.watch) ? options.watch : {};
     if (typeof watch.window !== "number" || !Number.isFinite(watch.window) || watch.window < 0) return { allowed: false, reason: "The layout shift watch needs a reviewed observation window of zero or more milliseconds; the window stays a user choice with no code ceiling." };
     if (options.threshold !== void 0 && (typeof options.threshold !== "number" || !Number.isFinite(options.threshold) || options.threshold < 0)) return { allowed: false, reason: "The reviewed shift score threshold must be zero or a positive number." };
-    const budgetcheck = debugwaitbudgetallowed(watch.window, typeof options.wait === "number" ? options.wait : void 0);
-    if (!budgetcheck.allowed) return budgetcheck;
+    const budgetcheck2 = debugwaitbudgetallowed(watch.window, typeof options.wait === "number" ? options.wait : void 0);
+    if (!budgetcheck2.allowed) return budgetcheck2;
     return { allowed: true };
   }
   if (kind === "traceload") {
@@ -7550,8 +7663,8 @@ function validateprofilegrammar(step, options) {
     if (!trace || !Array.isArray(trace.categories) || trace.categories.length === 0 || !trace.categories.every((category) => typeof category === "string" && tracecategories.includes(category))) return { allowed: false, reason: `The trace record needs a non-empty reviewed category list of the reviewed category grammar: ${tracecategories.join(", ")}.` };
     if (typeof trace.window !== "number" || !Number.isFinite(trace.window) || trace.window < 0) return { allowed: false, reason: "The trace record needs a reviewed window of zero or more milliseconds and stops at the reviewed window end." };
     if (trace.exporttarget !== void 0 && trace.exporttarget !== "memory" && trace.exporttarget !== "download") return { allowed: false, reason: "The trace export target must be memory or download." };
-    const budgetcheck = debugwaitbudgetallowed(trace.window, typeof options.wait === "number" ? options.wait : void 0);
-    if (!budgetcheck.allowed) return budgetcheck;
+    const budgetcheck2 = debugwaitbudgetallowed(trace.window, typeof options.wait === "number" ? options.wait : void 0);
+    if (!budgetcheck2.allowed) return budgetcheck2;
     return { allowed: true };
   }
   if (kind === "annotatetrace" || kind === "replaytrace") {
@@ -8546,6 +8659,66 @@ function mockusagevalid(mock) {
   if (typeof mock.result.content !== "string") return { allowed: false, reason: "A tool mock needs its canned result content." };
   return { allowed: true };
 }
+function providervalid(config) {
+  if (config.name.trim() === "") return { allowed: false, reason: "The provider config needs its name." };
+  if (config.endpoint.trim() === "") return { allowed: false, reason: "The provider config needs the user configured endpoint url; no default endpoint ever applies." };
+  let parsed;
+  try {
+    parsed = new URL(config.endpoint);
+  } catch {
+    return { allowed: false, reason: "The provider endpoint must be a well-formed url." };
+  }
+  if (parsed.protocol !== "https:" && parsed.protocol !== "http:") return { allowed: false, reason: "The provider endpoint must speak http or https." };
+  if (config.models.length === 0) return { allowed: false, reason: "The provider config needs at least one user configured model name." };
+  if (config.models.some((model) => model.trim() === "")) return { allowed: false, reason: "Every provider model name must stay non-empty free text." };
+  if (config.style !== "chatcompletions" && config.style !== "responses" && config.style !== "messages" && config.style !== "gemini") return { allowed: false, reason: "The provider protocol shape must be one of the four wire shapes the user picks." };
+  if (config.authref !== void 0 && config.authref.storageid.trim() === "") return { allowed: false, reason: "The provider auth reference needs the storage id of the stored key; the key material never enters the config." };
+  return { allowed: true };
+}
+function provideregressgrade(input) {
+  const valid = providervalid(input.provider);
+  if (!valid.allowed) return valid;
+  return { allowed: true, reason: input.local ? "The model call stays on the local machine endpoint and grades as the local data egress preference." : "The model call leaves the browser for the user configured endpoint and grades as a data egress event with its endpoint, model and token counts in the audit trail." };
+}
+function egressconsentgate(input) {
+  if (input.pagecontent !== void 0 && input.pagecontent.trim() !== "" && input.granted !== true) return { allowed: false, reason: "The model call carries page content the user has not granted, so the content stays in the browser and the call refuses." };
+  return { allowed: true };
+}
+function plandraftreviewgate(draft) {
+  if (draft.state !== "approved") return { allowed: false, reason: "The model drafted plan stays unreviewed; the human review approves the draft before any step executes." };
+  if (draft.steps.length === 0) return { allowed: false, reason: "The model drafted plan carries no step, so nothing executes." };
+  return { allowed: true };
+}
+function replanreviewgate(replan) {
+  if (replan.state !== "approved") return { allowed: false, reason: "The replanned tail stays unreviewed; the fresh review approves the changed steps before any of them executes." };
+  if (replan.tail.some((step) => step.freshreview !== true)) return { allowed: false, reason: "Every revised step of a replan must carry the fresh review marker." };
+  return { allowed: true };
+}
+function costbudgetvalid(budget) {
+  if (budget.maxtokens !== void 0 && (!Number.isFinite(budget.maxtokens) || budget.maxtokens <= 0)) return { allowed: false, reason: "The token ceiling of a cost budget must stay a positive user value." };
+  if (budget.maxcost !== void 0 && (!Number.isFinite(budget.maxcost) || budget.maxcost <= 0)) return { allowed: false, reason: "The cost ceiling of a cost budget must stay a positive user value." };
+  if (budget.maxcost !== void 0 && (budget.currency === void 0 || budget.currency.trim() === "")) return { allowed: false, reason: "The cost ceiling of a cost budget needs its currency unit." };
+  if (budget.maxtokens === void 0 && budget.maxcost === void 0) return { allowed: false, reason: "The cost budget needs at least one ceiling the user configured; an absent budget stays the documented unbounded choice." };
+  return { allowed: true };
+}
+function draftriskof(step) {
+  try {
+    return resolvedrisk({ id: step.id, kind: step.kind, ...step.target !== void 0 ? { target: step.target } : {}, ...step.value !== void 0 ? { value: step.value } : {}, summary: step.summary, risk: "sensitive" });
+  } catch {
+    return "sensitive";
+  }
+}
+function planlint(draft, origin) {
+  const findings = [];
+  if (draft.goal.trim() === "") findings.push("The drafted plan carries no goal.");
+  if (draft.steps.length === 0) findings.push("The drafted plan carries no step.");
+  for (const step of draft.steps) {
+    const mapped = { id: step.id, kind: step.kind, ...step.target !== void 0 ? { target: step.target } : {}, ...step.value !== void 0 ? { value: step.value } : {}, summary: step.summary, risk: draftriskof(step) };
+    const verdict = validatestep(mapped, origin);
+    if (!verdict.allowed) findings.push(`The drafted step ${step.id || "without id"} of kind ${step.kind || "unknown"} violates the action grammar: ${verdict.reason ?? "the step failed its grammar check."}`);
+  }
+  return findings;
+}
 
 // progress.ts
 function emptyprogress(planid, now) {
@@ -8725,7 +8898,7 @@ function recordtoolcall(progress, planid, stepid, entry, now) {
 }
 
 // version.ts
-var packageversion = "1.1.56";
+var packageversion = "1.1.57";
 
 // types.ts
 var protocolversion = packageversion;
@@ -10831,6 +11004,367 @@ function endcall(input) {
   return { contexts: input.contexts.map((candidate) => candidate.callid === input.callid ? context : candidate), context };
 }
 
+// llm.ts
+var defaultrefusalmarkers = ["i cannot", "i can't", "i'm unable", "refusal:", "cannot comply"];
+function buildrequest(input) {
+  const headers = { "content-type": "application/json" };
+  let url = input.provider.endpoint;
+  const style = input.provider.style;
+  if (style === "chatcompletions") {
+    if (input.apikey !== void 0 && input.apikey.trim() !== "") headers.authorization = `Bearer ${input.apikey}`;
+    const body2 = { model: input.model, messages: input.messages.map((message) => ({ role: message.role, content: message.content })), ...input.temperature !== void 0 ? { temperature: input.temperature } : {}, ...input.maxtokens !== void 0 ? { max_tokens: input.maxtokens } : {}, ...input.stream === true ? { stream: true } : {} };
+    return { url, method: "POST", headers: { ...headers, ...input.provider.headers ?? {} }, body: JSON.stringify(body2) };
+  }
+  if (style === "responses") {
+    if (input.apikey !== void 0 && input.apikey.trim() !== "") headers.authorization = `Bearer ${input.apikey}`;
+    const system2 = input.messages.filter((message) => message.role === "system").map((message) => message.content).join("\n");
+    const turns2 = input.messages.filter((message) => message.role !== "system").map((message) => ({ role: message.role === "assistant" ? "assistant" : "user", content: message.content }));
+    const body2 = { model: input.model, input: turns2, ...system2.trim() !== "" ? { instructions: system2 } : {}, ...input.temperature !== void 0 ? { temperature: input.temperature } : {}, ...input.maxtokens !== void 0 ? { max_output_tokens: input.maxtokens } : {}, ...input.stream === true ? { stream: true } : {} };
+    return { url, method: "POST", headers: { ...headers, ...input.provider.headers ?? {} }, body: JSON.stringify(body2) };
+  }
+  if (style === "messages") {
+    if (input.apikey !== void 0 && input.apikey.trim() !== "") headers["x-api-key"] = input.apikey;
+    const system2 = input.messages.filter((message) => message.role === "system").map((message) => message.content).join("\n");
+    const turns2 = input.messages.filter((message) => message.role !== "system").map((message) => ({ role: message.role, content: message.content }));
+    const body2 = { model: input.model, messages: turns2, ...system2.trim() !== "" ? { system: system2 } : {}, ...input.temperature !== void 0 ? { temperature: input.temperature } : {}, ...input.maxtokens !== void 0 ? { max_tokens: input.maxtokens } : {}, ...input.stream === true ? { stream: true } : {} };
+    return { url, method: "POST", headers: { ...headers, ...input.provider.headers ?? {} }, body: JSON.stringify(body2) };
+  }
+  if (input.apikey !== void 0 && input.apikey.trim() !== "") url = `${url}${url.includes("?") ? "&" : "?"}key=${encodeURIComponent(input.apikey)}`;
+  const system = input.messages.filter((message) => message.role === "system").map((message) => message.content).join("\n");
+  const turns = input.messages.filter((message) => message.role !== "system").map((message) => ({ role: message.role === "assistant" ? "model" : "user", parts: [{ text: message.content }] }));
+  const body = { contents: turns, ...system.trim() !== "" ? { systemInstruction: { parts: [{ text: system }] } } : {}, ...input.temperature !== void 0 ? { generationConfig: { temperature: input.temperature, ...input.maxtokens !== void 0 ? { maxOutputTokens: input.maxtokens } : {} } } : input.maxtokens !== void 0 ? { generationConfig: { maxOutputTokens: input.maxtokens } } : {} };
+  return { url, method: "POST", headers: { ...headers, ...input.provider.headers ?? {} }, body: JSON.stringify(body) };
+}
+function numberof(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function parsecompletion(style, body) {
+  let parsed;
+  try {
+    parsed = JSON.parse(body);
+  } catch {
+    return { reason: "The provider answer is not json." };
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return { reason: "The provider answer is not a json object." };
+  const record2 = parsed;
+  if (style === "chatcompletions") {
+    const choice = Array.isArray(record2.choices) ? record2.choices[0] : void 0;
+    const message = choice !== void 0 && choice.message !== void 0 && typeof choice.message === "object" ? choice.message : void 0;
+    if (message === void 0 || typeof message.content !== "string") return { reason: "The chat completions answer carries no message content." };
+    const usage2 = record2.usage !== void 0 && typeof record2.usage === "object" ? record2.usage : void 0;
+    const prompttokens2 = usage2 !== void 0 ? numberof(usage2.prompt_tokens) : void 0;
+    const completiontokens2 = usage2 !== void 0 ? numberof(usage2.completion_tokens) : void 0;
+    const totaltokens2 = usage2 !== void 0 ? numberof(usage2.total_tokens) : void 0;
+    return { text: message.content, ...prompttokens2 !== void 0 || completiontokens2 !== void 0 || totaltokens2 !== void 0 ? { usage: { prompttokens: prompttokens2 ?? 0, completiontokens: completiontokens2 ?? 0, totaltokens: totaltokens2 ?? (prompttokens2 ?? 0) + (completiontokens2 ?? 0) } } : {} };
+  }
+  if (style === "responses") {
+    const direct = typeof record2.output_text === "string" ? record2.output_text : void 0;
+    let text2 = direct;
+    if (text2 === void 0 && Array.isArray(record2.output)) {
+      const parts2 = [];
+      for (const item of record2.output) {
+        if (item && typeof item === "object" && Array.isArray(item.content)) {
+          for (const part of item.content) {
+            if (part && typeof part === "object" && part.type === "output_text" && typeof part.text === "string") parts2.push(part.text);
+          }
+        }
+      }
+      if (parts2.length > 0) text2 = parts2.join("");
+    }
+    if (text2 === void 0) return { reason: "The responses answer carries no output text." };
+    const usage2 = record2.usage !== void 0 && typeof record2.usage === "object" ? record2.usage : void 0;
+    const prompttokens2 = usage2 !== void 0 ? numberof(usage2.input_tokens) : void 0;
+    const completiontokens2 = usage2 !== void 0 ? numberof(usage2.output_tokens) : void 0;
+    const totaltokens2 = usage2 !== void 0 ? numberof(usage2.total_tokens) : void 0;
+    return { text: text2, ...prompttokens2 !== void 0 || completiontokens2 !== void 0 || totaltokens2 !== void 0 ? { usage: { prompttokens: prompttokens2 ?? 0, completiontokens: completiontokens2 ?? 0, totaltokens: totaltokens2 ?? (prompttokens2 ?? 0) + (completiontokens2 ?? 0) } } : {} };
+  }
+  if (style === "messages") {
+    const parts2 = [];
+    if (Array.isArray(record2.content)) {
+      for (const part of record2.content) {
+        if (part && typeof part === "object" && part.type === "text" && typeof part.text === "string") parts2.push(part.text);
+      }
+    }
+    if (parts2.length === 0) return { reason: "The messages answer carries no text block." };
+    const usage2 = record2.usage !== void 0 && typeof record2.usage === "object" ? record2.usage : void 0;
+    const prompttokens2 = usage2 !== void 0 ? numberof(usage2.input_tokens) : void 0;
+    const completiontokens2 = usage2 !== void 0 ? numberof(usage2.output_tokens) : void 0;
+    return { text: parts2.join(""), ...prompttokens2 !== void 0 || completiontokens2 !== void 0 ? { usage: { prompttokens: prompttokens2 ?? 0, completiontokens: completiontokens2 ?? 0, totaltokens: (prompttokens2 ?? 0) + (completiontokens2 ?? 0) } } : {} };
+  }
+  const candidate = Array.isArray(record2.candidates) ? record2.candidates[0] : void 0;
+  const content = candidate !== void 0 && candidate.content !== void 0 && typeof candidate.content === "object" ? candidate.content.parts : void 0;
+  const parts = [];
+  if (Array.isArray(content)) {
+    for (const part of content) {
+      if (part && typeof part === "object" && typeof part.text === "string") parts.push(part.text);
+    }
+  }
+  if (parts.length === 0) return { reason: "The gemini answer carries no candidate text." };
+  const usage = record2.usageMetadata !== void 0 && typeof record2.usageMetadata === "object" ? record2.usageMetadata : void 0;
+  const prompttokens = usage !== void 0 ? numberof(usage.promptTokenCount) : void 0;
+  const completiontokens = usage !== void 0 ? numberof(usage.candidatesTokenCount) : void 0;
+  const totaltokens = usage !== void 0 ? numberof(usage.totalTokenCount) : void 0;
+  return { text: parts.join(""), ...prompttokens !== void 0 || completiontokens !== void 0 || totaltokens !== void 0 ? { usage: { prompttokens: prompttokens ?? 0, completiontokens: completiontokens ?? 0, totaltokens: totaltokens ?? (prompttokens ?? 0) + (completiontokens ?? 0) } } : {} };
+}
+function islocalorigin(url) {
+  try {
+    const host = new URL(url).hostname.toLowerCase();
+    return host === "localhost" || host === "127.0.0.1" || host === "::1" || host === "[::1]" || host.endsWith(".localhost");
+  } catch {
+    return false;
+  }
+}
+async function callmodel(input) {
+  if (input.provider.endpoint.trim() === "") throw new Error("The provider needs the user configured endpoint url before any call leaves.");
+  if (input.provider.authref !== void 0 && (input.apikey === void 0 || input.apikey.trim() === "")) throw new Error(`The provider ${input.provider.name} references the stored key ${input.provider.authref.name} and the call needs the resolved key material.`);
+  const consent = egressconsentgate({ ...input.pagecontent !== void 0 ? { pagecontent: input.pagecontent } : {}, granted: input.pagegrant === true });
+  if (!consent.allowed) throw new Error(consent.reason ?? "The page content stayed ungranted and the call refused.");
+  const shaped = buildrequest({ provider: input.provider, model: input.model, messages: input.messages, ...input.apikey !== void 0 ? { apikey: input.apikey } : {}, ...input.temperature !== void 0 ? { temperature: input.temperature } : {}, ...input.maxtokens !== void 0 ? { maxtokens: input.maxtokens } : {}, ...input.stream === true ? { stream: true } : {} });
+  const transport = await sendfetch({ request: { url: shaped.url, method: shaped.method, headers: shaped.headers, body: shaped.body }, ...input.options !== void 0 ? { options: input.options } : {}, transport: input.transport, ...input.sleep !== void 0 ? { sleep: input.sleep } : {}, ...input.now !== void 0 ? { now: input.now } : {} });
+  const parsed = parsecompletion(input.provider.style, transport.body);
+  if (parsed.text === void 0) throw new Error(parsed.reason ?? "The provider answer did not parse.");
+  return { text: parsed.text, ...parsed.usage !== void 0 ? { usage: parsed.usage } : {}, request: shaped };
+}
+async function calllocal(input) {
+  if (input.local.endpoint.trim() === "") throw new Error("The local model needs the user configured endpoint url before any call runs.");
+  if (!islocalorigin(input.local.endpoint)) throw new Error("The local model endpoint must stay a local machine address; the call never leaves the machine.");
+  const provider = { id: "local", name: "The local model endpoint", endpoint: input.local.endpoint, style: input.local.style, models: [input.local.model], status: "available", createdat: 0 };
+  return callmodel({ provider, model: input.local.model, messages: input.messages, ...input.apikey !== void 0 ? { apikey: input.apikey } : {}, ...input.temperature !== void 0 ? { temperature: input.temperature } : {}, ...input.maxtokens !== void 0 ? { maxtokens: input.maxtokens } : {}, ...input.options !== void 0 ? { options: input.options } : {}, transport: input.transport, ...input.sleep !== void 0 ? { sleep: input.sleep } : {}, ...input.now !== void 0 ? { now: input.now } : {} });
+}
+var commandguard = { schema: { intent: { type: "string", required: true }, entities: { type: "array", required: true }, confidence: { type: "number", required: true } }, retries: 1 };
+function classifyintent(text2) {
+  const words = text2.toLowerCase().split(/[^a-z0-9]+/).filter(Boolean);
+  if (words.length === 0) return { intent: "ask", confidence: 0 };
+  const scores = { navigate: 0, extract: 0, fill: 0, monitor: 0, automate: 0, ask: 0 };
+  const keywords = [
+    ["navigate", ["go", "open", "visit", "navigate", "browse", "url", "site", "page", "to"]],
+    ["extract", ["extract", "scrape", "collect", "read", "gather", "copy", "table", "data", "text"]],
+    ["fill", ["fill", "type", "enter", "form", "submit", "login", "sign", "checkout", "field"]],
+    ["monitor", ["watch", "monitor", "observe", "track", "alert", "notify", "poll", "changes"]],
+    ["automate", ["automate", "workflow", "repeat", "every", "schedule", "batch", "pipeline", "steps", "then"]],
+    ["ask", ["what", "who", "when", "where", "why", "how", "explain", "summarize", "ask", "question", "tell"]]
+  ];
+  for (const [intent, list] of keywords) for (const word of list) if (words.includes(word)) scores[intent] += 1;
+  let best = "ask";
+  let bestscore = scores.ask;
+  for (const [intent] of keywords) if (scores[intent] > bestscore) {
+    best = intent;
+    bestscore = scores[intent];
+  }
+  const total = Object.values(scores).reduce((sum, value) => sum + value, 0);
+  const confidence = bestscore === 0 ? 0.1 : Math.min(1, Math.round((bestscore / total * 0.6 + Math.min(bestscore / 3, 1) * 0.4) * 100) / 100);
+  return { intent: best, confidence };
+}
+async function parsecommand(input) {
+  if (input.text.trim() === "") return { reason: "The command parse needs the natural language text." };
+  const guard = input.guard ?? commandguard;
+  const answer = await callmodel({ provider: input.provider, model: input.model, messages: [{ role: "system", content: "Parse the user command into json with the fields intent (one of navigate, extract, fill, monitor, automate, ask), entities (an array of { name, value } objects) and confidence (a number between 0 and 1). Answer with the json object only." }, { role: "user", content: input.text }], ...input.apikey !== void 0 ? { apikey: input.apikey } : {}, transport: input.transport, ...input.sleep !== void 0 ? { sleep: input.sleep } : {}, ...input.now !== void 0 ? { now: input.now } : {} });
+  const output = guardoutput({ guard, attempts: [answer.text] });
+  if (output.verdict !== "valid" || output.parsed === void 0) return { output, reason: output.reason ?? "The command answer failed its guard." };
+  const parsed = output.parsed;
+  if (typeof parsed.intent !== "string") return { output, reason: "The command answer carries no intent." };
+  const intents = ["navigate", "extract", "fill", "monitor", "automate", "ask"];
+  if (!intents.includes(parsed.intent)) return { output, reason: `The intent ${parsed.intent} is not one of the intent kinds.` };
+  const entities = Array.isArray(parsed.entities) ? parsed.entities.filter((entity) => entity !== null && typeof entity === "object" && !Array.isArray(entity) && typeof entity.name === "string" && typeof entity.value === "string") : [];
+  const confidence = typeof parsed.confidence === "number" && Number.isFinite(parsed.confidence) ? Math.min(1, Math.max(0, parsed.confidence)) : 0;
+  return { parse: { text: input.text, intent: parsed.intent, entities, confidence, model: input.model, providerid: input.provider.id, parsedat: (input.now ?? Date.now)() }, output };
+}
+async function draftplan(input) {
+  if (input.goal.trim() === "") return { reason: "The plan draft needs the goal." };
+  const lessons = input.lessons ?? [];
+  const answer = await callmodel({ provider: input.provider, model: input.model, messages: [{ role: "system", content: `Draft a browser agent plan as json with the fields goal (string), steps (an array of { kind, target, value, summary } objects using browser action kinds) and openquestions (an array of strings for what stays unclear).${lessons.length > 0 ? ` The running lessons of the earlier steps: ${lessons.join(" | ")}.` : ""} Answer with the json object only.` }, { role: "user", content: input.goal }], ...input.apikey !== void 0 ? { apikey: input.apikey } : {}, transport: input.transport, ...input.sleep !== void 0 ? { sleep: input.sleep } : {}, ...input.now !== void 0 ? { now: input.now } : {} });
+  const guard = { schema: { goal: { type: "string", required: true }, steps: { type: "array", required: true }, openquestions: { type: "array" } }, retries: 1 };
+  const output = guardoutput({ guard, attempts: [answer.text] });
+  if (output.verdict !== "valid" || output.parsed === void 0) return { output, reason: output.reason ?? "The plan draft answer failed its guard." };
+  const parsed = output.parsed;
+  const rawsteps = Array.isArray(parsed.steps) ? parsed.steps : [];
+  const steps = rawsteps.filter((step) => step !== null && typeof step === "object" && !Array.isArray(step)).map((step, index) => ({ id: `step${index + 1}`, kind: typeof step.kind === "string" ? step.kind : "", ...typeof step.target === "string" && step.target.trim() !== "" ? { target: step.target } : {}, ...typeof step.value === "string" && step.value.trim() !== "" ? { value: step.value } : {}, summary: typeof step.summary === "string" ? step.summary : "" }));
+  const openquestions = Array.isArray(parsed.openquestions) ? parsed.openquestions.filter((question) => typeof question === "string") : [];
+  const draft = { id: randomid(), goal: typeof parsed.goal === "string" && parsed.goal.trim() !== "" ? parsed.goal : input.goal, steps, openquestions, providerid: input.provider.id, model: input.model, state: "draft", lintfindings: [], createdat: (input.now ?? Date.now)() };
+  draft.lintfindings = planlint(draft, input.origin ?? "");
+  return { draft, output };
+}
+async function replannonfail(input) {
+  if (input.reason.trim() === "") return { reason: "The replan needs the failure reason." };
+  const completed = input.draft.steps.filter((step) => input.completedstepids.includes(step.id));
+  const failed = input.draft.steps.filter((step) => input.failedstepids.includes(step.id));
+  const lessons = input.lessons ?? [];
+  const answer = await callmodel({ provider: input.provider, model: input.model, messages: [{ role: "system", content: `The plan ${input.draft.goal} failed at the steps ${failed.map((step) => step.summary).join("; ") || "unknown"} with the reason: ${input.reason}. The completed steps stay: ${completed.map((step) => step.summary).join("; ") || "none"}.${lessons.length > 0 ? ` The running lessons: ${lessons.join(" | ")}.` : ""} Draft the revised tail steps of the plan as json with the field steps (an array of { kind, target, value, summary } objects using browser action kinds). Answer with the json object only.` }, { role: "user", content: input.draft.goal }], ...input.apikey !== void 0 ? { apikey: input.apikey } : {}, transport: input.transport, ...input.sleep !== void 0 ? { sleep: input.sleep } : {}, ...input.now !== void 0 ? { now: input.now } : {} });
+  const guard = { schema: { steps: { type: "array", required: true } }, retries: 1 };
+  const output = guardoutput({ guard, attempts: [answer.text] });
+  if (output.verdict !== "valid" || output.parsed === void 0) return { output, reason: output.reason ?? "The replan answer failed its guard." };
+  const rawsteps = Array.isArray(output.parsed.steps) ? output.parsed.steps : [];
+  const tail = rawsteps.filter((step) => step !== null && typeof step === "object" && !Array.isArray(step)).map((step, index) => ({ id: `tail${index + 1}`, kind: typeof step.kind === "string" ? step.kind : "", ...typeof step.target === "string" && step.target.trim() !== "" ? { target: step.target } : {}, ...typeof step.value === "string" && step.value.trim() !== "" ? { value: step.value } : {}, summary: typeof step.summary === "string" ? step.summary : "", freshreview: true }));
+  const replan = { id: randomid(), draftid: input.draft.id, completedstepids: [...input.completedstepids], failedstepids: [...input.failedstepids], tail, reason: input.reason, providerid: input.provider.id, model: input.model, state: "pending", createdat: (input.now ?? Date.now)() };
+  return { replan, output };
+}
+async function reflectstep(input) {
+  if (input.outcome.trim() === "") return { reason: "The reflection needs the step outcome." };
+  const lessons = input.lessons ?? [];
+  const answer = await callmodel({ provider: input.provider, model: input.model, messages: [{ role: "system", content: `Reflect on the executed step ${input.stepid} of the run ${input.runid} with the outcome: ${input.outcome}.${lessons.length > 0 ? ` The running lessons of the earlier steps: ${lessons.join(" | ")}.` : ""} Answer as json with the fields outcome (string), lesson (string) and advice (string) for the next step. Answer with the json object only.` }, { role: "user", content: input.outcome }], ...input.apikey !== void 0 ? { apikey: input.apikey } : {}, transport: input.transport, ...input.sleep !== void 0 ? { sleep: input.sleep } : {}, ...input.now !== void 0 ? { now: input.now } : {} });
+  const guard = { schema: { outcome: { type: "string", required: true }, lesson: { type: "string", required: true }, advice: { type: "string", required: true } }, retries: 1 };
+  const output = guardoutput({ guard, attempts: [answer.text] });
+  if (output.verdict !== "valid" || output.parsed === void 0) return { output, reason: output.reason ?? "The reflection answer failed its guard." };
+  const parsed = output.parsed;
+  if (typeof parsed.lesson !== "string" || typeof parsed.advice !== "string") return { output, reason: "The reflection answer carries no lesson or advice." };
+  const note = { id: randomid(), runid: input.runid, stepid: input.stepid, outcome: typeof parsed.outcome === "string" ? parsed.outcome : input.outcome, lesson: parsed.lesson, advice: parsed.advice, providerid: input.provider.id, model: input.model, createdat: (input.now ?? Date.now)() };
+  return { note, output };
+}
+function reflectionsummary(notes) {
+  const latest = /* @__PURE__ */ new Map();
+  for (const note of notes) latest.set(note.stepid, note);
+  const lessons = [...latest.values()].sort((one, two) => one.createdat - two.createdat).map((note) => note.lesson);
+  return lessons.length === 0 ? "" : lessons.join(" | ");
+}
+function stripguardrails(text2) {
+  const fenced = text2.match(/```(?:[a-z]*)\s*\r?\n?([\s\S]*?)```/i);
+  const candidate = fenced !== null ? fenced[1] ?? "" : text2;
+  const start = candidate.indexOf("{");
+  const end = candidate.lastIndexOf("}");
+  if (start >= 0 && end > start) return candidate.slice(start, end + 1);
+  const arraystart = candidate.indexOf("[");
+  const arrayend = candidate.lastIndexOf("]");
+  if (arraystart >= 0 && arrayend > arraystart) return candidate.slice(arraystart, arrayend + 1);
+  return candidate.trim();
+}
+function parseoutput(input) {
+  const raw = input.text;
+  const stripped = stripguardrails(raw);
+  const markers = input.guard.refusalmarkers ?? defaultrefusalmarkers;
+  const lowered = stripped.toLowerCase();
+  for (const marker of markers) if (marker.trim() !== "" && lowered.includes(marker.toLowerCase())) return { raw, verdict: "refused", reason: `The model answer carries the refusal marker ${marker}.`, attempts: 1 };
+  let parsed;
+  try {
+    parsed = JSON.parse(stripped);
+  } catch {
+    return { raw, verdict: "invalid", reason: "The model answer is not json after the guardrail strip.", attempts: 1 };
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return { raw, verdict: "invalid", reason: "The model answer is not a json object.", attempts: 1 };
+  const record2 = parsed;
+  for (const [name, field] of Object.entries(input.guard.schema)) {
+    const value = record2[name];
+    if (value === void 0 || value === null) {
+      if (field.required === true) return { raw, verdict: "invalid", reason: `The required field ${name} of the expected schema is missing.`, attempts: 1 };
+      continue;
+    }
+    const actual = Array.isArray(value) ? "array" : typeof value;
+    if (actual !== field.type) return { raw, verdict: "invalid", reason: `The field ${name} carries a ${actual} value where the schema asks a ${field.type}.`, attempts: 1 };
+  }
+  return { raw, parsed: record2, verdict: "valid", attempts: 1 };
+}
+function guardoutput(input) {
+  const limit = Math.max(1, Math.floor(input.guard.retries) + 1);
+  const attempts = input.attempts.slice(0, limit);
+  let last;
+  for (let index = 0; index < attempts.length; index += 1) {
+    const output = parseoutput({ guard: input.guard, text: attempts[index] ?? "" });
+    last = { ...output, attempts: index + 1 };
+    if (output.verdict === "valid") return last;
+    if (output.verdict === "refused") return { ...output, attempts: index + 1 };
+  }
+  const exhausted = last === void 0 ? { raw: "", verdict: "invalid", reason: "The model answer never arrived.", attempts: 0 } : { ...last, verdict: "invalid", reason: `${last.reason ?? "The model answer failed its guard."} Every retry attempt failed, so the guard refuses the output and nothing executes.` };
+  return exhausted;
+}
+function toolbriefof(tool) {
+  return { tool: tool.name, summary: `${tool.name}: ${tool.description.split(".")[0] ?? tool.description}.`, description: tool.description, risk: tool.risk, parameters: Object.entries(tool.inputschema.properties).map(([name, property]) => ({ name, type: property.type, description: property.description, required: property.required === true })) };
+}
+function rendertoolbriefs(tools) {
+  const blocks = tools.map((tool) => {
+    const brief = toolbriefof(tool);
+    const parameters = brief.parameters.map((parameter) => `    - name: ${parameter.name}
+      type: ${parameter.type}
+      required: ${parameter.required ? "true" : "false"}
+      description: ${parameter.description}`).join("\n");
+    return `  - tool: ${brief.tool}
+    summary: ${brief.summary}
+    risk: ${brief.risk}
+    parameters:
+${parameters}`;
+  });
+  return `tools:
+${blocks.join("\n")}
+consent: every tool with side effects executes only the approved plan step it names; a proposal without the approved step stays refused.`;
+}
+function usagetotals(records, filter = {}) {
+  const kept = records.filter((record2) => (filter.runid === void 0 || record2.runid === filter.runid) && (filter.stepid === void 0 || record2.stepid === filter.stepid) && (filter.since === void 0 || record2.at >= filter.since) && (filter.until === void 0 || record2.at <= filter.until));
+  return kept.reduce((totals, record2) => ({ prompttokens: totals.prompttokens + record2.prompttokens, completiontokens: totals.completiontokens + record2.completiontokens, totaltokens: totals.totaltokens + record2.totaltokens, cost: totals.cost + record2.cost, calls: totals.calls + 1 }), { prompttokens: 0, completiontokens: 0, totaltokens: 0, cost: 0, calls: 0 });
+}
+function budgetcheck(input) {
+  if (input.budget === void 0) return { allowed: true, halted: false, asksuser: false };
+  if (input.budget.maxtokens !== void 0 && Number.isFinite(input.budget.maxtokens) && input.totals.totaltokens >= input.budget.maxtokens) return { allowed: false, halted: true, asksuser: true, reason: `The run reached the user configured token ceiling of ${input.budget.maxtokens} and halts until the user answers.` };
+  if (input.budget.maxcost !== void 0 && Number.isFinite(input.budget.maxcost) && input.totals.cost >= input.budget.maxcost) return { allowed: false, halted: true, asksuser: true, reason: `The run reached the user configured cost ceiling of ${input.budget.maxcost} and halts until the user answers.` };
+  return { allowed: true, halted: false, asksuser: false };
+}
+
+// modelroute.ts
+function routevalid(route) {
+  if (route.kind.trim() === "") return { allowed: false, reason: "The model route needs its task kind." };
+  if (route.providerid.trim() === "") return { allowed: false, reason: "The model route needs the provider it routes to." };
+  if (route.model.trim() === "") return { allowed: false, reason: "The model route needs the model name it routes to." };
+  const hasfallbackprovider = route.fallbackproviderid !== void 0 && route.fallbackproviderid.trim() !== "";
+  const hasfallbackmodel = route.fallbackmodel !== void 0 && route.fallbackmodel.trim() !== "";
+  if (hasfallbackprovider !== hasfallbackmodel) return { allowed: false, reason: "The fallback of a model route needs its provider and its model together." };
+  return { allowed: true };
+}
+function routesfor(routes, kind) {
+  return routes.filter((route) => route.kind === kind).sort((one, two) => two.revision - one.revision);
+}
+function resolveroute(input) {
+  const candidates = routesfor(input.routes, input.kind);
+  if (candidates.length === 0) return { reason: `No model route configures the task kind ${input.kind}; the user picks the provider and model pair.` };
+  for (const route of candidates) {
+    if (!routevalid(route).allowed) continue;
+    const provider = input.providers.find((candidate) => candidate.id === route.providerid);
+    if (provider === void 0) return { reason: `The route of ${input.kind} names the missing provider ${route.providerid}.` };
+    if (provider.status === "unavailable") return { reason: `The provider ${provider.name} of the route of ${input.kind} stays marked unavailable from its last failure.` };
+    if (!provider.models.includes(route.model)) return { reason: `The route of ${input.kind} names the model ${route.model} outside the model list of ${provider.name}.` };
+    return { route, provider, model: route.model };
+  }
+  return { reason: `Every route of the task kind ${input.kind} failed its validation.` };
+}
+function markprovider(input) {
+  return input.providers.map((provider) => provider.id === input.providerid ? { ...provider, status: input.available ? "available" : "unavailable", lastcheckedat: input.now } : provider);
+}
+function fallbackroute(input) {
+  const candidates = routesfor(input.routes, input.kind);
+  const primary = candidates.find((route) => routevalid(route).allowed);
+  if (primary === void 0) return { reason: `No valid route configures the task kind ${input.kind}, so no fallback applies.` };
+  if (primary.fallbackproviderid === void 0 || primary.fallbackmodel === void 0) return { reason: `The route of ${input.kind} carries no user configured fallback pair.` };
+  const provider = input.providers.find((candidate) => candidate.id === primary.fallbackproviderid);
+  if (provider === void 0) return { reason: `The fallback names the missing provider ${primary.fallbackproviderid}.` };
+  if (provider.status === "unavailable") return { reason: `The fallback provider ${provider.name} stays marked unavailable from its last failure.` };
+  if (!provider.models.includes(primary.fallbackmodel)) return { reason: `The fallback names the model ${primary.fallbackmodel} outside the model list of ${provider.name}.` };
+  return { route: primary, provider, model: primary.fallbackmodel };
+}
+
+// promptlibrary.ts
+function templatevariables(body) {
+  const names = [];
+  for (const match of body.matchAll(/\{\{\s*([a-z0-9]+)\s*\}\}/g)) {
+    const name = match[1] ?? "";
+    if (name !== "" && !names.includes(name)) names.push(name);
+  }
+  return names;
+}
+function savetemplate(input) {
+  const existing = input.templates.filter((template) => template.name === input.name);
+  const version = existing.length === 0 ? 1 : Math.max(...existing.map((template) => template.version)) + 1;
+  const record2 = { id: randomid(), name: input.name, body: input.body, variables: templatevariables(input.body), version, ...input.notes !== void 0 && input.notes.trim() !== "" ? { notes: input.notes } : {}, createdat: input.now };
+  return [record2, ...input.templates];
+}
+function latesttemplate(templates, name) {
+  const versions = templates.filter((template) => template.name === name);
+  return versions.length === 0 ? void 0 : versions.reduce((newest, template) => template.version > newest.version ? template : newest);
+}
+function searchtemplates(templates, query) {
+  const term = query.trim().toLowerCase();
+  const matches = term === "" ? templates : templates.filter((template) => template.name.toLowerCase().includes(term) || template.body.toLowerCase().includes(term) || (template.notes ?? "").toLowerCase().includes(term) || template.variables.some((variable) => variable.toLowerCase().includes(term)));
+  return [...matches].sort((one, two) => two.version - one.version || two.createdat - one.createdat);
+}
+function removetemplate(templates, name) {
+  return templates.filter((template) => template.name !== name);
+}
+
 // extension/pagesession.ts
 function capturepagestate(sections) {
   const wants = (section) => sections.includes(section);
@@ -15378,8 +15912,8 @@ async function executecdpstep(step, session, plan, tabid2, origin) {
     const input = breakpointinputof(options.breakpoint);
     if (!input) throw new Error("The breakpoint input is absent.");
     const settings = await memory.getsettings();
-    const budgetcheck = breakpointbudgetallowed(active.breakpoints.filter((spec) => spec.revertedat === void 0).length, breakpointceilingof(settings));
-    if (!budgetcheck.allowed) throw new Error(budgetcheck.reason ?? "The breakpoint ceiling refused the registration.");
+    const budgetcheck2 = breakpointbudgetallowed(active.breakpoints.filter((spec) => spec.revertedat === void 0).length, breakpointceilingof(settings));
+    if (!budgetcheck2.allowed) throw new Error(budgetcheck2.reason ?? "The breakpoint ceiling refused the registration.");
     const output = await dispatchpagestep(step, tabid2, origin, plan) ?? { ok: false, summary: "The breakpoint registration returned no result." };
     if (!output.ok) return output;
     const registered = output.details?.breakpoint;
@@ -16021,8 +16555,8 @@ async function executenetcontrolstep(step, session, plan, tabid2, origin) {
     const limits = await memory.getratelimits(Date.now());
     const limit = limits.find((item) => item.origin === new URL(url).origin);
     const wait = ratelimitwait(limit, Date.now());
-    const budgetcheck = ratelimitbudgetallowed(wait, budget);
-    if (!budgetcheck.allowed) throw new Error(budgetcheck.reason ?? "The rate limit wait exceeds the reviewed budget.");
+    const budgetcheck2 = ratelimitbudgetallowed(wait, budget);
+    if (!budgetcheck2.allowed) throw new Error(budgetcheck2.reason ?? "The rate limit wait exceeds the reviewed budget.");
     if (wait > 0) {
       await audit("control", `The rate limiter waits ${wait} milliseconds until the reset window of ${new URL(url).origin} passes before the submission.`, extra);
       await new Promise((resolve) => setTimeout(resolve, wait));
@@ -17276,7 +17810,7 @@ async function handlerequest(message, sender) {
       const livetab = session ? await chrome.tabs.get(session.tabid).catch(() => void 0) : void 0;
       const waitprofile = session ? waitprofiles.find((record2) => record2.origin === session.origin) : void 0;
       const livestate = { phase: livetab?.status === "loading" ? "loading" : "complete", ...navrecords[0] ? { finalurl: navrecords[0].finalurl, redirects: navrecords[0].chain } : {} };
-      return { config: await memory.getconfig(), session, plan, progress: plan && progress?.planid === plan.id ? progress : void 0, diagnostic: await memory.getdiagnostic(), audit: await memory.getaudit(), capabilities: await refreshcapabilities(), outcomes: await memory.getoutcomes(), holds: heldkeysreport({ tabid: session?.tabid ?? 0, holds }), dialogs: await memory.getdialogs(), retries: await memory.getretries(), ...signals ? { signals: signalsreport({ signals }) } : { signals: signalsreport({}) }, banners: await memory.getbanners(), mutationevents: await memory.getmutationevents(), focusevents: await memory.getfocusevents(), diffs: await memory.getdiffs(), selectors: await memory.getselectors(), ...a11y ? { a11y } : {}, ...reader ? { reader } : {}, ...map ? { map } : {}, trail: trailreport({ ...session ? { sessionid: session.id } : {}, trail }), navrecords, ratestates, safeties, curated, waitprofiles, auths, navcontrol, navqueues, artifacts, navstate: livestate, ...waitprofile ? { waitprofile } : {}, offline: !navigator.onLine, tabs, windows, layouts: layoutreport({ layouts }), tabgroups, tabmetas, badges, snapshots, closedtabs, tabwatchevents, clones, tasktabgauge: taskgauge, ...controltab ? { controltab } : {}, tabreport: report, profiles, tickets, wizards: wizardreport({ ...session ? { sessionid: session.id } : {}, wizards, picks }), picks, errorreports, captchas, detections, ...codeentry !== void 0 ? { codeentry: true } : {}, datasets, imports, extractsessions, streams, exports, provenances, taskrules, sheetendpoints: sheetgrants, downloads, netlogs, clipconsents, clips, quarantines, cleanuprules, cleanupruns, capturecounters, inventory, mimefilters, scanhooks, captures: capturemetadata, capturepairs, capturepolicy: runsettings?.capturepolicy ?? "manual", media: mediarecords, imagebatches, recordingconsents, recordingactive: [...activerecordings.values()].map((active) => ({ id: active.record.id, kind: active.record.kind, scope: active.record.scope, startedat: active.record.startedat, stopat: active.stopat })), recordingwindow: runsettings?.recordingwindow, calls, endpoints, fetchconsents, apikeys, callretention: runsettings?.callretention, fetchesactive: activefetches.size, exchanges, channels, subscriptions, apimap, messages: messagecount, webrequestgrant: runsettings?.webrequestgrant === true, bodyretention: runsettings?.bodyretention, timelineretention: runsettings?.timelineretention, timeline, consoleconsents: await memory.getconsoleconsents(), rotationtargets: await memory.getrotationtargets(), levelsummaries: await memory.getlevelsummaries(), cdpsessions: await memory.getcdpsessions(), cdpcommands: await memory.getcdpcommands(), cdpeventrules: await memory.getcdpeventrules(), breakpoints: await memory.getbreakpoints(), pauses: await memory.getpauses(), watchexpressions: await memory.getwatchexpressions(), scriptoverrides: await memory.getscriptoverrides(), debuggergrants: await memory.getdebuggergrants(), pauseretention: runsettings?.pauseretention, breakpointceiling: runsettings?.breakpointceiling, cdpattached: [...activecdpsessions.values()].filter((active) => active.session.detachedat === void 0).length, profileretention: runsettings?.profileretention, traceceiling: runsettings?.traceceiling, profile: profilereport({ flows: await memory.getflowmetrics(), heaps: await memory.getheaprecords(), samples: await memory.getgrowsamples(), trends: await memory.gettrends(), profiles: await memory.getcpuprofiles(), shifts: await memory.getshiftentries(), traces: await memory.gettracerecords(), sourcemaps: await memory.getsourcemaps(), consents: await memory.getsourcemapconsents() }), profileactive: activememorytrackers.size + activeprofiletargets.size, profiletargets: [...activeprofiletargets.values()].flatMap((entry) => entry.targets), socketsactive: activesockets.size, emulation: emulationreport({ ...plan && await loademulationstate(plan.id) !== void 0 ? { state: await loademulationstate(plan.id) } : {}, devices: await memory.getdevicepresets(), networks: await memory.getnetworkpresets(), locations: await memory.getlocationpresets(), agents: await memory.getagentpresets(), blackbox: await memory.getblackboxrules(), permissions: await memory.getpermissionoverrides(), consents: await memory.getlocationconsents() }), emulatedlayers: plan ? layernames(await loademulationstate(plan.id)) : [], emulationretention: runsettings?.emulationretention, traffic, tokens, authflows, activerules: [...activerules.values()].reduce((total, ruleset) => total + ruleset.blocks.filter((rule) => rule.revertedat === void 0).length + ruleset.mocks.filter((rule) => rule.revertedat === void 0).length + ruleset.rewrites.filter((rule) => rule.revertedat === void 0).length + (ruleset.proxy !== void 0 && ruleset.proxy.revertedat === void 0 ? 1 : 0), 0), sessionmemory: sessionreport({ records: sessionrecords, events: await memory.getsessionevents(), folders: await memory.getsessionfolders(), diffs: await memory.getsessiondiffs(), ...autosnapshot !== void 0 ? { auto: autosnapshot.interval } : {}, ...crashed ? { crashed: true } : {} }), autosnapshotstate: autosnapshot, sessionretention: runsettings?.sessionretention, trigger: triggerlist({ rules: await memory.gettriggerules(), workflows: await memory.listworkflows(), queue: await memory.gettriggerqueue() }), triggerretention: runsettings?.triggerretention, workflow: workflowreport({ workflows: await memory.listworkflows(), runs: await memory.listworkflowruns(), templates: await memory.getsteptemplates(), ...newestworkflowrun !== void 0 ? { log: await memory.getrunlog(newestworkflowrun.id), scopes: await memory.getrunscopes(newestworkflowrun.id), provenance: await memory.getworkflowprovenance(newestworkflowrun.id), control: await memory.listcontroldecisions(newestworkflowrun.id) } : {} }), runlogretention: runsettings?.runlogretention, runhistoryretention: runsettings?.runhistoryretention, editor: editorstate({ versions: await memory.listworkflowversions(), diffs: await memory.listversiondiffs(), history: await memory.gethistory(), overrides: await memory.listsiteoverrides(), imports: (await memory.listworkflowimports()).map((entry) => ({ id: entry.id, workflowid: entry.record.id, name: entry.record.name, version: entry.record.version, steps: entry.record.steps.length, risk: entry.record.risk, importedat: entry.importedat, ...entry.filename !== void 0 ? { filename: entry.filename } : {} })), backgroundruns: await memory.getbackgroundruns(), watchdog: { ...runsettings?.watchdog !== void 0 ? { config: runsettings.watchdog } : {}, events: await memory.listwatchdogevents() } }), ...taskstate !== void 0 ? { taskstate } : {}, ...stitchprogress.size > 0 ? { stitchprogress: [...stitchprogress.values()] } : {}, mcp: await mcpstateof() };
+      return { config: await memory.getconfig(), session, plan, progress: plan && progress?.planid === plan.id ? progress : void 0, diagnostic: await memory.getdiagnostic(), audit: await memory.getaudit(), capabilities: await refreshcapabilities(), outcomes: await memory.getoutcomes(), holds: heldkeysreport({ tabid: session?.tabid ?? 0, holds }), dialogs: await memory.getdialogs(), retries: await memory.getretries(), ...signals ? { signals: signalsreport({ signals }) } : { signals: signalsreport({}) }, banners: await memory.getbanners(), mutationevents: await memory.getmutationevents(), focusevents: await memory.getfocusevents(), diffs: await memory.getdiffs(), selectors: await memory.getselectors(), ...a11y ? { a11y } : {}, ...reader ? { reader } : {}, ...map ? { map } : {}, trail: trailreport({ ...session ? { sessionid: session.id } : {}, trail }), navrecords, ratestates, safeties, curated, waitprofiles, auths, navcontrol, navqueues, artifacts, navstate: livestate, ...waitprofile ? { waitprofile } : {}, offline: !navigator.onLine, tabs, windows, layouts: layoutreport({ layouts }), tabgroups, tabmetas, badges, snapshots, closedtabs, tabwatchevents, clones, tasktabgauge: taskgauge, ...controltab ? { controltab } : {}, tabreport: report, profiles, tickets, wizards: wizardreport({ ...session ? { sessionid: session.id } : {}, wizards, picks }), picks, errorreports, captchas, detections, ...codeentry !== void 0 ? { codeentry: true } : {}, datasets, imports, extractsessions, streams, exports, provenances, taskrules, sheetendpoints: sheetgrants, downloads, netlogs, clipconsents, clips, quarantines, cleanuprules, cleanupruns, capturecounters, inventory, mimefilters, scanhooks, captures: capturemetadata, capturepairs, capturepolicy: runsettings?.capturepolicy ?? "manual", media: mediarecords, imagebatches, recordingconsents, recordingactive: [...activerecordings.values()].map((active) => ({ id: active.record.id, kind: active.record.kind, scope: active.record.scope, startedat: active.record.startedat, stopat: active.stopat })), recordingwindow: runsettings?.recordingwindow, calls, endpoints, fetchconsents, apikeys, callretention: runsettings?.callretention, fetchesactive: activefetches.size, exchanges, channels, subscriptions, apimap, messages: messagecount, webrequestgrant: runsettings?.webrequestgrant === true, bodyretention: runsettings?.bodyretention, timelineretention: runsettings?.timelineretention, timeline, consoleconsents: await memory.getconsoleconsents(), rotationtargets: await memory.getrotationtargets(), levelsummaries: await memory.getlevelsummaries(), cdpsessions: await memory.getcdpsessions(), cdpcommands: await memory.getcdpcommands(), cdpeventrules: await memory.getcdpeventrules(), breakpoints: await memory.getbreakpoints(), pauses: await memory.getpauses(), watchexpressions: await memory.getwatchexpressions(), scriptoverrides: await memory.getscriptoverrides(), debuggergrants: await memory.getdebuggergrants(), pauseretention: runsettings?.pauseretention, breakpointceiling: runsettings?.breakpointceiling, cdpattached: [...activecdpsessions.values()].filter((active) => active.session.detachedat === void 0).length, profileretention: runsettings?.profileretention, traceceiling: runsettings?.traceceiling, profile: profilereport({ flows: await memory.getflowmetrics(), heaps: await memory.getheaprecords(), samples: await memory.getgrowsamples(), trends: await memory.gettrends(), profiles: await memory.getcpuprofiles(), shifts: await memory.getshiftentries(), traces: await memory.gettracerecords(), sourcemaps: await memory.getsourcemaps(), consents: await memory.getsourcemapconsents() }), profileactive: activememorytrackers.size + activeprofiletargets.size, profiletargets: [...activeprofiletargets.values()].flatMap((entry) => entry.targets), socketsactive: activesockets.size, emulation: emulationreport({ ...plan && await loademulationstate(plan.id) !== void 0 ? { state: await loademulationstate(plan.id) } : {}, devices: await memory.getdevicepresets(), networks: await memory.getnetworkpresets(), locations: await memory.getlocationpresets(), agents: await memory.getagentpresets(), blackbox: await memory.getblackboxrules(), permissions: await memory.getpermissionoverrides(), consents: await memory.getlocationconsents() }), emulatedlayers: plan ? layernames(await loademulationstate(plan.id)) : [], emulationretention: runsettings?.emulationretention, traffic, tokens, authflows, activerules: [...activerules.values()].reduce((total, ruleset) => total + ruleset.blocks.filter((rule) => rule.revertedat === void 0).length + ruleset.mocks.filter((rule) => rule.revertedat === void 0).length + ruleset.rewrites.filter((rule) => rule.revertedat === void 0).length + (ruleset.proxy !== void 0 && ruleset.proxy.revertedat === void 0 ? 1 : 0), 0), sessionmemory: sessionreport({ records: sessionrecords, events: await memory.getsessionevents(), folders: await memory.getsessionfolders(), diffs: await memory.getsessiondiffs(), ...autosnapshot !== void 0 ? { auto: autosnapshot.interval } : {}, ...crashed ? { crashed: true } : {} }), autosnapshotstate: autosnapshot, sessionretention: runsettings?.sessionretention, trigger: triggerlist({ rules: await memory.gettriggerules(), workflows: await memory.listworkflows(), queue: await memory.gettriggerqueue() }), triggerretention: runsettings?.triggerretention, workflow: workflowreport({ workflows: await memory.listworkflows(), runs: await memory.listworkflowruns(), templates: await memory.getsteptemplates(), ...newestworkflowrun !== void 0 ? { log: await memory.getrunlog(newestworkflowrun.id), scopes: await memory.getrunscopes(newestworkflowrun.id), provenance: await memory.getworkflowprovenance(newestworkflowrun.id), control: await memory.listcontroldecisions(newestworkflowrun.id) } : {} }), runlogretention: runsettings?.runlogretention, runhistoryretention: runsettings?.runhistoryretention, editor: editorstate({ versions: await memory.listworkflowversions(), diffs: await memory.listversiondiffs(), history: await memory.gethistory(), overrides: await memory.listsiteoverrides(), imports: (await memory.listworkflowimports()).map((entry) => ({ id: entry.id, workflowid: entry.record.id, name: entry.record.name, version: entry.record.version, steps: entry.record.steps.length, risk: entry.record.risk, importedat: entry.importedat, ...entry.filename !== void 0 ? { filename: entry.filename } : {} })), backgroundruns: await memory.getbackgroundruns(), watchdog: { ...runsettings?.watchdog !== void 0 ? { config: runsettings.watchdog } : {}, events: await memory.listwatchdogevents() } }), ...taskstate !== void 0 ? { taskstate } : {}, ...stitchprogress.size > 0 ? { stitchprogress: [...stitchprogress.values()] } : {}, mcp: await mcpstateof(), llm: await llmstateof() };
     }
     case "capabilities":
       return refreshcapabilities();
@@ -19420,6 +19954,298 @@ async function handlerequest(message, sender) {
       await audit("workflow", `The user removed the per site override ${removed.pattern} of the workflow ${removed.workflowid}.`, {});
       return { removed: removed.id };
     }
+    case "llmstate": {
+      return llmstateof();
+    }
+    case "llmproviders": {
+      const inputprovider = message;
+      const id = inputprovider.id?.trim() ?? "";
+      const providers = await memory.getproviders();
+      if (inputprovider.remove === true) {
+        if (id === "") throw new Error("The provider removal needs the provider id.");
+        await memory.setproviders(providers.filter((candidate) => candidate.id !== id));
+        await audit("model", `The user removed the provider config ${id}; the stored key reference and its secret stay untouched in the credential store.`, {});
+        return llmstateof();
+      }
+      const authrefname = inputprovider.authrefname?.trim() ?? "";
+      const ref = authrefname !== "" ? (await memory.getapikeys()).find((entry) => entry.name === authrefname) : void 0;
+      if (authrefname !== "" && ref === void 0) throw new Error(`No stored api key reference matches ${authrefname}; set the key from the review panel first.`);
+      const style = inputprovider.style === "chatcompletions" || inputprovider.style === "responses" || inputprovider.style === "messages" || inputprovider.style === "gemini" ? inputprovider.style : void 0;
+      const models = Array.isArray(inputprovider.models) ? inputprovider.models.map((model) => String(model).trim()).filter((model) => model !== "") : [];
+      const storedprovider = providers.find((candidate) => candidate.id === id);
+      const config = {
+        id: id !== "" ? id : randomid(),
+        name: inputprovider.name?.trim() ?? "",
+        endpoint: inputprovider.endpoint?.trim() ?? "",
+        ...style !== void 0 ? { style } : { style: "chatcompletions" },
+        models,
+        ...inputprovider.headers !== void 0 ? { headers: inputprovider.headers } : {},
+        ...ref !== void 0 ? { authref: { name: ref.name, origins: ref.origins, header: ref.header, storageid: ref.storageid, configuredat: ref.createdat } } : {},
+        ...inputprovider.costpermilliontokens !== void 0 && Number.isFinite(inputprovider.costpermilliontokens) ? { costpermilliontokens: inputprovider.costpermilliontokens } : {},
+        ...inputprovider.currency !== void 0 && inputprovider.currency.trim() !== "" ? { currency: inputprovider.currency.trim() } : {},
+        status: storedprovider?.status ?? "available",
+        ...storedprovider?.lastcheckedat !== void 0 ? { lastcheckedat: storedprovider.lastcheckedat } : {},
+        createdat: storedprovider?.createdat ?? Date.now()
+      };
+      const gate = providervalid(config);
+      if (!gate.allowed) throw new Error(gate.reason ?? "The provider config failed its validation.");
+      await memory.setproviders([config, ...providers.filter((candidate) => candidate.id !== config.id)]);
+      await audit("model", `The user saved the provider config ${config.name} for the ${config.endpoint} endpoint with the ${config.style} protocol shape, ${config.models.length} model${config.models.length === 1 ? "" : "s"}${config.authref !== void 0 ? ` and the stored key reference ${config.authref.name} (the key material never enters the config)` : " and no key reference"}; every value stays the user choice.`, {});
+      return llmstateof();
+    }
+    case "llmtestprovider": {
+      const inputtest = message;
+      const id = inputtest.id?.trim() ?? "";
+      const provider = (await memory.getproviders()).find((candidate) => candidate.id === id);
+      if (!provider) throw new Error(`No provider config matches ${id}.`);
+      const now = Date.now();
+      const providers = await memory.getproviders();
+      try {
+        const key = await providerkey(provider);
+        const outcome = await callmodel({ provider, model: provider.models[0] ?? "", messages: [{ role: "user", content: "Answer with the single word ready." }], ...key !== void 0 ? { apikey: key } : {}, transport: llmtransport });
+        await memory.setproviders(markprovider({ providers, providerid: provider.id, available: true, now }));
+        await audit("model", `The test call of the provider ${provider.name} reached the ${provider.endpoint} endpoint with the ${provider.models[0] ?? ""} model and answered ${outcome.text.length} characters; the provider stays available.`, {});
+      } catch (error) {
+        await memory.setproviders(markprovider({ providers, providerid: provider.id, available: false, now }));
+        await audit("model", `The test call of the provider ${provider.name} failed: ${error instanceof Error ? error.message : String(error)} The provider stays marked unavailable until its next success.`, {});
+        throw error;
+      }
+      return llmstateof();
+    }
+    case "llmlocal": {
+      const inputlocal = message;
+      const stored = await memory.getlocalmodel();
+      if (inputlocal.check === true) {
+        const local = stored ?? { endpoint: "", model: "", style: "chatcompletions" };
+        if (local.endpoint.trim() === "") throw new Error("The local model needs the user configured endpoint url before the health check runs.");
+        const now = Date.now();
+        try {
+          const key = local.authref !== void 0 ? await memory.getsecret(local.authref.storageid) : void 0;
+          const outcome = await calllocal({ local, messages: [{ role: "user", content: "Answer with the single word ready." }], ...key !== void 0 ? { apikey: key } : {}, transport: llmtransport });
+          await memory.setlocalmodel({ ...local, health: { checkedat: now, ok: true, ...outcome.text !== "" ? { detail: `The endpoint answered ${outcome.text.length} characters.` } : {} } });
+          await memory.addusagerecord({ id: randomid(), providerid: "local", endpoint: local.endpoint, model: local.model, prompttokens: outcome.usage?.prompttokens ?? 0, completiontokens: outcome.usage?.completiontokens ?? 0, totaltokens: outcome.usage?.totaltokens ?? 0, cost: 0, local: true, at: now });
+          await audit("model", `The local model health check reached the ${local.endpoint} endpoint with the ${local.model} model and the endpoint stays healthy; the call never left the machine.`, {});
+        } catch (error) {
+          await memory.setlocalmodel({ ...local, health: { checkedat: now, ok: false, detail: error instanceof Error ? error.message : String(error) } });
+          await audit("model", `The local model health check failed on the ${local.endpoint} endpoint: ${error instanceof Error ? error.message : String(error)}`, {});
+        }
+        return llmstateof();
+      }
+      const authrefname = inputlocal.authrefname?.trim() ?? "";
+      const ref = authrefname !== "" ? (await memory.getapikeys()).find((entry) => entry.name === authrefname) : void 0;
+      if (authrefname !== "" && ref === void 0) throw new Error(`No stored api key reference matches ${authrefname}; set the key from the review panel first.`);
+      const style = inputlocal.style === "chatcompletions" || inputlocal.style === "responses" || inputlocal.style === "messages" || inputlocal.style === "gemini" ? inputlocal.style : stored?.style ?? "chatcompletions";
+      const config = { endpoint: inputlocal.endpoint?.trim() ?? stored?.endpoint ?? "", model: inputlocal.model?.trim() ?? stored?.model ?? "", style, ...ref !== void 0 ? { authref: { name: ref.name, origins: ref.origins, header: ref.header, storageid: ref.storageid, configuredat: ref.createdat } } : {}, ...stored?.health !== void 0 ? { health: stored.health } : {} };
+      if (config.endpoint.trim() === "") throw new Error("The local model needs the user configured endpoint url.");
+      if (config.model.trim() === "") throw new Error("The local model needs the user configured model name.");
+      if (!islocalorigin(config.endpoint)) throw new Error("The local model endpoint must stay a local machine address so no call leaves the machine.");
+      await memory.setlocalmodel(config);
+      await audit("model", `The user saved the local model endpoint ${config.endpoint} with the ${config.model} model and the ${config.style} protocol shape${config.authref !== void 0 ? ` and the stored key reference ${config.authref.name}` : " and no key reference"}.`, {});
+      return llmstateof();
+    }
+    case "llmroutes": {
+      const inputroute = message;
+      const kind = inputroute.taskkind?.trim() ?? "";
+      if (kind === "") throw new Error("The model route needs its task kind.");
+      const routes = await memory.getmodelroutes();
+      if (inputroute.remove === true) {
+        await memory.setmodelroutes(routes.filter((candidate) => !(candidate.kind === kind)));
+        await audit("model", `The user removed every route of the task kind ${kind}; the routing table holds no default route.`, {});
+        return llmstateof();
+      }
+      const existing = routes.find((candidate) => candidate.kind === kind);
+      const now = Date.now();
+      const route = { id: existing?.id ?? randomid(), kind, providerid: inputroute.providerid?.trim() ?? "", model: inputroute.model?.trim() ?? "", ...inputroute.fallbackproviderid !== void 0 && inputroute.fallbackproviderid.trim() !== "" ? { fallbackproviderid: inputroute.fallbackproviderid.trim() } : {}, ...inputroute.fallbackmodel !== void 0 && inputroute.fallbackmodel.trim() !== "" ? { fallbackmodel: inputroute.fallbackmodel.trim() } : {}, revision: (existing?.revision ?? 0) + 1, updatedat: now };
+      const gate = routevalid(route);
+      if (!gate.allowed) throw new Error(gate.reason ?? "The model route failed its validation.");
+      await memory.setmodelroutes([route, ...routes.filter((candidate) => candidate.kind !== kind)]);
+      await memory.addmodelrouterevision(route);
+      await audit("model", `The user routed the task kind ${kind} to the ${route.providerid} provider with the ${route.model} model${route.fallbackproviderid !== void 0 ? ` and the ${route.fallbackproviderid} fallback with the ${route.fallbackmodel} model` : " and no fallback"} at revision ${route.revision}.`, {});
+      return llmstateof();
+    }
+    case "llmcommand": {
+      const inputcommand = message;
+      const text2 = inputcommand.text?.trim() ?? "";
+      if (text2 === "") throw new Error("The command parse needs the natural language text.");
+      const providers = await memory.getproviders();
+      const routes = await memory.getmodelroutes();
+      const resolved = resolveroute({ routes, providers, kind: "parsecommand" });
+      if (resolved.provider === void 0 || resolved.model === void 0) {
+        const local = await memory.getlocalmodel();
+        if (local === void 0 || local.endpoint.trim() === "") {
+          const fallback = classifyintent(text2);
+          const parse = { text: text2, intent: fallback.intent, entities: [], confidence: fallback.confidence, parsedat: Date.now() };
+          await memory.setcommandparse(parse);
+          await audit("model", `The deterministic classifier mapped the command to the ${fallback.intent} intent at confidence ${fallback.confidence} because no model route and no local endpoint serve the parsecommand task kind.`, {});
+          return llmstateof();
+        }
+        const key2 = local.authref !== void 0 ? await memory.getsecret(local.authref.storageid) : void 0;
+        const now = Date.now();
+        const outcome = await calllocal({ local, messages: [{ role: "system", content: "Parse the user command into json with the fields intent (one of navigate, extract, fill, monitor, automate, ask), entities (an array of { name, value } objects) and confidence (a number between 0 and 1). Answer with the json object only." }, { role: "user", content: text2 }], ...key2 !== void 0 ? { apikey: key2 } : {}, transport: llmtransport });
+        const replay2 = await parsecommand({ provider: { id: "local", name: "The local model endpoint", endpoint: local.endpoint, style: local.style, models: [local.model], status: "available", createdat: now }, model: local.model, text: text2, transport: cannedtransport(outcome.text) });
+        if (replay2.parse === void 0) {
+          if (replay2.output !== void 0) await recordguardnotice("parsecommand", replay2.output);
+          throw new Error(replay2.reason ?? "The command parse failed its guard.");
+        }
+        await memory.setcommandparse(replay2.parse);
+        await memory.addusagerecord({ id: randomid(), providerid: "local", endpoint: local.endpoint, model: local.model, prompttokens: outcome.usage?.prompttokens ?? 0, completiontokens: outcome.usage?.completiontokens ?? 0, totaltokens: outcome.usage?.totaltokens ?? 0, cost: 0, local: true, at: now });
+        await audit("model", `The local model parsed the command into the ${replay2.parse.intent} intent at confidence ${replay2.parse.confidence} with ${replay2.parse.entities.length} entit${replay2.parse.entities.length === 1 ? "y" : "ies"}; the call never left the machine.`, {});
+        return llmstateof();
+      }
+      const raw = await callroutedmodel({ kind: "parsecommand", messages: [{ role: "system", content: "Parse the user command into json with the fields intent (one of navigate, extract, fill, monitor, automate, ask), entities (an array of { name, value } objects) and confidence (a number between 0 and 1). Answer with the json object only." }, { role: "user", content: text2 }] });
+      const key = await providerkey(raw.provider);
+      const replay = await parsecommand({ provider: raw.provider, model: raw.model, text: text2, ...key !== void 0 ? { apikey: key } : {}, transport: cannedtransport(raw.text) });
+      if (replay.parse === void 0) {
+        if (replay.output !== void 0) await recordguardnotice("parsecommand", replay.output);
+        throw new Error(replay.reason ?? "The command parse failed its guard.");
+      }
+      await memory.setcommandparse(replay.parse);
+      await audit("model", `The routed model parsed the command into the ${replay.parse.intent} intent at confidence ${replay.parse.confidence} with ${replay.parse.entities.length} entit${replay.parse.entities.length === 1 ? "y" : "ies"}.`, {});
+      return llmstateof();
+    }
+    case "llmdraftplan": {
+      const inputdraft = message;
+      const goal = inputdraft.goal?.trim() ?? "";
+      if (goal === "") throw new Error("The plan draft needs the goal.");
+      const session = await memory.getsession();
+      const origin = session?.origin ?? "";
+      const raw = await callroutedmodel({ kind: "draftplan", messages: [{ role: "system", content: `Draft a browser agent plan as json with the fields goal (string), steps (an array of { kind, target, value, summary } objects using browser action kinds) and openquestions (an array of strings for what stays unclear). Answer with the json object only.` }, { role: "user", content: goal }] });
+      const key = await providerkey(raw.provider);
+      const replay = await draftplan({ provider: raw.provider, model: raw.model, goal, ...origin !== "" ? { origin } : {}, ...key !== void 0 ? { apikey: key } : {}, transport: cannedtransport(raw.text) });
+      if (replay.draft === void 0) {
+        if (replay.output !== void 0) await recordguardnotice("draftplan", replay.output);
+        throw new Error(replay.reason ?? "The plan draft failed its guard.");
+      }
+      await memory.addplandraft(replay.draft);
+      await audit("model", `The ${raw.provider.name} model drafted a ${replay.draft.steps.length} step plan for the goal ${goal}${replay.draft.lintfindings.length > 0 ? ` with ${replay.draft.lintfindings.length} grammar finding${replay.draft.lintfindings.length === 1 ? "" : "s"} the review must resolve` : " with a clean grammar check"}${replay.draft.openquestions.length > 0 ? ` and ${replay.draft.openquestions.length} open question${replay.draft.openquestions.length === 1 ? "" : "s"}` : ""}; the draft never executes until the human review approves it.`, {});
+      return llmstateof();
+    }
+    case "llmdraftdecision": {
+      const inputdecision = message;
+      const drafts = await memory.getplandrafts();
+      const draft = drafts.find((candidate) => candidate.id === (inputdecision.draftid ?? ""));
+      if (!draft) throw new Error("No model drafted plan matches the decision.");
+      if (inputdecision.approve !== true) {
+        await memory.setplandrafts(drafts.map((candidate) => candidate.id === draft.id ? { ...candidate, state: "rejected" } : candidate));
+        await audit("model", `The user rejected the model drafted plan ${draft.id} of the goal ${draft.goal}; the draft stays for the audit trail.`, {});
+        return llmstateof();
+      }
+      const gate = plandraftreviewgate(draft);
+      if (!gate.allowed) throw new Error(gate.reason ?? "The model drafted plan failed its review gate.");
+      if (draft.lintfindings.length > 0) throw new Error(`The model drafted plan carries grammar violations the review must resolve first: ${draft.lintfindings.join(" ")}`);
+      const steps = Array.isArray(inputdecision.steps) && inputdecision.steps.length > 0 ? inputdecision.steps.filter((step) => typeof step?.kind === "string" && step.kind.trim() !== "" && typeof step?.summary === "string" && step.summary.trim() !== "").map((step, index) => ({ id: typeof step.id === "string" && step.id.trim() !== "" ? step.id.trim() : `step${index + 1}`, kind: step.kind, ...typeof step.target === "string" && step.target.trim() !== "" ? { target: step.target } : {}, ...typeof step.value === "string" && step.value.trim() !== "" ? { value: step.value } : {}, summary: step.summary })) : draft.steps.map((step) => ({ id: step.id, kind: step.kind, ...step.target !== void 0 ? { target: step.target } : {}, ...step.value !== void 0 ? { value: step.value } : {}, summary: step.summary }));
+      if (steps.length === 0) throw new Error("The model drafted plan carries no step to approve.");
+      for (const step of steps) {
+        try {
+          actionrisk(step.kind);
+        } catch {
+          throw new Error(`The drafted step ${step.id} carries the unsupported kind ${step.kind}.`);
+        }
+      }
+      const session = await memory.getsession();
+      const plan = draftplanof(draft, steps, session?.origin ?? "");
+      await memory.setplan(plan);
+      await memory.setprogress(resetforplan(await memory.getprogress(), plan, Date.now()));
+      await memory.setplandrafts(drafts.map((candidate) => candidate.id === draft.id ? { ...candidate, state: "approved" } : candidate));
+      await audit("model", `The user approved the model drafted plan ${draft.id} of the goal ${draft.goal}; the ${plan.steps.length} drafted steps became a pending plan that still passes the same plan review every local plan passes before anything executes.`, { planid: plan.id, ...session ? { sessionid: session.id } : {} });
+      return llmstateof();
+    }
+    case "llmreplan": {
+      const inputreplan = message;
+      const drafts = await memory.getplandrafts();
+      const draft = inputreplan.draftid !== void 0 && inputreplan.draftid.trim() !== "" ? drafts.find((candidate) => candidate.id === inputreplan.draftid) : drafts.find((candidate) => candidate.state === "approved");
+      if (!draft) throw new Error("No approved model drafted plan exists to replan.");
+      const failedstepids = Array.isArray(inputreplan.failedstepids) ? inputreplan.failedstepids.filter((id) => typeof id === "string" && id.trim() !== "") : [];
+      const reason = inputreplan.reason?.trim() ?? "";
+      if (reason === "") throw new Error("The replan needs the failure reason.");
+      const notes = await memory.getreflectnotes();
+      const raw = await callroutedmodel({ kind: "replan", messages: [{ role: "system", content: `The plan ${draft.goal} failed with the reason: ${reason}. Draft the revised tail steps of the plan as json with the field steps (an array of { kind, target, value, summary } objects using browser action kinds). Answer with the json object only.` }, { role: "user", content: draft.goal }] });
+      const completedstepids = draft.steps.filter((step) => !failedstepids.includes(step.id)).map((step) => step.id);
+      const key = await providerkey(raw.provider);
+      const replay = await replannonfail({ provider: raw.provider, model: raw.model, draft, completedstepids, failedstepids, reason, ...reflectionsummary(notes) !== "" ? { lessons: [reflectionsummary(notes)] } : {}, ...key !== void 0 ? { apikey: key } : {}, transport: cannedtransport(raw.text) });
+      if (replay.replan === void 0) {
+        if (replay.output !== void 0) await recordguardnotice("replan", replay.output);
+        throw new Error(replay.reason ?? "The replan failed its guard.");
+      }
+      await memory.addreplan(replay.replan);
+      await audit("model", `The ${raw.provider.name} model replanned the failed plan ${draft.id}: ${completedstepids.length} completed step${completedstepids.length === 1 ? "" : "s"} stay, the ${failedstepids.length} failed step${failedstepids.length === 1 ? "" : "s"} fall away and the ${replay.replan.tail.length} revised step${replay.replan.tail.length === 1 ? "" : "s"} carry the fresh review marker.`, {});
+      return llmstateof();
+    }
+    case "llmreplandecision": {
+      const inputdecision = message;
+      const replans = await memory.getreplans();
+      const replan = replans.find((candidate) => candidate.id === (inputdecision.replanid ?? ""));
+      if (!replan) throw new Error("No replan record matches the decision.");
+      if (inputdecision.approve !== true) {
+        await memory.setreplans(replans.map((candidate) => candidate.id === replan.id ? { ...candidate, state: "rejected" } : candidate));
+        await audit("model", `The user rejected the replan ${replan.id}; the record stays for the audit trail.`, {});
+        return llmstateof();
+      }
+      const gate = replanreviewgate(replan);
+      if (!gate.allowed) throw new Error(gate.reason ?? "The replan failed its fresh review gate.");
+      const draft = (await memory.getplandrafts()).find((candidate) => candidate.id === replan.draftid);
+      if (!draft) throw new Error("The replan names no stored draft.");
+      const completed = draft.steps.filter((step) => replan.completedstepids.includes(step.id));
+      const steps = [...completed.map((step) => ({ id: step.id, kind: step.kind, ...step.target !== void 0 ? { target: step.target } : {}, ...step.value !== void 0 ? { value: step.value } : {}, summary: step.summary })), ...replan.tail.map((step) => ({ id: step.id, kind: step.kind, ...step.target !== void 0 ? { target: step.target } : {}, ...step.value !== void 0 ? { value: step.value } : {}, summary: step.summary }))];
+      const session = await memory.getsession();
+      const plan = draftplanof(draft, steps, session?.origin ?? "");
+      await memory.setplan(plan);
+      await memory.setprogress(resetforplan(await memory.getprogress(), plan, Date.now()));
+      await memory.setreplans(replans.map((candidate) => candidate.id === replan.id ? { ...candidate, state: "approved" } : candidate));
+      await audit("model", `The user approved the fresh review of the replan ${replan.id}: ${completed.length} completed step${completed.length === 1 ? "" : "s"} stay and the ${replan.tail.length} revised step${replan.tail.length === 1 ? "" : "s"} became the changed tail of a pending plan that still passes the same plan review.`, { planid: plan.id, ...session ? { sessionid: session.id } : {} });
+      return llmstateof();
+    }
+    case "llmreflect": {
+      const inputreflect = message;
+      const outcomes = await memory.getoutcomes();
+      const outcome = inputreflect.stepid !== void 0 && inputreflect.stepid.trim() !== "" ? outcomes.find((entry) => entry.stepid === inputreflect.stepid) : outcomes[0];
+      if (!outcome) throw new Error("No executed step outcome exists to reflect on.");
+      const notes = await memory.getreflectnotes();
+      const summary = reflectionsummary(notes.filter((note) => note.stepid !== outcome.stepid));
+      const raw = await callroutedmodel({ kind: "reflect", stepid: outcome.stepid, messages: [{ role: "system", content: `Reflect on the executed step ${outcome.stepid} with the outcome: ${outcome.summary}. Answer as json with the fields outcome (string), lesson (string) and advice (string) for the next step. Answer with the json object only.` }, { role: "user", content: outcome.summary }] });
+      const key = await providerkey(raw.provider);
+      const replay = await reflectstep({ provider: raw.provider, model: raw.model, runid: inputreflect.runid?.trim() ?? "adhoc", stepid: outcome.stepid, outcome: outcome.summary, ...summary !== "" ? { lessons: [summary] } : {}, ...key !== void 0 ? { apikey: key } : {}, transport: cannedtransport(raw.text) });
+      if (replay.note === void 0) {
+        if (replay.output !== void 0) await recordguardnotice("reflect", replay.output);
+        throw new Error(replay.reason ?? "The reflection failed its guard.");
+      }
+      await memory.addreflectnote(replay.note);
+      await audit("model", `The ${raw.provider.name} model reflected on the step ${outcome.stepid}: the lesson learned rides the next prompt together with the running lessons of the earlier steps.`, {});
+      return llmstateof();
+    }
+    case "llmbudget": {
+      const inputbudget = message;
+      if (inputbudget.remove === true) {
+        await memory.setcostbudget({ maxtokens: Number.MAX_SAFE_INTEGER, configuredat: Date.now() });
+        await audit("model", "The user removed the cost budget; the runs stay unbounded because no ceiling applies.", {});
+        return llmstateof();
+      }
+      const budget = { ...inputbudget.runid !== void 0 && inputbudget.runid.trim() !== "" ? { runid: inputbudget.runid.trim() } : {}, ...inputbudget.maxtokens !== void 0 && Number.isFinite(inputbudget.maxtokens) ? { maxtokens: inputbudget.maxtokens } : {}, ...inputbudget.maxcost !== void 0 && Number.isFinite(inputbudget.maxcost) ? { maxcost: inputbudget.maxcost } : {}, ...inputbudget.currency !== void 0 && inputbudget.currency.trim() !== "" ? { currency: inputbudget.currency.trim() } : {}, configuredat: Date.now() };
+      const gate = costbudgetvalid(budget);
+      if (!gate.allowed) throw new Error(gate.reason ?? "The cost budget failed its validation.");
+      await memory.setcostbudget(budget);
+      await audit("model", `The user configured the cost budget${budget.runid !== void 0 ? ` of the run ${budget.runid}` : ""}${budget.maxtokens !== void 0 ? ` with a ${budget.maxtokens} token ceiling` : ""}${budget.maxcost !== void 0 ? `${budget.maxtokens !== void 0 ? " and" : " with"} a ${budget.maxcost} ${budget.currency ?? ""} cost ceiling` : ""}; a reached ceiling halts the run and asks the user.`, {});
+      return llmstateof();
+    }
+    case "llmtemplate": {
+      const inputtemplate = message;
+      if (inputtemplate.remove === true) {
+        const name2 = inputtemplate.name?.trim() ?? "";
+        if (name2 === "") throw new Error("The template removal needs the template name.");
+        await memory.setprompttemplates(removetemplate(await memory.getprompttemplates(), name2));
+        await audit("model", `The user removed every version of the prompt template ${name2}; the change history leaves with the name.`, {});
+        return llmstateof();
+      }
+      const name = inputtemplate.name?.trim() ?? "";
+      const body = inputtemplate.body ?? "";
+      if (name === "") throw new Error("The prompt template needs its name.");
+      if (body.trim() === "") throw new Error("The prompt template needs its body.");
+      const stored = savetemplate({ templates: await memory.getprompttemplates(), name, body, ...inputtemplate.notes !== void 0 && inputtemplate.notes.trim() !== "" ? { notes: inputtemplate.notes } : {}, now: Date.now() });
+      await memory.setprompttemplates(stored);
+      const latest = latesttemplate(stored, name);
+      await audit("model", `The user saved the prompt template ${name} at version ${latest?.version ?? 1} with ${latest?.variables.length ?? 0} variable${(latest?.variables.length ?? 0) === 1 ? "" : "s"}${inputtemplate.notes !== void 0 ? ` and the change notes` : ""}; every earlier version stays stored.`, {});
+      return llmstateof();
+    }
     default:
       throw new Error("Unknown Devthink request.");
   }
@@ -19526,6 +20352,82 @@ async function restorebackgroundruns() {
 async function mcpconfigof() {
   return await memory.getmcpconfig() ?? defaultmcpconfig();
 }
+var llmtaskkinds = ["parsecommand", "classifyintent", "draftplan", "replan", "reflect", "summarize"];
+var llmtransport = async (url, init) => {
+  const response = await fetch(url, { method: init.method, headers: init.headers, ...init.body !== void 0 ? { body: init.body } : {}, ...init.mode !== void 0 ? { mode: init.mode } : {}, redirect: init.redirect });
+  return { status: response.status, headers: Object.fromEntries(response.headers.entries()), body: await response.text(), ...response.redirected ? { redirected: true } : {} };
+};
+function cannedtransport(text2) {
+  return async () => ({ status: 200, headers: { "content-type": "application/json" }, body: JSON.stringify({ choices: [{ message: { role: "assistant", content: text2 } }] }) });
+}
+async function providerkey(provider) {
+  if (provider.authref === void 0) return void 0;
+  const secret = await memory.getsecret(provider.authref.storageid);
+  if (secret === void 0) throw new Error(`The provider ${provider.name} references the stored key ${provider.authref.name} and its secret is missing; set it from the review panel first.`);
+  return secret;
+}
+async function callroutedmodel(input) {
+  const providers = await memory.getproviders();
+  const routes = await memory.getmodelroutes();
+  const primary = resolveroute({ routes, providers, kind: input.kind });
+  const pair = primary.provider !== void 0 && primary.model !== void 0 ? primary : fallbackroute({ routes, providers, kind: input.kind });
+  if (pair.provider === void 0 || pair.model === void 0) throw new Error(pair.reason ?? `No model route configures the task kind ${input.kind}; the user picks the provider and model pair.`);
+  const budget = await memory.getcostbudget();
+  if (budget !== void 0) {
+    const verdict = budgetcheck({ budget, totals: usagetotals(await memory.getusagerecords()) });
+    if (!verdict.allowed) {
+      await audit("model", `The cost budget halted the ${input.kind} model call before it left: ${verdict.reason ?? "the ceiling is reached"} The user answers before anything else runs.`, {});
+      throw new Error(verdict.reason ?? "The cost budget halted the run.");
+    }
+  }
+  const attempt = async (provider, model) => {
+    const egress = provideregressgrade({ provider, local: islocalorigin(provider.endpoint) });
+    if (!egress.allowed) throw new Error(egress.reason ?? "The provider config failed its gate.");
+    const key = await providerkey(provider);
+    const at = Date.now();
+    const outcome = await callmodel({ provider, model, messages: input.messages, ...key !== void 0 ? { apikey: key } : {}, transport: llmtransport });
+    const usage = outcome.usage ?? { prompttokens: 0, completiontokens: 0, totaltokens: 0 };
+    const cost = provider.costpermilliontokens !== void 0 && Number.isFinite(provider.costpermilliontokens) ? (usage.prompttokens + usage.completiontokens) / 1e6 * provider.costpermilliontokens : 0;
+    await memory.addusagerecord({ id: randomid(), ...input.stepid !== void 0 ? { stepid: input.stepid } : {}, providerid: provider.id, endpoint: provider.endpoint, model, prompttokens: usage.prompttokens, completiontokens: usage.completiontokens, totaltokens: usage.totaltokens, cost, ...islocalorigin(provider.endpoint) ? { local: true } : {}, at });
+    await audit("model", `The ${input.kind} model call reached the ${provider.endpoint} endpoint with the ${model} model and ${usage.totaltokens} total token${usage.totaltokens === 1 ? "" : "s"} (${usage.prompttokens} prompt and ${usage.completiontokens} completion)${cost > 0 ? ` at the recorded cost of ${cost.toFixed(4)}` : ""}; ${egress.reason ?? ""}`, {});
+    return { text: outcome.text, provider, model, at };
+  };
+  try {
+    return await attempt(pair.provider, pair.model);
+  } catch (error) {
+    const now = Date.now();
+    const marked = markprovider({ providers, providerid: pair.provider.id, available: false, now });
+    await memory.setproviders(marked);
+    await audit("model", `The provider ${pair.provider.name} failed the ${input.kind} call and stays marked unavailable until its next success: ${error instanceof Error ? error.message : String(error)}`, {});
+    const fallback = fallbackroute({ routes, providers: marked, kind: input.kind });
+    if (fallback.provider === void 0 || fallback.model === void 0) throw error;
+    const outcome = await attempt(fallback.provider, fallback.model);
+    await memory.setproviders(markprovider({ providers: await memory.getproviders(), providerid: fallback.provider.id, available: true, now: Date.now() }));
+    return outcome;
+  }
+}
+async function recordguardnotice(kind, output) {
+  if (output.verdict === "valid") return;
+  await memory.addguardnotice(output);
+  await audit("model", `The guardrails refused the ${kind} model output after ${output.attempts} attempt${output.attempts === 1 ? "" : "s"}: ${output.reason ?? "the output failed its guard"}`, {});
+}
+function draftplanof(draft, steps, origin) {
+  const now = Date.now();
+  const mapped = steps.map((step) => ({ id: step.id, kind: step.kind, ...step.target !== void 0 ? { target: step.target } : {}, ...step.value !== void 0 ? { value: step.value } : {}, summary: step.summary, risk: actionrisk(step.kind) }));
+  return { id: randomid(), objective: draft.goal, origin, steps: mapped, createdat: now, expiresat: now + sessionduration, state: "pending" };
+}
+async function llmstateof() {
+  const providers = await memory.getproviders();
+  const routes = await memory.getmodelroutes();
+  const budget = await memory.getcostbudget();
+  const local = await memory.getlocalmodel();
+  const parse = await memory.getcommandparse();
+  const tasks = llmtaskkinds.map((kind) => {
+    const resolved = resolveroute({ routes, providers, kind });
+    return { kind, ...resolved.provider !== void 0 ? { provider: resolved.provider.name, model: resolved.model } : {} };
+  });
+  return { providers, ...local !== void 0 ? { local } : {}, routes, routehistory: (await memory.getmodelroutehistory()).slice(0, 10), drafts: (await memory.getplandrafts()).slice(0, 10), replans: (await memory.getreplans()).slice(0, 10), notes: (await memory.getreflectnotes()).slice(0, 10), ...budget !== void 0 ? { budget } : {}, usage: await memory.getusage(), templates: searchtemplates(await memory.getprompttemplates(), "").slice(0, 20), ...parse !== void 0 ? { parse } : {}, guardnotices: (await memory.getguardnotices()).slice(0, 10), tasks, toolbriefs: rendertoolbriefs((buildtoolcatalog().domains[0]?.tools ?? []).slice(0, 4)) };
+}
 async function mcpstateof() {
   const config = await mcpconfigof();
   const state = await memory.getmcpstate();