@wenathlan/extension 1.1.55 → 1.1.57

package/dist/index.js

@@ -2544,6 +2544,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";
@@ -4662,12 +4880,6 @@ async function callgraphql(input) {
   }
 }
 
-// version.ts
-var packageversion = "1.1.55";
-
-// types.ts
-var protocolversion = packageversion;
-
 // socketbus.ts
 var socketkinds = ["opensocket", "sendmessage", "waitmessage", "subscribesse", "longpoll"];
 function channelorigin(url) {
@@ -7204,8 +7416,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(", ")}.` };
@@ -7798,8 +8010,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 };
@@ -7823,8 +8035,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") {
@@ -7861,8 +8073,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") {
@@ -7879,16 +8091,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") {
@@ -7896,8 +8108,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") {
@@ -8879,6 +9091,481 @@ function approvaltimeoutvalid(timeout) {
   if (timeout.ontimeout !== "refuse") return { allowed: false, reason: "The documented disposition of an unanswered approval gate is refusal." };
   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 localsensitivegrade(input) {
+  if (input.sensitive && !input.local) return { allowed: true, reason: "The sensitive extraction prefers the local model endpoint; the user keeps the choice of the remote provider." };
+  return { allowed: true, reason: input.local ? "The local model endpoint satisfies the sensitive extraction preference." : "The extraction stays non-sensitive and every configured endpoint serves it." };
+}
+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 guardverdictgate(output) {
+  if (output.verdict === "invalid") return { allowed: false, reason: output.reason ?? "The guardrails marked the model output invalid." };
+  if (output.verdict === "refused") return { allowed: false, reason: output.reason ?? "The model refused the request, so nothing executes." };
+  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;
+}
+
+// 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 } : {} });
+}
+function streamdelta(style, event) {
+  let parsed;
+  try {
+    parsed = JSON.parse(event);
+  } catch {
+    return "";
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return "";
+  const record2 = parsed;
+  if (style === "chatcompletions") {
+    const choice = Array.isArray(record2.choices) ? record2.choices[0] : void 0;
+    const delta = choice !== void 0 && choice.delta !== void 0 && typeof choice.delta === "object" ? choice.delta.content : void 0;
+    return typeof delta === "string" ? delta : "";
+  }
+  if (style === "responses") {
+    if (record2.type === "response.output_text.delta" && typeof record2.delta === "string") return record2.delta;
+    return "";
+  }
+  if (style === "messages") {
+    if (record2.type === "content_block_delta" && record2.delta !== void 0 && typeof record2.delta === "object" && typeof record2.delta.text === "string") return record2.delta.text;
+    return "";
+  }
+  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;
+  if (!Array.isArray(content)) return "";
+  const parts = [];
+  for (const part of content) {
+    if (part && typeof part === "object" && typeof part.text === "string") parts.push(part.text);
+  }
+  return parts.join("");
+}
+function parsestream(style, body) {
+  const tokens = [];
+  let seq = 0;
+  let done = false;
+  for (const line of body.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (trimmed === "") continue;
+    if (!trimmed.startsWith("data:")) continue;
+    const payload = trimmed.slice(5).trim();
+    if (payload === "[DONE]") {
+      done = true;
+      continue;
+    }
+    const text2 = streamdelta(style, payload);
+    if (text2 === "") continue;
+    seq += 1;
+    tokens.push({ seq, text: text2, done: false });
+  }
+  if (tokens.length > 0 && done) tokens[tokens.length - 1] = { ...tokens[tokens.length - 1], done: true };
+  return tokens;
+}
+async function streammodel(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 } : {}, 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 tokens = parsestream(input.provider.style, transport.body);
+  if (tokens.length === 0) return { text: transport.body, tokens: 0, request: shaped };
+  return { text: tokens.map((token) => token.text).join(""), tokens: tokens.length, request: shaped };
+}
+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 addusage(records, record2) {
+  return [record2, ...records];
+}
+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 };
+}
+
+// version.ts
+var packageversion = "1.1.57";
+
+// types.ts
+var protocolversion = packageversion;
+
+// agentstream.ts
+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 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";
@@ -8934,7 +9621,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) {
@@ -9029,6 +9719,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 } });
 }
@@ -9049,7 +9755,7 @@ function framedlog(event, at, fields) {
   return JSON.stringify({ at, event, ...fields ?? {} });
 }
 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
@@ -9410,6 +10116,92 @@ function streamsummaries(raw) {
   });
 }
 
+// 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 };
+}
+function bumprevision(route, now) {
+  return { ...route, revision: route.revision + 1, updatedat: now };
+}
+
+// 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 rendertemplate(input) {
+  if (input.sensitive === true && (input.consentnotice === void 0 || input.consentnotice.trim() === "")) return { reason: "The sensitive flow needs its consent notice before the template renders." };
+  const variables = input.variables ?? {};
+  const missing = input.template.variables.filter((name) => variables[name] === void 0 || variables[name] === null || typeof variables[name] === "string" && variables[name].trim() === "");
+  if (missing.length > 0) return { reason: `The template variables ${missing.join(", ")} stay empty.` };
+  let text2 = input.template.body.replace(/\{\{\s*([a-z0-9]+)\s*\}\}/g, (whole, name) => {
+    const value = variables[name];
+    if (value === void 0 || value === null) return whole;
+    return typeof value === "string" ? value : JSON.stringify(value);
+  });
+  if (input.sensitive === true && input.consentnotice !== void 0) text2 = `${text2}
+Consent notice: ${input.consentnotice}`;
+  return { text: text2 };
+}
+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);
+}
+
 // protocol.ts
 function record(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("Protocol message must be an object.");
@@ -10065,6 +10857,72 @@ function heartbeatreport(input) {
   const open = input.channels.filter((channel) => channel.closedat === void 0 && input.now - channel.lastbeatat < (input.idlewindow ?? defaultidlewindowms));
   return { version: protocolversion, beats: input.channels.filter((channel) => channel.lastbeatat > channel.openedat).length, open: open.length, dead: input.channels.length - open.length };
 }
+function subscriptionframes(input) {
+  const subscribe = { jsonrpc: "2.0", id: input.id, method: "events/subscribe", params: { subscriptionid: input.subscription.id, kinds: input.subscription.kinds, ...input.subscription.origin !== void 0 ? { origin: input.subscription.origin } : {}, ...input.subscription.tool !== void 0 ? { tool: input.subscription.tool } : {} } };
+  const unsubscribe = { jsonrpc: "2.0", id: input.id, method: "events/unsubscribe", params: { subscriptionid: input.subscription.id } };
+  return { subscribe, unsubscribe };
+}
+function eventnotification(input) {
+  return { jsonrpc: "2.0", method: "events/notify", params: { subscriptionid: input.subscriptionid, 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 } };
+}
+function resourcedeltareport(input) {
+  return { version: protocolversion, watchid: input.watchid, clientid: input.clientid, resource: input.resource, delta: input.delta, at: input.now };
+}
+function samplingframes(input) {
+  const request = { jsonrpc: "2.0", id: input.id, method: "sampling/request", params: { samplingid: input.request.id, prompt: input.request.prompt, ...input.request.system !== void 0 ? { system: input.request.system } : {}, ...input.request.pagecontent !== void 0 ? { pagecontent: input.request.pagecontent } : {}, ...input.request.maxtokens !== void 0 ? { maxtokens: input.request.maxtokens } : {} } };
+  const answer = input.request.state === "answered" ? { jsonrpc: "2.0", id: input.id, method: "sampling/answer", params: { samplingid: input.request.id, answer: input.request.answer ?? "" } } : input.request.state === "refused" ? { jsonrpc: "2.0", id: input.id, method: "sampling/answer", params: { samplingid: input.request.id, refused: true } } : { jsonrpc: "2.0", id: input.id, method: "sampling/answer", params: { samplingid: input.request.id, state: "pending" } };
+  return { request, answer };
+}
+function promptreport(input) {
+  return { version: protocolversion, prompts: input.prompts.map((prompt) => ({ name: prompt.name, description: prompt.description, arguments: prompt.arguments, template: prompt.template })) };
+}
+function promptcallframe(input) {
+  return { jsonrpc: "2.0", id: input.id, method: "prompts/call", params: { name: input.name, arguments: input.args } };
+}
+function streamchunkframe(chunk) {
+  return { jsonrpc: "2.0", method: "calls/stream", params: { callid: chunk.callid, seq: chunk.seq, content: chunk.content, done: chunk.done, at: chunk.at } };
+}
+function progressnoticeframe(notice) {
+  return { jsonrpc: "2.0", method: "calls/progress", params: { callid: notice.callid, ...notice.percent !== void 0 ? { percent: notice.percent } : {}, message: notice.message, cancellable: notice.cancellable, at: notice.at } };
+}
+function cancelframes(input) {
+  const cancel = { jsonrpc: "2.0", id: input.id, method: "calls/cancel", params: { callid: input.frame.callid, ...input.frame.reason !== void 0 ? { reason: input.frame.reason } : {} } };
+  const cancelled = { jsonrpc: "2.0", id: input.id, result: { cancelled: true, callid: input.frame.callid, ...input.frame.reason !== void 0 ? { reason: input.frame.reason } : {}, ...input.partial !== void 0 ? { partial: input.partial } : {} } };
+  return { cancel, cancelled };
+}
+function structurederrorreport(input) {
+  return { version: protocolversion, code: input.error.code, message: input.error.message, retryhint: input.error.retryhint, ...input.error.retryafter !== void 0 ? { retryafter: input.error.retryafter } : {}, ...input.usage !== void 0 ? { usage: input.usage } : {} };
+}
+function idempotencyreplayframe(input) {
+  return { jsonrpc: "2.0", id: input.id, result: { replayed: true, idempotencykey: input.key, originalat: input.originalat, result: input.result } };
+}
+function batchreport(input) {
+  return { version: protocolversion, batchid: input.batch.id, clientid: input.batch.clientid, state: input.batch.state, stoponerror: input.batch.stoponerror, done: input.batch.outcomes.length, total: input.batch.calls.length, outcomes: input.batch.outcomes };
+}
+function ratelimitreport(input) {
+  return { version: protocolversion, limits: input.limits.map((limit) => ({ clientid: limit.clientid, windowms: limit.windowms, ...limit.budget !== void 0 ? { budget: limit.budget } : {}, used: limit.used, unbounded: limit.budget === void 0, resetat: limit.windowstartedat + limit.windowms })) };
+}
+function calllogreport(input) {
+  return { version: protocolversion, calls: input.calls, filters: input.filters ?? {} };
+}
+function inflightreport(input) {
+  return { version: protocolversion, inflight: input.contexts.filter((context) => context.state === "inflight").map((context) => ({ callid: context.callid, clientid: context.clientid, tool: context.tool, startedat: context.startedat, msopen: input.now - context.startedat, chunks: context.chunks, ...context.dryrun === true ? { dryrun: true } : {}, ...context.batchid !== void 0 ? { batchid: context.batchid } : {}, ...context.idempotencykey !== void 0 ? { idempotencykey: context.idempotencykey } : {} })) };
+}
+function dryrunreport(dryrun) {
+  return { version: protocolversion, callid: dryrun.callid, tool: dryrun.tool, argsvalid: dryrun.argsvalid, consentok: dryrun.consentok, findings: dryrun.findings, executed: dryrun.executed, mutations: dryrun.mutations };
+}
+function mockreport(mocks) {
+  return { version: protocolversion, mocks: mocks.map((mock) => ({ tool: mock.tool, content: mock.result.content, testcontext: mock.testcontext, createdat: mock.createdat })) };
+}
+function idempotencyreport(records, now) {
+  return { version: protocolversion, records: records.map((record2) => ({ key: record2.key, clientid: record2.clientid, tool: record2.tool, createdat: record2.createdat, expiresat: record2.expiresat, live: now < record2.expiresat })) };
+}
+function modelproposal(input) {
+  return { version: protocolversion, modelproposal: { draftid: input.draft.id, goal: input.draft.goal, steps: input.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, ...step.freshreview === true ? { freshreview: true } : {} })), openquestions: input.draft.openquestions, lintfindings: input.draft.lintfindings, providerid: input.draft.providerid, model: input.draft.model, state: input.draft.state, createdat: input.draft.createdat } };
+}
+function modeloutcome(input) {
+  return { version: protocolversion, modeloutcome: { ...input.runid !== void 0 && input.runid.trim() !== "" ? { runid: input.runid } : {}, usage: input.totals, guards: input.outputs.map((output) => ({ verdict: output.verdict, ...output.reason !== void 0 ? { reason: output.reason } : {}, attempts: output.attempts })) } };
+}
 
 // workfloweditor.ts
 var palettecategories = ["actions", "controlflow", "waits", "variables", "triggers"];
@@ -10773,6 +11631,7 @@ export {
   activelayers,
   addedge,
   addnode,
+  addusage,
   agentgrammarvalid,
   agentpresetof,
   allowlistcovers,
@@ -10805,6 +11664,7 @@ export {
   authreport,
   autointervalof,
   backoffdelay,
+  batchreport,
   bindlocalhost,
   bindparam,
   bindvariables,
@@ -10823,15 +11683,22 @@ export {
   breakpointceilingof,
   breakpointinputof,
   browserpermissions,
+  budgetcheck,
   buildname,
   buildpdf,
+  buildrequest,
   buildsheet,
   buildsteplibrary,
   buildstitchplan,
   buildtoolcatalog,
+  bumprevision,
   callgraphql,
+  calllocal,
+  calllogreport,
+  callmodel,
   callrest,
   callsreport,
+  cancelframes,
   cancellederror,
   cancelrun,
   canexecute,
@@ -10860,9 +11727,11 @@ export {
   channelorigin,
   checkallowlist,
   choosebranch,
+  classifyintent,
   closechannel,
   closeidlechannels,
   collectmessages,
+  commandguard,
   composeworkflow,
   conditionof,
   confirmmanualrun,
@@ -10883,6 +11752,7 @@ export {
   cookiegate,
   cookierecordof,
   correlationid,
+  costbudgetvalid,
   cpusnap,
   crashinterrupted,
   cronnext,
@@ -10904,6 +11774,7 @@ export {
   defaultmcpconfig,
   defaultmcpport,
   defaultpairinglifetimems,
+  defaultrefusalmarkers,
   defaulttokenlifetimems,
   defaulttriggercooldown,
   delayjitter,
@@ -10918,12 +11789,15 @@ export {
   dispatchtool,
   domainkinds,
   downloadreport,
+  draftplan,
   drainqueue,
   dryrunprojection,
+  dryrunreport,
   dryrunworkflow,
   editorsavegate,
   editorstate,
   editstep,
+  egressconsentgate,
   emugate,
   emulationkinds,
   emulationreport,
@@ -10936,6 +11810,7 @@ export {
   errorreportresponse,
   evaluatecondition,
   evaluatetrigger,
+  eventnotification,
   eventresponse,
   eventrulematches,
   exchangesreport,
@@ -10956,6 +11831,7 @@ export {
   extractionreport,
   extractvalues,
   failureclass,
+  fallbackroute,
   familyofkind,
   fetchoptionsof,
   fetchrequestof,
@@ -10978,6 +11854,8 @@ export {
   groupselect,
   growsampleof,
   growthtrend,
+  guardoutput,
+  guardverdictgate,
   handleframe,
   headerfilterof,
   headeruleof,
@@ -10992,12 +11870,15 @@ export {
   httpframepipeline,
   httpkinds,
   httpstreamreport,
+  idempotencyreplayframe,
+  idempotencyreport,
   imagefilterof,
   imagematches,
   imagenames,
   importpresetlibrary,
   importsessionfile,
   importworkflow,
+  inflightreport,
   initialize,
   iscdpkind,
   iscontrolflowkind,
@@ -11005,6 +11886,7 @@ export {
   isdebugkind,
   isemulationkind,
   isformkind,
+  islocalorigin,
   isnetwatchkind,
   isprofilekind,
   issessionkind,
@@ -11020,6 +11902,7 @@ export {
   jsonpathrulesof,
   lapseframes,
   lapseplanof,
+  latesttemplate,
   launchbridge,
   layernames,
   layoutreport,
@@ -11030,6 +11913,7 @@ export {
   listtools,
   loadworkflow,
   localhostbind,
+  localsensitivegrade,
   locationconsentcovers,
   locationconsentgate,
   locationpresetof,
@@ -11042,6 +11926,7 @@ export {
   mapresponse,
   mapurlof,
   markbreakpoint,
+  markprovider,
   matchmessage,
   matchurl,
   matchurlpattern,
@@ -11053,7 +11938,10 @@ export {
   methoddomain,
   minimapfocus,
   mockfor,
+  mockreport,
   mockspecof,
+  modeloutcome,
+  modelproposal,
   multipartchunks,
   multipartpayloadof,
   namespaceof,
@@ -11092,10 +11980,14 @@ export {
   palettecategories,
   palettenodes,
   parallelof,
+  parsecommand,
+  parsecompletion,
   parseframe,
   parsehtmlbody,
+  parseoutput,
   parseproposal,
   parsessetext,
+  parsestream,
   parsetokens,
   parsewire,
   parseworkflowproposal,
@@ -11118,6 +12010,8 @@ export {
   permissionstatevalid,
   ping,
   planallowlist,
+  plandraftreviewgate,
+  planlint,
   pollcursorof,
   polldecision,
   pollurl,
@@ -11127,8 +12021,13 @@ export {
   profilereport,
   profileretentionwindow,
   profilerkinds,
+  progressnoticeframe,
+  promptcallframe,
+  promptreport,
   protocolversion,
   provenancereport,
+  provideregressgrade,
+  providervalid,
   proxygate,
   proxyrouteof,
   publishmessage,
@@ -11139,6 +12038,7 @@ export {
   rankapis,
   ratelimitbudgetallowed,
   ratelimitreadof,
+  ratelimitreport,
   ratelimitwait,
   readpath,
   readstream,
@@ -11151,6 +12051,8 @@ export {
   redactparams,
   redeempairingcode,
   redoedit,
+  reflectionsummary,
+  reflectstep,
   regexextract,
   regexruleof,
   regionsteps,
@@ -11158,9 +12060,14 @@ export {
   relayframe,
   removeedge,
   removenode,
+  removetemplate,
   renderminimap,
+  rendertemplate,
+  rendertoolbriefs,
   reordersteps,
   repeatuntilof,
+  replannonfail,
+  replanreviewgate,
   replaytrace,
   replayurl,
   requestbody,
@@ -11168,8 +12075,10 @@ export {
   resolutionverdict,
   resolveapproval,
   resolvedrisk,
+  resolveroute,
   resolvetool,
   resolvevariable,
+  resourcedeltareport,
   resourcefacts,
   respond,
   restartbridge,
@@ -11188,6 +12097,8 @@ export {
   rewritesourcelocation,
   rotatelogs,
   rotationruleof,
+  routesfor,
+  routevalid,
   rpcerrorcodeof,
   rpcerrornumbers,
   rpcerrorof,
@@ -11209,6 +12120,8 @@ export {
   runwhile,
   runworkflow,
   safetyresponse,
+  samplingframes,
+  savetemplate,
   saveworkflow,
   scaledrect,
   schedulecron,
@@ -11219,6 +12132,7 @@ export {
   searchqueryof,
   searchsessionrecords,
   searchsteps,
+  searchtemplates,
   seededrandom,
   selectorresponse,
   sendcdpcommand,
@@ -11262,9 +12176,15 @@ export {
   stepmodeof,
   steptemplateof,
   stepwindows,
+  streamchunkframe,
+  streamdelta,
+  streammodel,
   streamsummaries,
   streamwindowof,
+  stripguardrails,
+  structurederrorreport,
   submitreviewgranted,
+  subscriptionframes,
   subscriptionoptionsof,
   tabreportresponse,
   targetgate,
@@ -11274,6 +12194,7 @@ export {
   teardowncdpsession,
   teardownplanof,
   templateurl,
+  templatevariables,
   thumbdirectiveof,
   thumbgeometry,
   timelinecounts,
@@ -11289,6 +12210,7 @@ export {
   tokenhashprefix,
   tokenreport,
   tokenrequest,
+  toolbriefof,
   toolcallevent,
   toolcallframe,
   toolcatalogversion,
@@ -11323,6 +12245,7 @@ export {
   unwrapgraphql,
   updaterule,
   urlencodeform,
+  usagetotals,
   validatebreakpointcondition,
   validatecontrolpayload,
   validatefieldmatch,