@wenathlan/extension 1.1.55 → 1.1.57

package/extension/dist/background.js

@@ -2510,6 +2510,224 @@ var sessionmemory = class {
   async setstreamchannels(channels) {
     return this.adapter.set("mcpchannels", channels);
   }
+  /** Returns every client event subscription with its kinds and filters, newest first. */
+  async geteventsubscriptions() {
+    return await this.adapter.get("mcpeventsubscriptions") ?? [];
+  }
+  /** Replaces the stored event subscription set after one subscribe, unsubscribe or delivery sweep. */
+  async seteventsubscriptions(subscriptions) {
+    return this.adapter.set("mcpeventsubscriptions", subscriptions);
+  }
+  /** Returns every page state resource watcher with its baseline, newest first. */
+  async getresourcewatches() {
+    return await this.adapter.get("mcpresourcewatches") ?? [];
+  }
+  /** Replaces the stored resource watcher set after one watch, unwatch or delta push. */
+  async setresourcewatches(watches) {
+    return this.adapter.set("mcpresourcewatches", watches);
+  }
+  /** Returns every sampling request with its provenance, newest first. */
+  async getsamplingrequests() {
+    return await this.adapter.get("mcpsampling") ?? [];
+  }
+  /** Replaces the stored sampling request set after one request or answer. */
+  async setsamplingrequests(requests) {
+    return this.adapter.set("mcpsampling", requests);
+  }
+  /** Returns every stored idempotency record for replay, newest first. */
+  async getidempotencyrecords() {
+    return await this.adapter.get("mcpidempotency") ?? [];
+  }
+  /** Replaces the stored idempotency record set after one store or expiry sweep. */
+  async setidempotencyrecords(records) {
+    return this.adapter.set("mcpidempotency", records);
+  }
+  /** Returns every per client rate limit counter with its window and budget. */
+  async getcallratelimits() {
+    return await this.adapter.get("mcpcallratelimits") ?? [];
+  }
+  /** Replaces the stored per client rate limit set after one configuration or counted call. */
+  async setcallratelimits(limits) {
+    return this.adapter.set("mcpcallratelimits", limits);
+  }
+  /** Returns every stored batch call with its per item outcomes, newest first. */
+  async getbatchcalls() {
+    return await this.adapter.get("mcpbatchcalls") ?? [];
+  }
+  /** Upserts one batch call by its id with the per item outcomes riding the record. */
+  async setbatchcall(batch) {
+    await this.adapter.set("mcpbatchcalls", [batch, ...(await this.getbatchcalls()).filter((candidate) => candidate.id !== batch.id)]);
+  }
+  /** Returns every call context of the call runtime, newest first. */
+  async getcallcontexts() {
+    return await this.adapter.get("mcpcallcontexts") ?? [];
+  }
+  /** Replaces the stored call context set after one begin, end or cancellation. */
+  async setcallcontexts(contexts) {
+    return this.adapter.set("mcpcallcontexts", contexts);
+  }
+  /** Returns every stored tool mock for client testing. */
+  async gettoolmocks() {
+    return await this.adapter.get("mcptoolmocks") ?? [];
+  }
+  /** Upserts one tool mock by its tool name or removes it when the canned result is absent. */
+  async settoolmock(mock) {
+    await this.adapter.set("mcptoolmocks", [mock, ...(await this.gettoolmocks()).filter((candidate) => candidate.tool !== mock.tool)]);
+  }
+  /** Removes one tool mock so its tool returns to the real gates. */
+  async removetoolmock(tool) {
+    await this.adapter.set("mcptoolmocks", (await this.gettoolmocks()).filter((candidate) => candidate.tool !== tool));
+  }
+  /** Stores one stream chunk of a progressive tool result under the recent chunk window of 25 records. */
+  async addstreamchunk(chunk) {
+    await this.adapter.set("mcpstreamchunks", [chunk, ...(await this.getstreamchunks()).slice(0, 24)]);
+  }
+  /** Returns the recent stream chunks of progressive tool results, newest first. */
+  async getstreamchunks() {
+    return await this.adapter.get("mcpstreamchunks") ?? [];
+  }
+  /** Replaces the recent stream chunk window after one streaming sweep. */
+  async setstreamchunks(chunks) {
+    return this.adapter.set("mcpstreamchunks", chunks);
+  }
+  /** Returns the audited tool call log under the requested filters: the client, the tool, the outcome, the time floor and the newest bound, all optional. */
+  async getcalllog(filters) {
+    let records = await this.listtoolcalls();
+    if (filters?.clientid !== void 0) records = records.filter((record2) => record2.clientid === filters.clientid);
+    if (filters?.tool !== void 0) records = records.filter((record2) => record2.tool === filters.tool);
+    if (filters?.ok !== void 0) records = records.filter((record2) => record2.ok === filters.ok);
+    if (filters?.since !== void 0) records = records.filter((record2) => record2.at >= (filters.since ?? 0));
+    return filters?.limit !== void 0 ? records.slice(0, filters.limit) : records;
+  }
+  /** Stores one progress notice of a long tool call under the recent notice window of 25 records. */
+  async addprogressnotice(notice) {
+    await this.adapter.set("mcpprogressnotices", [notice, ...(await this.getprogressnotices()).slice(0, 24)]);
+  }
+  /** Returns the recent progress notices of long tool calls, newest first. */
+  async getprogressnotices() {
+    return await this.adapter.get("mcpprogressnotices") ?? [];
+  }
+  /** Returns the tool dry run toggle of the next call: true once the user armed the dry run in the panel. */
+  async getdryruntoggle() {
+    return await this.adapter.get("mcpdryruntoggle") === true;
+  }
+  /** Arms or disarms the tool dry run of the next call. */
+  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";
@@ -6770,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(", ")}.` };
@@ -7347,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 };
@@ -7372,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") {
@@ -7410,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") {
@@ -7428,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") {
@@ -7445,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") {
@@ -8417,6 +8635,90 @@ function approvaltimeoutvalid(timeout) {
 function revocationgate() {
   return { allowed: true };
 }
+function subscriptiongrade(subscription) {
+  if (!Array.isArray(subscription.kinds) || subscription.kinds.length === 0) return { allowed: false, reason: "An event subscription needs at least one protocol event kind." };
+  if (subscription.kinds.includes("callstarted") && subscription.origin === void 0 && subscription.tool === void 0) return { allowed: false, reason: "An event subscription that mirrors the callstarted events of tools with side effects needs its origin or tool filter so it never widens what the session grants." };
+  return { allowed: true };
+}
+function callratelimitvalid(limit) {
+  if (limit === void 0) return { allowed: true };
+  if (typeof limit.windowms !== "number" || !Number.isFinite(limit.windowms) || limit.windowms <= 0) return { allowed: false, reason: "The rate limit window must stay a positive user value with no code ceiling." };
+  if (limit.budget !== void 0 && (typeof limit.budget !== "number" || !Number.isFinite(limit.budget) || limit.budget <= 0)) return { allowed: false, reason: "The rate limit budget must stay a positive user value with no code ceiling." };
+  if (limit.clientid.trim() === "") return { allowed: false, reason: "A per client rate limit needs the client it counts." };
+  return { allowed: true };
+}
+function batchgrade(input) {
+  if (input.calls.length === 0) return { allowed: false, reason: "A batch call needs at least one ordered tool call." };
+  const sensitive = input.calls.some((call) => call.risk === "sensitive");
+  if (sensitive && !input.approved) return { allowed: false, reason: "The batch grades sensitive through its most sensitive member and runs only behind the approval gates." };
+  return { allowed: true };
+}
+function mockusagevalid(mock) {
+  if (mock.testcontext !== true) return { allowed: false, reason: `The ${mock.tool} mock stays outside a test context and is refused; tool mocks never answer real calls.` };
+  if (mock.tool.trim() === "") return { allowed: false, reason: "A tool mock needs the namespaced tool it stands in for." };
+  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) {
@@ -8596,7 +8898,7 @@ function recordtoolcall(progress, planid, stepid, entry, now) {
 }
 
 // version.ts
-var packageversion = "1.1.55";
+var packageversion = "1.1.57";
 
 // types.ts
 var protocolversion = packageversion;
@@ -8665,6 +8967,128 @@ function tlsstateof(tls) {
   return { mode: tls.mode, certificaterequired: tls.mode === "required" || tls.certificatefingerprint !== void 0, verified: tls.verifiedat !== void 0 };
 }
 
+// agentstream.ts
+var protocoleventkinds = ["callstarted", "callresult", "streamchunk", "progress", "resourcedelta", "sampling", "cancellation"];
+var readonlyeventkinds = ["callresult", "streamchunk", "progress", "resourcedelta", "sampling", "cancellation"];
+function subscriberegister(input) {
+  if (input.clientid.trim() === "") return { reason: "The event subscription needs the paired client it belongs to." };
+  const kinds = input.kinds === void 0 || input.kinds.length === 0 ? [...readonlyeventkinds] : [...new Set(input.kinds)];
+  for (const kind of kinds) {
+    if (!protocoleventkinds.includes(kind)) return { reason: `The event kind ${kind} is not a protocol event kind.` };
+  }
+  if (input.origin !== void 0 && input.origin.trim() === "") return { reason: "The origin filter of an event subscription must name an origin or stay absent." };
+  if (input.tool !== void 0 && input.tool.trim() === "") return { reason: "The tool filter of an event subscription must name a tool or stay absent." };
+  return { subscription: { id: input.id ?? randomid(), clientid: input.clientid, kinds, ...input.origin !== void 0 ? { origin: input.origin } : {}, ...input.tool !== void 0 ? { tool: input.tool } : {}, createdat: input.now } };
+}
+function unsubscriberegister(subscriptions, id, now) {
+  return subscriptions.map((subscription) => subscription.id === id && subscription.canceledat === void 0 ? { ...subscription, canceledat: now } : subscription);
+}
+function notifyevent(input) {
+  const deliveries = [];
+  const subscriptions = input.subscriptions.map((subscription) => {
+    if (subscription.canceledat !== void 0) return subscription;
+    if (!subscription.kinds.includes(input.kind)) return subscription;
+    if (subscription.origin !== void 0 && input.origin !== void 0 && subscription.origin !== input.origin) return subscription;
+    if (subscription.tool !== void 0 && input.tool !== void 0 && subscription.tool !== input.tool) return subscription;
+    deliveries.push({ subscriptionid: subscription.id, clientid: subscription.clientid, frame: { jsonrpc: "2.0", method: "events/notify", params: { subscriptionid: subscription.id, kind: input.kind, ...input.origin !== void 0 ? { origin: input.origin } : {}, ...input.tool !== void 0 ? { tool: input.tool } : {}, ...input.payload !== void 0 ? { payload: input.payload } : {}, at: input.now } } });
+    return { ...subscription, lastdeliveredat: input.now };
+  });
+  return { deliveries, subscriptions };
+}
+function watchresource(input) {
+  if (input.clientid.trim() === "") return { reason: "The resource watcher needs the paired client it belongs to." };
+  if (input.resource.trim() === "") return { reason: "The resource watcher needs the page state resource it watches." };
+  return { watch: { id: input.id ?? randomid(), clientid: input.clientid, resource: input.resource, baseline: input.state ?? {}, createdat: input.now } };
+}
+function unwatchresource(watches, id, now) {
+  return watches.map((watch) => watch.id === id && watch.canceledat === void 0 ? { ...watch, canceledat: now } : watch);
+}
+function notifyresource(input) {
+  const deliveries = [];
+  const watches = input.watches.map((watch) => {
+    if (watch.canceledat !== void 0 || watch.resource !== input.resource) return watch;
+    const delta = {};
+    for (const [key, value] of Object.entries(input.state)) {
+      if (!(key in watch.baseline) || watch.baseline[key] !== value) delta[key] = value;
+    }
+    if (Object.keys(delta).length === 0) return watch;
+    deliveries.push({ watchid: watch.id, clientid: watch.clientid, delta });
+    return { ...watch, baseline: { ...input.state }, lastdeliveredat: input.now };
+  });
+  return { deliveries, watches };
+}
+function requestsampling(input) {
+  if (input.clientid.trim() === "") return { reason: "The sampling callback needs the paired client it addresses." };
+  if (input.prompt.trim() === "") return { reason: "The sampling callback needs its prompt." };
+  if (input.capabilities?.sampling === false) return { reason: "The client declared no sampling capability and the callback is refused." };
+  if (input.maxtokens !== void 0 && (!Number.isFinite(input.maxtokens) || input.maxtokens <= 0)) return { reason: "The granted maximum tokens of a sampling callback must stay a positive user value." };
+  const granted = input.pagegrant === true;
+  const pagecontent = granted ? input.pagecontent : void 0;
+  const prompt = granted || input.pagecontent === void 0 ? input.prompt : `${input.prompt}
+The page content stays stripped because the user granted none.`;
+  return { request: { id: input.id ?? randomid(), clientid: input.clientid, prompt, ...input.system !== void 0 ? { system: input.system } : {}, ...pagecontent !== void 0 ? { pagecontent } : {}, ...input.maxtokens !== void 0 ? { maxtokens: input.maxtokens } : {}, state: "pending", requestedat: input.now } };
+}
+function answersampling(input) {
+  const match = input.requests.find((request2) => request2.id === input.id);
+  if (match === void 0) return { requests: input.requests, reason: "The sampling answer names no stored request." };
+  if (match.state !== "pending") return { requests: input.requests, reason: "The sampling request already closed its round trip." };
+  const request = { ...match, state: input.refused === true ? "refused" : "answered", answeredat: input.now, ...input.refused !== true && input.answer !== void 0 ? { answer: input.answer } : {} };
+  return { requests: input.requests.map((candidate) => candidate.id === input.id ? request : candidate), request };
+}
+function listprompts() {
+  return [
+    { name: "runreview", description: "Renders the run review prompt that asks the user model to summarize the executed steps of the approved plan behind the consent gates.", arguments: [{ name: "objective", description: "The objective of the approved plan under review.", required: true }, { name: "steps", description: "The executed step summaries the review covers.", required: true }, { name: "tone", description: "The tone of the summary.", default: "plain" }], template: "Review the run of the objective {{objective}}. Summarize the executed steps: {{steps}}. Keep the tone {{tone}} and state every refusal the consent gates raised." },
+    { name: "pagesummary", description: "Renders the page summary prompt that condenses the observed page state of the session tab into the summary the client model asked for.", arguments: [{ name: "url", description: "The url of the observed page.", required: true }, { name: "observations", description: "The observed page state sections the summary condenses.", required: true }], template: "Summarize the page at {{url}} from the observations: {{observations}}. Name nothing the observations leave out." },
+    { name: "failuretriage", description: "Renders the failure triage prompt that classifies a failed tool call through the retry hints of the structured error it produced.", arguments: [{ name: "tool", description: "The namespaced tool that failed.", required: true }, { name: "error", description: "The structured error of the failed call.", required: true }], template: "Triage the failure of the {{tool}} tool: {{error}}. Classify it as retryable, a busy window or a consent refusal and propose the next reviewed step." }
+  ];
+}
+function renderprompt(prompt, args) {
+  return prompt.template.replace(/\{\{\s*([a-z0-9]+)\s*\}\}/g, (whole, name) => {
+    const value = args[name];
+    if (value === void 0 || value === null) return whole;
+    return typeof value === "string" ? value : JSON.stringify(value);
+  });
+}
+function callprompt(input) {
+  const prompt = listprompts().find((candidate) => candidate.name === input.name);
+  if (prompt === void 0) return { reason: `The server exposes no prompt named ${input.name}.` };
+  const args = input.args ?? {};
+  const findings = [];
+  const resolved = {};
+  for (const argument of prompt.arguments) {
+    const value = args[argument.name];
+    if (value === void 0 || value === null || typeof value === "string" && value.trim() === "") {
+      if (argument.default !== void 0) resolved[argument.name] = argument.default;
+      else if (argument.required === true) findings.push(`The prompt argument ${argument.name} is required and stays empty.`);
+      else resolved[argument.name] = "";
+    } else {
+      resolved[argument.name] = value;
+    }
+  }
+  if (findings.length > 0) return { reason: findings.join(" ") };
+  return { rendered: renderprompt(prompt, resolved), toolcall: { name: `prompts.${prompt.name}`, params: { prompt: prompt.name, arguments: resolved, rendered: renderprompt(prompt, resolved) } } };
+}
+function streamchunkof(input) {
+  return { callid: input.callid, seq: input.seq, content: input.content, done: input.done === true, at: input.now };
+}
+function chunkcontent(input) {
+  const size = input.size !== void 0 && Number.isFinite(input.size) && input.size > 0 ? Math.floor(input.size) : 80;
+  const parts = [];
+  for (let index = 0; index < input.content.length; index += size) parts.push(input.content.slice(index, index + size));
+  const slices = parts.length > 0 ? parts : [""];
+  return slices.map((content, index) => streamchunkof({ callid: input.callid, seq: index + 1, content, done: index === slices.length - 1, now: input.now + index }));
+}
+function notifyprogress(input) {
+  return { callid: input.callid, ...input.percent !== void 0 ? { percent: input.percent } : {}, message: input.message, cancellable: input.cancellable !== false, at: input.now };
+}
+function canceltool(input) {
+  const match = input.contexts.find((context2) => context2.callid === input.callid);
+  if (match === void 0) return { contexts: input.contexts, reason: `The cancellation frame names no call context ${input.callid}.` };
+  if (match.state !== "inflight") return { contexts: input.contexts, reason: `The call ${input.callid} already left the in flight state.` };
+  const context = { ...match, state: "cancelled", endedat: input.now, ...input.partial !== void 0 ? { partial: input.partial } : {} };
+  return { contexts: input.contexts.map((candidate) => candidate.callid === input.callid ? context : candidate), context };
+}
+
 // mcpserver.ts
 var localhostbind = "127.0.0.1";
 var defaultmcpport = 7436;
@@ -8707,7 +9131,10 @@ function servermethods() {
     { method: "ping", handler: "ping", description: "Answers keepalive frames with pong." },
     { method: "tools/list", handler: "listtools", description: "Returns every tool with its version and json schema inputs." },
     { method: "negotiate", handler: "negotiate", description: "Exchanges capability sets with the client." },
-    { method: "tools/call", handler: "dispatch", description: "Invokes one tool behind the consent gates." }
+    { method: "tools/call", handler: "dispatch", description: "Invokes one tool behind the consent gates." },
+    { method: "prompts/list", handler: "listprompts", description: "Lists the prompt defs the server exposes as callable tools." },
+    { method: "prompts/call", handler: "callprompt", description: "Renders one prompt and returns its arguments as a tool call." },
+    { method: "calls/cancel", handler: "cancel", description: "Aborts one in flight tool call and preserves its partial result." }
   ];
 }
 function servercapabilities(input) {
@@ -8792,6 +9219,22 @@ async function handleframe(input) {
     const outcome = negotiate({ ...clientcaps !== void 0 ? { client: clientcaps } : {}, server });
     return respond({ ...frame.id !== void 0 ? { id: frame.id } : {}, ...outcome.agreed ? { result: outcome.capabilities } : { error: rpcerrorof("params", outcome.mismatch ?? "The capability negotiation did not agree.") } });
   }
+  if (entry.handler === "listprompts") return respond({ ...frame.id !== void 0 ? { id: frame.id } : {}, result: { prompts: listprompts() } });
+  if (entry.handler === "callprompt") {
+    const name = typeof params?.name === "string" ? params.name : "";
+    const args = params?.arguments && typeof params.arguments === "object" && !Array.isArray(params.arguments) ? params.arguments : void 0;
+    const called = name === "" ? { reason: "The prompt call needs the prompt name." } : callprompt({ name, ...args !== void 0 ? { args } : {} });
+    if (called.toolcall === void 0) return respond({ ...frame.id !== void 0 ? { id: frame.id } : {}, error: rpcerrorof("params", called.reason ?? "The prompt call did not render.") });
+    return respond({ ...frame.id !== void 0 ? { id: frame.id } : {}, result: { toolcall: called.toolcall, rendered: called.rendered } });
+  }
+  if (entry.handler === "cancel") {
+    const callid = typeof params?.callid === "string" ? params.callid : "";
+    const reason = typeof params?.reason === "string" ? params.reason : void 0;
+    if (callid.trim() === "") return respond({ ...frame.id !== void 0 ? { id: frame.id } : {}, error: rpcerrorof("params", "The cancellation frame needs the call id it aborts.") });
+    const aborted = canceltool({ contexts: input.contexts ?? [], callid, ...reason !== void 0 ? { reason } : {}, now: input.now });
+    if (aborted.context === void 0) return respond({ ...frame.id !== void 0 ? { id: frame.id } : {}, error: rpcerrorof("params", aborted.reason ?? "The cancellation frame named no in flight tool call.") });
+    return respond({ ...frame.id !== void 0 ? { id: frame.id } : {}, result: { cancelled: true, callid, ...reason !== void 0 ? { reason } : {}, ...aborted.context.partial !== void 0 ? { partial: aborted.context.partial } : {} } });
+  }
   const dispatched = await dispatchtool({ ...params !== void 0 ? { params } : {}, client: input.client, catalog: input.catalog, ...input.session !== void 0 ? { session: input.session } : {}, ...input.plan !== void 0 ? { plan: input.plan } : {}, ...input.scopes !== void 0 ? { scopes: input.scopes } : {}, origin: input.origin, now: input.now, execute: input.execute });
   return respond({ ...frame.id !== void 0 ? { id: frame.id } : {}, ...dispatched.error !== void 0 ? { error: dispatched.error } : { result: dispatched.result } });
 }
@@ -8806,7 +9249,7 @@ function relayframe(input) {
   return { ...input.bridge, connected: true, received: input.bridge.received + (input.direction === "inbound" ? 1 : 0), sent: input.bridge.sent + (input.direction === "outbound" ? 1 : 0), lastframeat: input.now };
 }
 function toolcallevent(input) {
-  return { id: input.id, clientid: input.clientid, tool: input.tool, origin: input.origin, ok: input.ok, ...input.code !== void 0 ? { code: input.code } : {}, at: input.now };
+  return { id: input.id, clientid: input.clientid, tool: input.tool, origin: input.origin, ok: input.ok, ...input.code !== void 0 ? { code: input.code } : {}, at: input.now, ...input.callid !== void 0 ? { callid: input.callid } : {}, ...input.idempotencykey !== void 0 && input.idempotencykey.trim() !== "" ? { idempotencykey: input.idempotencykey } : {}, ...input.dryrun === true ? { dryrun: true } : {}, ...input.mocked === true ? { mocked: true } : {}, ...input.batchid !== void 0 ? { batchid: input.batchid } : {}, ...input.replayed === true ? { replayed: true } : {} };
 }
 
 // httpstream.ts
@@ -10477,6 +10920,451 @@ function yamlscalarvalue(text2) {
   return text2;
 }
 
+// toolcalls.ts
+var defaultidempotencywindowms = 3e5;
+function applyratelimit(input) {
+  const existing = input.limits.find((limit2) => limit2.clientid === input.clientid);
+  if (existing === void 0) return { allowed: true, used: 0, limits: input.limits };
+  const elapsed = input.now - existing.windowstartedat;
+  const limit = elapsed >= existing.windowms ? { ...existing, windowstartedat: input.now, used: 0 } : existing;
+  if (limit.budget !== void 0 && limit.used >= limit.budget) {
+    const retryafter = Math.max(0, limit.windowms - (input.now - limit.windowstartedat));
+    return { allowed: false, used: limit.used, budget: limit.budget, retryafter, limits: input.limits.map((candidate) => candidate.clientid === input.clientid ? limit : candidate) };
+  }
+  const counted = { ...limit, used: limit.used + 1 };
+  return { allowed: true, used: counted.used, ...counted.budget !== void 0 ? { budget: counted.budget } : {}, limit: counted, limits: input.limits.map((candidate) => candidate.clientid === input.clientid ? counted : candidate) };
+}
+function structurederrorof(input) {
+  return { code: input.code, message: input.message, retryhint: input.retryhint, ...input.retryafter !== void 0 ? { retryafter: input.retryafter } : {} };
+}
+function retryhintof(failure) {
+  const text2 = `${failure.code ?? ""} ${failure.message ?? ""}`.toLowerCase();
+  if (text2.includes("consent") || text2.includes("refus") || text2.includes("unpaired") || text2.includes("unapproved") || text2.includes("grant")) return "none";
+  if (text2.includes("rate") || text2.includes("busy") || text2.includes("queue") || text2.includes("window")) return "wait";
+  if (text2.includes("timeout") || text2.includes("timed out") || text2.includes("internal") || text2.includes("network")) return "retry";
+  return "none";
+}
+function checkidempotency(input) {
+  const match = input.records.find((record2) => record2.key === input.key);
+  if (match === void 0) return { reason: "The idempotency key names no stored record." };
+  if (match.clientid !== input.clientid) return { reason: "The idempotency key belongs to another client and never replays across clients." };
+  if (input.now >= match.expiresat) return { reason: "The idempotency record expired past its window and the call runs again." };
+  return { replay: match.result, record: match };
+}
+function recordidempotency(input) {
+  const record2 = { key: input.key, clientid: input.clientid, tool: input.tool, result: input.result, createdat: input.now, expiresat: input.now + (input.window ?? defaultidempotencywindowms) };
+  return [record2, ...input.records.filter((candidate) => !(candidate.key === input.key && candidate.clientid === input.clientid))];
+}
+function expireidempotency(records, now) {
+  return records.filter((record2) => now < record2.expiresat);
+}
+async function runbatch(input) {
+  const outcomes = [];
+  for (let index = 0; index < input.calls.length; index += 1) {
+    const call = input.calls[index];
+    if (call === void 0) continue;
+    const outcome = await input.execute(call, index);
+    outcomes.push({ callid: call.id, tool: call.name, ok: outcome.ok, ...outcome.result !== void 0 ? { result: outcome.result } : {}, ...outcome.error !== void 0 ? { error: outcome.error } : {}, at: input.now + index });
+    if (!outcome.ok && input.stoponerror) return { outcomes, stoppedat: call.id };
+  }
+  return { outcomes };
+}
+function dryruntool(input) {
+  const findings = [];
+  for (const required of input.tool.inputschema.required) {
+    const value = input.params[required];
+    if (value === void 0 || value === null || typeof value === "string" && value.trim() === "") findings.push(`The required argument ${required} of ${input.tool.name} stays empty.`);
+  }
+  for (const [name, property] of Object.entries(input.tool.inputschema.properties)) {
+    const value = input.params[name];
+    if (value === void 0 || value === null) continue;
+    const expected = property.type;
+    const actual = Array.isArray(value) ? "array" : typeof value;
+    if (actual !== expected) findings.push(`The argument ${name} of ${input.tool.name} carries a ${actual} value where the schema asks a ${expected}.`);
+  }
+  const stepid = input.stepid !== void 0 ? input.stepid : typeof input.params.stepid === "string" ? input.params.stepid : void 0;
+  const gate = tooldispatchgate({ client: input.client, tool: input.tool, session: input.session, plan: input.plan, origin: input.origin, ...stepid !== void 0 ? { stepid } : {}, now: input.now });
+  if (!gate.allowed) findings.push(gate.reason ?? `The consent gates refused the ${input.tool.name} dry run.`);
+  return { callid: input.callid ?? randomid(), tool: input.tool.name, argsvalid: findings.length === 0, consentok: gate.allowed, findings, executed: false, mutations: [], at: input.now };
+}
+function applymock(input) {
+  const mock = input.mocks.find((candidate) => candidate.tool === input.tool);
+  if (mock === void 0) return {};
+  if (mock.testcontext !== true) return { reason: `The ${input.tool} mock stays outside a test context and is refused; mocks never answer real calls.` };
+  return { result: mock.result };
+}
+function begincall(input) {
+  return { callid: input.callid ?? randomid(), clientid: input.clientid, tool: input.tool, state: "inflight", startedat: input.now, ...input.idempotencykey !== void 0 && input.idempotencykey.trim() !== "" ? { idempotencykey: input.idempotencykey } : {}, ...input.dryrun === true ? { dryrun: true } : {}, ...input.batchid !== void 0 ? { batchid: input.batchid } : {}, chunks: 0 };
+}
+function endcall(input) {
+  const match = input.contexts.find((context2) => context2.callid === input.callid);
+  if (match === void 0) return { contexts: input.contexts, reason: `The call context ${input.callid} never opened.` };
+  if (match.state !== "inflight") return { contexts: input.contexts, context: match };
+  const context = { ...match, state: input.ok ? "done" : "failed", endedat: input.now, ...input.errorcode !== void 0 ? { errorcode: input.errorcode } : {}, ...input.partial !== void 0 ? { partial: input.partial } : {} };
+  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);
@@ -15024,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;
@@ -15667,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));
@@ -16922,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();
@@ -18690,6 +19578,122 @@ async function handlerequest(message, sender) {
       }
       return mcpstateof();
     }
+    case "mcpsubscribe": {
+      const inputsub = message;
+      const clientid = inputsub.clientid?.trim() ?? "";
+      if (clientid === "") throw new Error("The event subscription needs the paired client.");
+      const now = Date.now();
+      if (inputsub.unsubscribe === true) {
+        const subscriptionid = inputsub.subscriptionid?.trim() ?? "";
+        if (subscriptionid === "") throw new Error("The unsubscribe needs the subscription id.");
+        await memory.seteventsubscriptions(unsubscriberegister(await memory.geteventsubscriptions(), subscriptionid, now));
+        await audit("protocol", `The user cancelled the event subscription ${subscriptionid} of the client ${clientid}; the record stays for the audit trail.`, {});
+        return mcpstateof();
+      }
+      const registered = subscriberegister({ clientid, ...Array.isArray(inputsub.kinds) ? { kinds: inputsub.kinds } : {}, ...inputsub.origin !== void 0 && inputsub.origin.trim() !== "" ? { origin: inputsub.origin.trim() } : {}, ...inputsub.tool !== void 0 && inputsub.tool.trim() !== "" ? { tool: inputsub.tool.trim() } : {}, now });
+      if (registered.subscription === void 0) throw new Error(registered.reason ?? "The event subscription did not register.");
+      const grade = subscriptiongrade(registered.subscription);
+      if (!grade.allowed) throw new Error(grade.reason ?? "The event subscription failed its gate.");
+      await memory.seteventsubscriptions([registered.subscription, ...await memory.geteventsubscriptions()]);
+      await audit("protocol", `The user subscribed the client ${clientid} to the ${registered.subscription.kinds.join(", ")} event kinds${registered.subscription.origin !== void 0 ? ` of the origin ${registered.subscription.origin}` : ""}${registered.subscription.tool !== void 0 ? ` for the tool ${registered.subscription.tool}` : ""}.`, {});
+      return mcpstateof();
+    }
+    case "mcpresource": {
+      const inputwatch = message;
+      const clientid = inputwatch.clientid?.trim() ?? "";
+      if (clientid === "") throw new Error("The resource watcher needs the paired client.");
+      const now = Date.now();
+      if (inputwatch.unwatch === true) {
+        const watchid = inputwatch.watchid?.trim() ?? "";
+        if (watchid === "") throw new Error("The unwatch needs the watcher id.");
+        await memory.setresourcewatches(unwatchresource(await memory.getresourcewatches(), watchid, now));
+        await audit("protocol", `The user cancelled the resource watcher ${watchid} of the client ${clientid}; the record stays for the audit trail.`, {});
+        return mcpstateof();
+      }
+      const watched = watchresource({ clientid, resource: inputwatch.resource?.trim() ?? "", ...inputwatch.state !== void 0 ? { state: inputwatch.state } : {}, now });
+      if (watched.watch === void 0) throw new Error(watched.reason ?? "The resource watcher did not start.");
+      await memory.setresourcewatches([watched.watch, ...await memory.getresourcewatches()]);
+      await audit("protocol", `The user started the ${watched.watch.resource} resource watcher for the client ${clientid} with its page state baseline; the deltas compare against it.`, {});
+      return mcpstateof();
+    }
+    case "mcpsampling": {
+      const inputsample = message;
+      const now = Date.now();
+      if (inputsample.respond === true) {
+        const samplingid = inputsample.samplingid?.trim() ?? "";
+        if (samplingid === "") throw new Error("The sampling answer needs the request id.");
+        const outcome = answersampling({ requests: await memory.getsamplingrequests(), id: samplingid, ...inputsample.answer !== void 0 ? { answer: inputsample.answer } : {}, ...inputsample.refused === true ? { refused: true } : {}, now });
+        if (outcome.request === void 0) throw new Error(outcome.reason ?? "The sampling answer closed no request.");
+        await memory.setsamplingrequests(outcome.requests);
+        await audit("protocol", `The sampling callback ${samplingid} of the client ${outcome.request.clientid} closed its round trip with the client answer; the provenance times ride the record.`, {});
+        return mcpstateof();
+      }
+      const clientid = inputsample.clientid?.trim() ?? "";
+      if (clientid === "") throw new Error("The sampling callback needs the paired client it addresses.");
+      const client = (await memory.getclients()).find((entry) => entry.id === clientid);
+      const requested = requestsampling({ clientid, ...client?.capabilities !== void 0 ? { capabilities: client.capabilities } : {}, prompt: inputsample.prompt ?? "", ...inputsample.system !== void 0 ? { system: inputsample.system } : {}, ...inputsample.pagecontent !== void 0 ? { pagecontent: inputsample.pagecontent } : {}, pagegrant: inputsample.pagegrant === true, ...inputsample.maxtokens !== void 0 ? { maxtokens: inputsample.maxtokens } : {}, now });
+      if (requested.request === void 0) throw new Error(requested.reason ?? "The sampling callback was refused.");
+      await memory.setsamplingrequests([requested.request, ...await memory.getsamplingrequests()]);
+      await audit("protocol", `The user sent one sampling callback to the client ${clientid}: the prompt leaves the browser${requested.request.pagecontent !== void 0 ? " with the page content the user granted" : " with the page content stripped because the user granted none"}, and the exact payload rides the panel.`, {});
+      return mcpstateof();
+    }
+    case "mcpcancelcall": {
+      const inputcancel = message;
+      const callid = inputcancel.callid?.trim() ?? "";
+      if (callid === "") throw new Error("The cancellation needs the call id.");
+      const now = Date.now();
+      const contexts = await memory.getcallcontexts();
+      const chunks = (await memory.getstreamchunks()).filter((chunk) => chunk.callid === callid);
+      const partial = chunks.length > 0 ? { content: chunks.map((chunk) => chunk.content).join(""), iserror: false } : void 0;
+      const aborted = canceltool({ contexts, callid, ...inputcancel.reason !== void 0 ? { reason: inputcancel.reason } : {}, ...partial !== void 0 ? { partial } : {}, now });
+      if (aborted.context === void 0) throw new Error(aborted.reason ?? "The cancellation named no in flight call.");
+      await memory.setcallcontexts(aborted.contexts);
+      await audit("protocol", `The user cancelled the in flight ${aborted.context.tool} call ${callid}${partial !== void 0 ? " with its partial result preserved" : ""}; the cooperative flag stops the page executor and the workflow engine keeps its own pause machinery.`, {});
+      return mcpstateof();
+    }
+    case "mcpmock": {
+      const inputmock = message;
+      const toolname = inputmock.tool?.trim() ?? "";
+      if (toolname === "") throw new Error("The tool mock needs the namespaced tool it stands in for.");
+      const now = Date.now();
+      if (inputmock.remove === true) {
+        await memory.removetoolmock(toolname);
+        await audit("protocol", `The user removed the ${toolname} tool mock; the tool returns to the real gates.`, {});
+        return mcpstateof();
+      }
+      if (resolvetool(buildtoolcatalog(), toolname) === void 0) throw new Error(`The catalog holds no unambiguous tool named ${toolname}.`);
+      const mock = { tool: toolname, result: { content: inputmock.content ?? `The ${toolname} mock answered from the test context.`, iserror: false }, testcontext: true, createdat: now };
+      const valid = mockusagevalid(mock);
+      if (!valid.allowed) throw new Error(valid.reason ?? "The tool mock failed its validation.");
+      await memory.settoolmock(mock);
+      await audit("protocol", `The user registered the ${toolname} tool mock of a test context; mocks answer with canned results and never touch the browser.`, {});
+      return mcpstateof();
+    }
+    case "mcpratelimit": {
+      const inputlimit = message;
+      const clientid = inputlimit.clientid?.trim() ?? "";
+      if (clientid === "") throw new Error("The per client rate limit needs the client it counts.");
+      const now = Date.now();
+      const limits = (await memory.getcallratelimits()).filter((limit2) => limit2.clientid !== clientid);
+      if (inputlimit.remove === true) {
+        await memory.setcallratelimits(limits);
+        await audit("protocol", `The user removed the rate limit of the client ${clientid}; the client stays unbounded because no silent default applies.`, {});
+        return mcpstateof();
+      }
+      const limit = { clientid, windowms: inputlimit.windowms ?? 6e4, ...inputlimit.budget !== void 0 ? { budget: inputlimit.budget } : {}, windowstartedat: now, used: 0 };
+      const valid = callratelimitvalid(limit);
+      if (!valid.allowed) throw new Error(valid.reason ?? "The rate limit failed its validation.");
+      await memory.setcallratelimits([limit, ...limits]);
+      await audit("protocol", `The user limited the client ${clientid} to ${limit.budget !== void 0 ? `${limit.budget} call${limit.budget === 1 ? "" : "s"} per ${limit.windowms} millisecond window` : `a ${limit.windowms} millisecond window with no call budget`}; every value stays the user choice.`, {});
+      return mcpstateof();
+    }
+    case "mcpdryrun": {
+      const inputdry = message;
+      const enabled = inputdry.enabled === true;
+      await memory.setdryruntoggle(enabled);
+      await audit("protocol", `The user ${enabled ? "armed the tool dry run of the next call: it evaluates arguments and consent with no side effects" : "disarmed the tool dry run; the next call executes behind the gates"}.`, {});
+      return mcpstateof();
+    }
     case "runtobreakpoint": {
       const inputdebug = message;
       const session = await memory.getsession();
@@ -18950,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.");
   }
@@ -19056,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();
@@ -19067,7 +20439,23 @@ async function mcpstateof() {
   const channels = closeidlechannels({ channels: await memory.getstreamchannels(), now, ...config.httpstream?.idlewindowms !== void 0 ? { idlewindow: config.httpstream.idlewindowms } : {} });
   await memory.setstreamchannels(channels);
   const streamstatus = listremotestatus;
-  return { state: state?.state ?? "stopped", config, bind: binding.bind, port: binding.port, localhost: binding.localhost, clients, ...state?.bridge !== void 0 ? { bridge: state.bridge } : {}, calls: (await memory.listtoolcalls()).slice(0, 25), catalog: listtools(buildtoolcatalog()), launches: (await memory.listbridgelaunches()).slice(0, 10), remote: streamstatus({ config, channels, clients, tokens, now }), pairing: (await memory.getpairingcodes()).filter((code) => code.usedat === void 0 && now < code.expiresat), allowlist: await memory.getallowlist(), tokens, identities: await memory.getclientidentities(), handshakes: (await memory.listauthhandshakes()).slice(0, 10), channels, approvals: await memory.listapprovals() };
+  const watches = await pushresourcestate(now);
+  const contexts = await memory.getcallcontexts();
+  const dryruntoggle = await memory.getdryruntoggle();
+  return { state: state?.state ?? "stopped", config, bind: binding.bind, port: binding.port, localhost: binding.localhost, clients, ...state?.bridge !== void 0 ? { bridge: state.bridge } : {}, calls: (await memory.listtoolcalls()).slice(0, 25), calllog: await memory.getcalllog({ limit: 25 }), catalog: listtools(buildtoolcatalog()), launches: (await memory.listbridgelaunches()).slice(0, 10), remote: streamstatus({ config, channels, clients, tokens, now }), pairing: (await memory.getpairingcodes()).filter((code) => code.usedat === void 0 && now < code.expiresat), allowlist: await memory.getallowlist(), tokens, identities: await memory.getclientidentities(), handshakes: (await memory.listauthhandshakes()).slice(0, 10), channels, approvals: await memory.listapprovals(), subscriptions: (await memory.geteventsubscriptions()).filter((subscription) => subscription.canceledat === void 0), watches: watches.filter((watch) => watch.canceledat === void 0), sampling: (await memory.getsamplingrequests()).slice(0, 10), limits: await memory.getcallratelimits(), contexts: contexts.slice(0, 25), inflight: contexts.filter((context) => context.state === "inflight"), batches: (await memory.getbatchcalls()).slice(0, 10), chunks: (await memory.getstreamchunks()).slice(0, 25), progressnotices: (await memory.getprogressnotices()).slice(0, 25), mocks: await memory.gettoolmocks(), dryruntoggle, idempotency: expireidempotency(await memory.getidempotencyrecords(), now) };
+}
+async function pushresourcestate(now) {
+  const watches = await memory.getresourcewatches();
+  const active = watches.filter((watch) => watch.canceledat === void 0);
+  if (active.length === 0) return watches;
+  const session = await memory.getsession();
+  const state = { origin: session?.origin ?? "", mutations: (await memory.getmutationevents()).length, diffs: (await memory.getdiffs()).length };
+  const pushed = notifyresource({ watches, resource: "page", state, now });
+  if (pushed.deliveries.length > 0) {
+    await memory.setresourcewatches(pushed.watches);
+    await audit("protocol", `${pushed.deliveries.length} page state delta${pushed.deliveries.length === 1 ? "" : "s"} reached the resource watcher${pushed.deliveries.length === 1 ? "" : "s"} of ${[...new Set(pushed.deliveries.map((delivery) => delivery.clientid))].join(", ")}; the baselines absorbed the new page state.`, {});
+  }
+  return pushed.watches;
 }
 async function mcpmaintenance(now) {
   const tokens = await memory.getsessiontokens();
@@ -19076,6 +20464,12 @@ async function mcpmaintenance(now) {
     await memory.setsessiontokens(tokens.map((token) => expired.includes(token) ? { ...token, revokedat: now } : token));
     await audit("protocol", `${expired.length} session token${expired.length === 1 ? "" : "s"} reached the user configured lifetime and the server refused ${expired.length === 1 ? "it" : "them"}; the records stay for the audit trail.`, {});
   }
+  const storedrecords = await memory.getidempotencyrecords();
+  const liverecords = expireidempotency(storedrecords, now);
+  if (liverecords.length !== storedrecords.length) {
+    await memory.setidempotencyrecords(liverecords);
+    await audit("protocol", `${storedrecords.length - liverecords.length} idempotency record${storedrecords.length - liverecords.length === 1 ? "" : "s"} expired past the user configured window and the key${storedrecords.length - liverecords.length === 1 ? " never replays" : "s never replay"}.`, {});
+  }
   const stored = await memory.listapprovals();
   const approvals = expireapprovals(stored, now);
   for (let index = 0; index < approvals.length; index += 1) {
@@ -19148,14 +20542,13 @@ async function trybridgelaunch(restart) {
 function restartbridgeof(bridge) {
   return { ...bridge, connected: true, restarts: bridge.restarts + 1, startedat: Date.now() };
 }
+var mcpcancelledcalls = /* @__PURE__ */ new Set();
 async function routemcpframe(client, frame, config, scopes) {
   const session = await memory.getsession();
   const plan = await memory.getplan();
   const catalog = buildtoolcatalog();
-  const calledtool = frame.method === "tools/call" && typeof frame.params?.name === "string" ? resolvetool(catalog, frame.params.name.trim()) : void 0;
-  const gatedname = client.transport === "http" && calledtool !== void 0 && calledtool.risk !== "read" ? calledtool.name : void 0;
-  const callparams = frame.params ?? {};
-  const response = await handleframe({ frame, client, catalog, config, ...session !== void 0 ? { session } : {}, ...plan !== void 0 ? { plan } : {}, ...scopes !== void 0 ? { scopes } : {}, origin: session?.origin ?? "", tabid: session?.tabid ?? 0, now: Date.now(), execute: gatedname !== void 0 ? (step) => raiseremoteapproval(client.id, gatedname, callparams, step) : executemcpstep });
+  if (frame.method === "tools/call") return await routetoolcall(client, frame, config, scopes, session, plan, catalog);
+  const response = await handleframe({ frame, client, catalog, config, ...session !== void 0 ? { session } : {}, ...plan !== void 0 ? { plan } : {}, ...scopes !== void 0 ? { scopes } : {}, origin: session?.origin ?? "", tabid: session?.tabid ?? 0, now: Date.now(), execute: executemcpstep });
   const now = Date.now();
   if (frame.method === "initialize") {
     const clientinfo = frame.params?.clientinfo && typeof frame.params.clientinfo === "object" && !Array.isArray(frame.params.clientinfo) ? frame.params.clientinfo : void 0;
@@ -19181,19 +20574,187 @@ async function routemcpframe(client, frame, config, scopes) {
     }
     await audit("protocol", `The mcp client ${client.id} ${agreed ? "negotiated its capability set with the server and the negotiated floor stays stored on its record" : `failed the capability negotiation: ${response.error?.message ?? "the sets did not agree"}`}.`, {});
   }
-  if (frame.method === "tools/call") {
-    const name = typeof frame.params?.name === "string" ? frame.params.name : "";
-    const code = response.error?.code;
-    const ok = response.error === void 0 && response.result?.iserror !== true;
-    await memory.addtoolcall(toolcallevent({ id: randomid(), clientid: client.id, tool: name, origin: session?.origin ?? "", ok, now, ...code !== void 0 ? { code } : {} }));
-    if (plan !== void 0) {
-      const stepid = typeof frame.params?.stepid === "string" ? frame.params.stepid : "mcp";
-      await memory.setprogress(recordtoolcall(await memory.getprogress(), plan.id, stepid, { clientid: client.id, tool: name, ok, ...code !== void 0 ? { code } : {} }, now));
-    }
-    await audit("tool", `The mcp client ${client.id} called the ${name} tool on ${session?.origin ?? "no origin"} and ${ok ? gatedname !== void 0 ? "its approval gate waits for the user decision" : "it ran behind the consent gates" : `it was refused${code !== void 0 ? ` with the ${code} error` : ""}`}; no payload rides the record.`, {});
-  }
   return response;
 }
+async function routetoolcall(client, frame, config, scopes, session, plan, catalog) {
+  const now = Date.now();
+  const params = frame.params ?? {};
+  const name = typeof params.name === "string" ? params.name : "";
+  const origin = session?.origin ?? "";
+  const answerframe = (result2, error) => ({ jsonrpc: "2.0", ...frame.id !== void 0 ? { id: frame.id } : error !== void 0 ? { id: null } : {}, ...error !== void 0 ? { error: { code: error.code, message: error.message, ...error.data !== void 0 ? { data: error.data } : {} } } : { result: result2 } });
+  const refuse = async (code, message, data) => {
+    await memory.addtoolcall(toolcallevent({ id: randomid(), clientid: client.id, tool: name, origin, ok: false, now: Date.now(), code }));
+    await audit("tool", `The mcp client ${client.id} called the ${name} tool on ${origin || "no origin"} and was refused with the ${code} error; no payload rides the record.`, {});
+    return answerframe(void 0, { code, message, ...data !== void 0 ? { data } : {} });
+  };
+  const counted = applyratelimit({ limits: await memory.getcallratelimits(), clientid: client.id, now });
+  await memory.setcallratelimits(counted.limits);
+  if (!counted.allowed) {
+    const error = structurederrorof({ code: "ratelimited", message: `The client ${client.id} spent its user configured call budget of ${counted.budget ?? 0} inside the window.`, retryhint: "wait", ...counted.retryafter !== void 0 ? { retryafter: counted.retryafter } : {} });
+    await audit("protocol", `The per client rate limit refused the ${name} call of the client ${client.id}: the budget of ${counted.budget ?? 0} calls is spent and the retry hint waits ${counted.retryafter ?? 0} milliseconds.`, {});
+    return refuse("consentrefused", `${error.message} Retry: wait${error.retryafter !== void 0 ? ` after ${error.retryafter} milliseconds` : ""}.`, { retryhint: error.retryhint, ...error.retryafter !== void 0 ? { retryafter: error.retryafter } : {} });
+  }
+  const key = typeof params.idempotencykey === "string" && params.idempotencykey.trim() !== "" ? params.idempotencykey.trim() : void 0;
+  if (key !== void 0) {
+    const replay = checkidempotency({ records: await memory.getidempotencyrecords(), key, clientid: client.id, now });
+    if (replay.replay !== void 0 && replay.record !== void 0) {
+      await memory.addtoolcall(toolcallevent({ id: randomid(), clientid: client.id, tool: name, origin, ok: !replay.replay.iserror, now: Date.now(), idempotencykey: key, replayed: true }));
+      await audit("tool", `The mcp client ${client.id} repeated the idempotency key of the ${name} call and the server replayed the stored result instead of executing; no payload rides the record.`, {});
+      return answerframe({ ...replay.replay, replayed: true, idempotencykey: key, originalat: replay.record.createdat });
+    }
+  }
+  const tool = name !== "" ? resolvetool(catalog, name) : void 0;
+  const mock = tool !== void 0 ? applymock({ mocks: await memory.gettoolmocks(), tool: tool.name }) : void 0;
+  if (mock?.result !== void 0) {
+    await memory.addtoolcall(toolcallevent({ id: randomid(), clientid: client.id, tool: name, origin, ok: !mock.result.iserror, now: Date.now(), mocked: true }));
+    await audit("tool", `A tool mock of a test context answered the ${name} call of the client ${client.id} with its canned result; the browser was never touched.`, {});
+    return answerframe({ ...mock.result, mocked: true });
+  }
+  if (mock?.reason !== void 0) return await refuse("consentrefused", mock.reason);
+  let dryrun = params.dryrun === true;
+  if (!dryrun && await memory.getdryruntoggle()) {
+    dryrun = true;
+    await memory.setdryruntoggle(false);
+  }
+  if (dryrun && tool !== void 0) {
+    const dry = dryruntool({ tool, params, client, ...session !== void 0 ? { session } : {}, ...plan !== void 0 ? { plan } : {}, origin, now });
+    await memory.addtoolcall(toolcallevent({ id: randomid(), clientid: client.id, tool: name, origin, ok: dry.argsvalid && dry.consentok, now: Date.now(), dryrun: true }));
+    await audit("tool", `The mcp client ${client.id} dry ran the ${name} tool: ${dry.findings.length} finding${dry.findings.length === 1 ? "" : "s"} and no page mutation because a dry run never executes anything.`, {});
+    return answerframe({ content: `The ${name} dry run found ${dry.findings.length} issue${dry.findings.length === 1 ? "" : "s"}.`, payload: { dryrun: dry }, iserror: false });
+  }
+  const context = begincall({ clientid: client.id, tool: name, ...key !== void 0 ? { idempotencykey: key } : {}, now });
+  await memory.setcallcontexts([context, ...await memory.getcallcontexts()]);
+  const started = notifyevent({ subscriptions: await memory.geteventsubscriptions(), kind: "callstarted", ...origin !== "" ? { origin } : {}, ...name !== "" ? { tool: name } : {}, payload: { callid: context.callid, clientid: client.id }, now });
+  await memory.seteventsubscriptions(started.subscriptions);
+  const notice = notifyprogress({ callid: context.callid, percent: 10, message: `The ${name} call started behind the consent gates.`, now });
+  await memory.addprogressnotice(notice);
+  const progressed = notifyevent({ subscriptions: started.subscriptions, kind: "progress", ...origin !== "" ? { origin } : {}, ...name !== "" ? { tool: name } : {}, payload: { callid: notice.callid, percent: notice.percent, message: notice.message, cancellable: notice.cancellable }, now });
+  await memory.seteventsubscriptions(progressed.subscriptions);
+  const gatedname = client.transport === "http" && tool !== void 0 && tool.risk !== "read" ? tool.name : void 0;
+  const execute = gatedname !== void 0 ? (step) => raiseremoteapproval(client.id, gatedname, params, step) : async (step) => {
+    if (mcpcancelledcalls.has(context.callid)) throw new Error(`The ${name} call was cancelled before the page executor ran.`);
+    const result2 = await executemcpstep(step);
+    if (mcpcancelledcalls.has(context.callid)) throw new Error(`The ${name} call was cancelled in flight; the partial result stays preserved.`);
+    return result2;
+  };
+  const response = await handleframe({ frame, client, catalog, config, ...session !== void 0 ? { session } : {}, ...plan !== void 0 ? { plan } : {}, ...scopes !== void 0 ? { scopes } : {}, origin, tabid: session?.tabid ?? 0, now: Date.now(), contexts: await memory.getcallcontexts(), execute });
+  const after = Date.now();
+  const ok = response.error === void 0 && (response.result?.iserror ?? true) !== true;
+  const result = response.error === void 0 ? response.result : void 0;
+  const closed = endcall({ contexts: await memory.getcallcontexts(), callid: context.callid, ok, ...response.error !== void 0 ? { errorcode: response.error.code } : {}, ...result !== void 0 ? { partial: result } : {}, now: after });
+  if (closed.contexts !== void 0) await memory.setcallcontexts(closed.contexts);
+  if (result !== void 0 && typeof result.content === "string" && result.content.length > 0) {
+    const chunks = chunkcontent({ callid: context.callid, content: result.content, now: after });
+    for (const chunk of chunks) await memory.addstreamchunk(chunk);
+    const streamed = notifyevent({ subscriptions: await memory.geteventsubscriptions(), kind: "streamchunk", ...origin !== "" ? { origin } : {}, ...name !== "" ? { tool: name } : {}, payload: { callid: context.callid, chunks: chunks.length, done: true }, now: after });
+    await memory.seteventsubscriptions(streamed.subscriptions);
+  }
+  const finished = notifyevent({ subscriptions: await memory.geteventsubscriptions(), kind: "callresult", ...origin !== "" ? { origin } : {}, ...name !== "" ? { tool: name } : {}, payload: { callid: context.callid, ok }, now: after });
+  await memory.seteventsubscriptions(finished.subscriptions);
+  if (key !== void 0 && result !== void 0 && !result.iserror) await memory.setidempotencyrecords(recordidempotency({ records: await memory.getidempotencyrecords(), key, clientid: client.id, tool: name, result, now: after }));
+  await memory.addtoolcall(toolcallevent({ id: randomid(), clientid: client.id, tool: name, origin, ok, now: after, ...response.error !== void 0 ? { code: response.error.code } : {}, callid: context.callid, ...key !== void 0 ? { idempotencykey: key } : {} }));
+  if (plan !== void 0) {
+    const stepid = typeof params.stepid === "string" ? params.stepid : "mcp";
+    await memory.setprogress(recordtoolcall(await memory.getprogress(), plan.id, stepid, { clientid: client.id, tool: name, ok, ...response.error !== void 0 ? { code: response.error.code } : {} }, after));
+  }
+  await audit("tool", `The mcp client ${client.id} called the ${name} tool on ${origin || "no origin"} and ${ok ? gatedname !== void 0 ? "its approval gate waits for the user decision" : `it ran behind the consent gates as the call ${context.callid}` : `it was refused${response.error !== void 0 ? ` with the ${response.error.code} error` : ""}`}${key !== void 0 ? " under its idempotency key" : ""}; no payload rides the record.`, {});
+  return response;
+}
+async function routeprotocolframe(client, frame, config, scopes) {
+  void config;
+  void scopes;
+  const params = frame.params ?? {};
+  const now = Date.now();
+  const answerframe = (result, error) => ({ jsonrpc: "2.0", ...frame.id !== void 0 ? { id: frame.id } : error !== void 0 ? { id: null } : {}, ...error !== void 0 ? { error: { code: error.code, message: error.message } } : { result } });
+  if (frame.method === "events/subscribe") {
+    const kinds = Array.isArray(params.kinds) ? params.kinds.filter((kind) => typeof kind === "string") : void 0;
+    const registered = subscriberegister({ clientid: client.id, ...kinds !== void 0 ? { kinds } : {}, ...typeof params.origin === "string" && params.origin.trim() !== "" ? { origin: params.origin.trim() } : {}, ...typeof params.tool === "string" && params.tool.trim() !== "" ? { tool: params.tool.trim() } : {}, now });
+    if (registered.subscription === void 0) return answerframe(void 0, { code: "params", message: registered.reason ?? "The event subscription did not register." });
+    const grade = subscriptiongrade(registered.subscription);
+    if (!grade.allowed) return answerframe(void 0, { code: "consentrefused", message: grade.reason ?? "The event subscription failed its gate." });
+    await memory.seteventsubscriptions([registered.subscription, ...await memory.geteventsubscriptions()]);
+    await audit("protocol", `The client ${client.id} subscribed to the ${registered.subscription.kinds.join(", ")} event kinds${registered.subscription.origin !== void 0 ? ` of the origin ${registered.subscription.origin}` : ""}${registered.subscription.tool !== void 0 ? ` for the tool ${registered.subscription.tool}` : ""}; the subscription grades read only.`, {});
+    return answerframe({ subscriptionid: registered.subscription.id, kinds: registered.subscription.kinds });
+  }
+  if (frame.method === "events/unsubscribe") {
+    const subscriptionid = typeof params.subscriptionid === "string" ? params.subscriptionid : "";
+    await memory.seteventsubscriptions(unsubscriberegister(await memory.geteventsubscriptions(), subscriptionid, now));
+    await audit("protocol", `The client ${client.id} cancelled its event subscription ${subscriptionid}; the record stays for the audit trail.`, {});
+    return answerframe({ unsubscribed: true, subscriptionid });
+  }
+  if (frame.method === "resources/watch") {
+    const resource = typeof params.resource === "string" ? params.resource.trim() : "";
+    const state = params.state !== void 0 && typeof params.state === "object" && !Array.isArray(params.state) ? params.state : void 0;
+    const watched = watchresource({ clientid: client.id, resource, ...state !== void 0 ? { state } : {}, now });
+    if (watched.watch === void 0) return answerframe(void 0, { code: "params", message: watched.reason ?? "The resource watcher did not start." });
+    await memory.setresourcewatches([watched.watch, ...await memory.getresourcewatches()]);
+    await audit("protocol", `The client ${client.id} started the ${watched.watch.resource} resource watcher with its page state baseline; the deltas compare against it.`, {});
+    return answerframe({ watchid: watched.watch.id, resource: watched.watch.resource });
+  }
+  if (frame.method === "resources/unwatch") {
+    const watchid = typeof params.watchid === "string" ? params.watchid : "";
+    await memory.setresourcewatches(unwatchresource(await memory.getresourcewatches(), watchid, now));
+    await audit("protocol", `The client ${client.id} cancelled its resource watcher ${watchid}; the record stays for the audit trail.`, {});
+    return answerframe({ unwatched: true, watchid });
+  }
+  if (frame.method === "sampling/answer") {
+    const samplingid = typeof params.samplingid === "string" ? params.samplingid : "";
+    const clientanswer = typeof params.answer === "string" ? params.answer : void 0;
+    const outcome = answersampling({ requests: await memory.getsamplingrequests(), id: samplingid, ...clientanswer !== void 0 ? { answer: clientanswer } : {}, ...params.refused === true ? { refused: true } : {}, now });
+    if (outcome.request === void 0) return answerframe(void 0, { code: "params", message: outcome.reason ?? "The sampling answer closed no request." });
+    await memory.setsamplingrequests(outcome.requests);
+    await audit("protocol", `The sampling callback ${samplingid} of the client ${client.id} closed its round trip with the client answer; the provenance times ride the record.`, {});
+    return answerframe({ samplingid, state: outcome.request.state });
+  }
+  if (frame.method === "calls/cancel") {
+    const callid = typeof params.callid === "string" ? params.callid : "";
+    const reason = typeof params.reason === "string" ? params.reason : void 0;
+    if (callid.trim() === "") return answerframe(void 0, { code: "params", message: "The cancellation frame needs the call id it aborts." });
+    const chunks = (await memory.getstreamchunks()).filter((chunk) => chunk.callid === callid);
+    const partial = chunks.length > 0 ? { content: chunks.map((chunk) => chunk.content).join(""), iserror: false } : void 0;
+    const aborted = canceltool({ contexts: await memory.getcallcontexts(), callid, ...reason !== void 0 ? { reason } : {}, ...partial !== void 0 ? { partial } : {}, now });
+    if (aborted.context === void 0) return answerframe(void 0, { code: "params", message: aborted.reason ?? "The cancellation frame named no in flight tool call." });
+    await memory.setcallcontexts(aborted.contexts);
+    mcpcancelledcalls.add(callid);
+    const cancelled = notifyevent({ subscriptions: await memory.geteventsubscriptions(), kind: "cancellation", payload: { callid, reason: reason ?? "cancelled by the client" }, now });
+    await memory.seteventsubscriptions(cancelled.subscriptions);
+    await audit("protocol", `The client ${client.id} cancelled the in flight ${aborted.context.tool} call ${callid}${partial !== void 0 ? " with its partial result preserved" : ""}; the cooperative flag stops the page executor between chunks and the workflow engine keeps its own pause machinery.`, {});
+    return answerframe({ cancelled: true, callid, ...aborted.context.partial !== void 0 ? { partial: aborted.context.partial } : {} });
+  }
+  if (frame.method === "calls/batch") {
+    const members = (Array.isArray(params.calls) ? params.calls : []).filter((entry) => entry !== null && typeof entry === "object" && !Array.isArray(entry)).map((entry, index) => ({ id: typeof entry.id === "string" && entry.id.trim() !== "" ? entry.id.trim() : `member-${index + 1}`, name: typeof entry.name === "string" ? entry.name : "", params: entry.params !== void 0 && typeof entry.params === "object" && !Array.isArray(entry.params) ? entry.params : {} }));
+    const stoponerror = params.stoponerror === true;
+    const session = await memory.getsession();
+    const plan = await memory.getplan();
+    const catalog = buildtoolcatalog();
+    const risks = members.map((member) => {
+      const tool = resolvetool(catalog, member.name);
+      return { risk: tool?.risk ?? "read" };
+    });
+    const approved = plan?.state === "approved" && members.every((member) => {
+      const tool = resolvetool(catalog, member.name);
+      return tool === void 0 || tool.risk === "read" || typeof member.params.stepid === "string" && plan.steps.some((step) => step.id === member.params.stepid);
+    });
+    const gate = batchgrade({ calls: risks, approved });
+    const batch = { id: randomid(), clientid: client.id, calls: members, stoponerror, state: gate.allowed ? "running" : "stopped", createdat: now, outcomes: [] };
+    await memory.setbatchcall(batch);
+    if (!gate.allowed) {
+      await audit("protocol", `The batch call of the client ${client.id} was refused: ${gate.reason ?? "the batch failed its grade."}`, {});
+      return answerframe(void 0, { code: "consentrefused", message: gate.reason ?? "The batch call failed its grade." });
+    }
+    const outcome = await runbatch({ calls: members, stoponerror, now, execute: async (member) => {
+      const response = await routemcpframe(client, { jsonrpc: "2.0", ...frame.id !== void 0 ? { id: frame.id } : {}, method: "tools/call", params: { ...member.params, name: member.name } }, config, scopes);
+      const ok = response.error === void 0 && (response.result?.iserror ?? true) !== true;
+      return { ok, ...response.result !== void 0 ? { result: response.result } : {}, ...response.error !== void 0 ? { error: structurederrorof({ code: response.error.code, message: response.error.message, retryhint: retryhintof({ code: response.error.code, message: response.error.message }) }) } : {} };
+    } });
+    const storedbatch = { ...batch, state: outcome.stoppedat !== void 0 ? "stopped" : "done", outcomes: outcome.outcomes, finishedat: Date.now() };
+    await memory.setbatchcall(storedbatch);
+    const ran = outcome.outcomes.filter((entry) => entry.ok).length;
+    await audit("protocol", `The client ${client.id} ran the batch ${batch.id} of ${members.length} ordered call${members.length === 1 ? "" : "s"}${outcome.stoppedat !== void 0 ? ` and stopped at the member ${outcome.stoppedat} on its first error as the flag requested` : ""}; ${ran} of ${members.length} members ran behind the gates.`, {});
+    return answerframe({ batchid: batch.id, state: storedbatch.state, stoponerror, outcomes: storedbatch.outcomes });
+  }
+  return void 0;
+}
 async function processmcpframe(raw, clientid, transport, rawtoken, fingerprint) {
   const state = await memory.getmcpstate();
   if (state?.state !== "running") return { jsonrpc: "2.0", id: null, error: rpcerrorof("consentrefused", "The mcp server is not running and no frame is routed.") };
@@ -19236,7 +20797,11 @@ async function processmcpframe(raw, clientid, transport, rawtoken, fingerprint)
     await audit("protocol", `A new mcp client ${client.id} connected on the ${transport} transport and waits for the pairing approval; unpaired clients never dispatch tools.`, {});
   }
   const previous = mcpclientchains.get(client.id) ?? Promise.resolve();
-  const task = previous.catch(() => void 0).then(async () => await routemcpframe(client, frame, config, scopes));
+  const task = previous.catch(() => void 0).then(async () => {
+    const protocol = await routeprotocolframe(client, frame, config, scopes);
+    if (protocol !== void 0) return protocol;
+    return await routemcpframe(client, frame, config, scopes);
+  });
   mcpclientchains.set(client.id, task);
   return task;
 }