@buzzni/saycode-cli 0.9.9 → 0.9.11

package/channel-extension-host.mjs

@@ -7,7 +7,7 @@ const ASSET_PERMISSIONS = ["assets.read", "assets.write", "files.select", "draft
 function usesAssetWorkflow(permissions) {
   return permissions.some((permission) => ASSET_PERMISSIONS.includes(permission));
 }
-const LONG_RUNNING_PERMISSIONS = ["localTools.inspect", "localTools.install", "localTools.control", "localBrowser.setup", "machine.run"];
+const LONG_RUNNING_PERMISSIONS = ["localTools.inspect", "localTools.install", "localTools.control", "localBrowser.setup", "browser.runtimeSetup", "machine.run"];
 function extensionRequestTimeoutMs(permissions, side) {
   const long = usesAssetWorkflow(permissions) || permissions.some((permission) => LONG_RUNNING_PERMISSIONS.includes(permission));
   if (!long) return void 0;
@@ -262,7 +262,7 @@ function path(value) {
 }
 function parseManagedLocalTool(value, extensionId2) {
   const root = row(value);
-  keys(root, ["version", "id", "toolVersion", "platforms", "operations"]);
+  keys(root, ["version", "id", "toolVersion", "platforms", "operations", "background"]);
   if (root.version !== 1 || !ID.test(text$2(root.id)) || !String(root.id).startsWith(extensionId2 + ".") || !/^\d+\.\d+\.\d+$/.test(text$2(root.toolVersion))) fail$4();
   const platforms = {};
   for (const [platform, raw] of Object.entries(row(root.platforms))) {
@@ -319,7 +319,23 @@ function parseManagedLocalTool(value, extensionId2) {
     operations[name] = operation;
   }
   if (!Object.keys(platforms).length || !Object.keys(operations).length || Object.keys(operations).length > 32) fail$4();
-  return { version: 1, id: String(root.id), toolVersion: String(root.toolVersion), platforms, operations };
+  const background = root.background === void 0 ? void 0 : parseBackground(root.background, platforms, operations);
+  return { version: 1, id: String(root.id), toolVersion: String(root.toolVersion), platforms, operations, ...background ? { background } : {} };
+}
+function parseBackground(value, platforms, operations) {
+  const source = row(value);
+  keys(source, ["argv", "stopOperation"]);
+  if (!Object.keys(platforms).some((platform) => platform.startsWith("win32-") || platform.startsWith("darwin-"))) fail$4();
+  if (!Array.isArray(source.argv) || !source.argv.length || source.argv.length > 8) fail$4();
+  const argv = source.argv.map((arg) => {
+    const value2 = text$2(arg);
+    if (value2.includes("{{")) fail$4();
+    return value2;
+  });
+  if (source.stopOperation === void 0) return { argv };
+  const stop = operations[text$2(source.stopOperation)];
+  if (!stop || Object.keys(stop.inputs ?? {}).length || stop.payload !== void 0) fail$4();
+  return { argv, stopOperation: String(source.stopOperation) };
 }
 function managedToolArguments(operation, parameters, session) {
   const inputs = operation.inputs ?? {};
@@ -469,8 +485,11 @@ function parseExtensionArtifactActions(value, path2 = "manifest.contributes.arti
     };
   });
 }
-const CHANNEL_API_VERSION = 1;
+const CHANNEL_API_VERSION = 2;
 const CHANNEL_MINIMUM_API_VERSION = 1;
+function isSupportedChannelApiVersion(value) {
+  return typeof value === "number" && Number.isInteger(value) && value >= CHANNEL_MINIMUM_API_VERSION && value <= CHANNEL_API_VERSION;
+}
 const CHANNEL_PROVIDERS = ["telegram", "slack", "discord"];
 const CHANNEL_COMMAND_SCHEMA = Object.freeze({
   pair: Object.freeze(["code!"]),
@@ -611,6 +630,7 @@ const EXTENSION_PERMISSIONS = [
   "localTools.install",
   "localTools.control",
   "localBrowser.setup",
+  "browser.runtimeSetup",
   "network.fetch",
   "notifications.show",
   "storage.read",
@@ -633,18 +653,22 @@ const EXTENSION_PERMISSIONS = [
   "channels.transport",
   "sessions.read",
   "sessions.control",
-  "sessions.approveOnce"
+  "sessions.approveOnce",
+  // Core → adapter, not a capability the adapter invokes: Core sends the current input and the
+  // thread's earlier messages (other people's words included) for display-text normalization
+  // (specs/slack-bot-improvements contracts §2). Channel API 2 only.
+  "channels.normalize"
 ];
 const CONVERSATION_MODS_INTERNAL = typeof __SAYCODE_MODS_INTERNAL__ !== "undefined" && __SAYCODE_MODS_INTERNAL__ === true;
 const SAYCODE_EXTENSION_API_VERSION = CONVERSATION_MODS_INTERNAL ? 5 : 4;
 const SAYCODE_EXTENSION_MINIMUM_API_VERSION = CONVERSATION_MODS_INTERNAL ? 4 : 2;
 const MAX_EXTENSION_API_WINDOW_WIDTH = 2;
-const SAYCODE_EXTENSION_ENGINE_VERSION = "1.2.0";
+const SAYCODE_EXTENSION_ENGINE_VERSION = "1.3.0";
 const SAYCODE_CHANNEL_API_VERSION = CHANNEL_API_VERSION;
 const SAYCODE_CHANNEL_MINIMUM_API_VERSION = CHANNEL_MINIMUM_API_VERSION;
 class UnsupportedChannelApiVersionError extends Error {
   constructor(channelApiVersion) {
-    super(`manifest.channelApiVersion: channel API version ${String(channelApiVersion)} is unsupported; Desktop supports ${String(SAYCODE_CHANNEL_API_VERSION)}`);
+    super(`manifest.channelApiVersion: channel API version ${String(channelApiVersion)} is unsupported; Desktop supports ${`${SAYCODE_CHANNEL_MINIMUM_API_VERSION}-${SAYCODE_CHANNEL_API_VERSION}`}`);
     this.channelApiVersion = channelApiVersion;
   }
   name = "UnsupportedChannelApiVersionError";
@@ -667,7 +691,7 @@ const V2_PERMISSIONS = /* @__PURE__ */ new Set([
   "browserViewer.install",
   "browserViewer.installChrome"
 ]);
-const V3_PERMISSIONS = /* @__PURE__ */ new Set(["machine.run", "artifacts.publishPublic", "assets.read", "assets.write", "files.select", "drafts.prepare", "localTools.inspect", "localTools.install", "localTools.control", "localBrowser.setup"]);
+const V3_PERMISSIONS = /* @__PURE__ */ new Set(["machine.run", "artifacts.publishPublic", "assets.read", "assets.write", "files.select", "drafts.prepare", "localTools.inspect", "localTools.install", "localTools.control", "localBrowser.setup", "browser.runtimeSetup"]);
 const CHANNEL_PERMISSIONS = /* @__PURE__ */ new Set([
   "channels.receive",
   "channels.ack",
@@ -675,7 +699,8 @@ const CHANNEL_PERMISSIONS = /* @__PURE__ */ new Set([
   "channels.transport",
   "sessions.read",
   "sessions.control",
-  "sessions.approveOnce"
+  "sessions.approveOnce",
+  "channels.normalize"
 ]);
 const TOP_LEVEL_KEYS = /* @__PURE__ */ new Set([
   "id",
@@ -925,6 +950,9 @@ function parseExtensionManifest(value, options) {
       if (channelApiVersion === void 0) {
         fail$5(`manifest.permissions[${index}]`, "requires manifest.channelApiVersion");
       }
+      if (typed === "channels.normalize" && channelApiVersion < 2) {
+        fail$5(`manifest.permissions[${index}]`, "channels.normalize requires channel API version 2");
+      }
     }
     return typed;
   });
@@ -1073,6 +1101,246 @@ function parseChannelApprovalRequest(value) {
   }
   return { approvalHandle, approveLabel, denyLabel };
 }
+const NORMALIZE_ADDITION_SOURCES = ["blocks", "quote", "forward", "table", "unfurl", "files"];
+const MAX_NORMALIZE_ITEMS = 200;
+const MAX_USER_LABELS = 200;
+const MAX_BLOCKS = 50;
+const MAX_ATTACHMENTS = 20;
+const MAX_FILES = 20;
+const MAX_RICH_TEXT_DEPTH = 6;
+const MAX_URL_LENGTH = 2048;
+const MAX_ADDITIONS_BYTES = 8192;
+const MAX_PRIMARY_BYTES = 65536;
+const ITEM_REF = /^i(0|[1-9]\d?|1\d\d)$/;
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const isString = (value) => typeof value === "string";
+function projectSlackMessage(raw) {
+  const state = { truncated: false };
+  const message = isRecord(raw) ? raw : {};
+  const projection = {};
+  const blocks = projectBlocks(message.blocks, state);
+  if (blocks) projection.blocks = blocks;
+  const attachments = capped(Array.isArray(message.attachments) ? message.attachments.filter(isRecord) : [], MAX_ATTACHMENTS, state).map((attachment) => projectAttachment(attachment, state));
+  if (attachments.length > 0) projection.attachments = attachments;
+  const files = capped(Array.isArray(message.files) ? message.files.filter(isRecord) : [], MAX_FILES, state).map(projectFile);
+  if (files.length > 0) projection.files = files;
+  if (isString(message.subtype)) projection.subtype = message.subtype;
+  return { projection, truncated: state.truncated };
+}
+function capped(items, max, state) {
+  if (items.length > max) state.truncated = true;
+  return items.slice(0, max);
+}
+function projectBlocks(value, state) {
+  if (!Array.isArray(value)) return void 0;
+  const projected = value.map((block) => projectBlock(block, state)).filter((block) => block !== null);
+  return projected.length > 0 ? capped(projected, MAX_BLOCKS, state) : void 0;
+}
+function projectBlock(block, state) {
+  if (!isRecord(block)) return null;
+  switch (block.type) {
+    case "rich_text":
+      return { type: "rich_text", elements: projectContainers(block.elements, 1, state) };
+    case "section": {
+      const section = { type: "section" };
+      const text2 = projectTextObject(block.text);
+      if (text2) section.text = text2;
+      if (Array.isArray(block.fields)) section.fields = block.fields.map(projectTextObject).filter((field) => field !== null);
+      return section;
+    }
+    case "header": {
+      const text2 = projectTextObject(block.text);
+      return text2 ? { type: "header", text: text2 } : null;
+    }
+    case "context":
+      return { type: "context", elements: Array.isArray(block.elements) ? block.elements.map(projectTextObject).filter((element) => element !== null) : [] };
+    case "table":
+      return { type: "table", rows: Array.isArray(block.rows) ? block.rows.filter(Array.isArray).map((row2) => row2.flatMap((cell) => {
+        if (isRecord(cell) && cell.type === "raw_text" && isString(cell.text)) return [{ type: "raw_text", text: cell.text }];
+        if (isRecord(cell) && cell.type === "rich_text") return [{ type: "rich_text", elements: projectContainers(cell.elements, 1, state) }];
+        return [];
+      })) : [] };
+    default:
+      return null;
+  }
+}
+function projectTextObject(value) {
+  if (!isRecord(value) || value.type !== "mrkdwn" && value.type !== "plain_text" || !isString(value.text)) return null;
+  return { type: value.type, text: value.text };
+}
+const CONTAINER_TYPES = /* @__PURE__ */ new Set(["rich_text_section", "rich_text_quote", "rich_text_preformatted", "rich_text_list"]);
+function projectContainers(value, depth, state) {
+  if (!Array.isArray(value)) return [];
+  return value.flatMap((node) => {
+    const container = isRecord(node) && CONTAINER_TYPES.has(String(node.type)) ? projectContainer(node, depth, state) : null;
+    return container ? [container] : [];
+  });
+}
+function projectContainer(node, depth, state) {
+  if (depth > MAX_RICH_TEXT_DEPTH) {
+    state.truncated = true;
+    return null;
+  }
+  const elements = (Array.isArray(node.elements) ? node.elements : []).flatMap((child) => {
+    if (isRecord(child) && CONTAINER_TYPES.has(String(child.type))) {
+      const nested = projectContainer(child, depth + 1, state);
+      return nested ? [nested] : [];
+    }
+    const leaf = projectLeaf(child);
+    return leaf ? [leaf] : [];
+  });
+  const container = { type: node.type, elements };
+  if (node.style === "bullet" || node.style === "ordered") container.style = node.style;
+  return container;
+}
+function projectLeaf(node) {
+  if (!isRecord(node)) return null;
+  switch (node.type) {
+    case "text": {
+      if (!isString(node.text)) return null;
+      const leaf = { type: "text", text: node.text };
+      if (isRecord(node.style)) {
+        const style = Object.fromEntries(["bold", "italic", "strike", "code"].filter((key) => typeof node.style[key] === "boolean").map((key) => [key, node.style[key]]));
+        if (Object.keys(style).length > 0) leaf.style = style;
+      }
+      return leaf;
+    }
+    case "link": {
+      const label = isString(node.text) ? node.text : void 0;
+      if (!httpUrl(node.url)) return label === void 0 ? null : { type: "text", text: label };
+      return label === void 0 ? { type: "link", url: node.url } : { type: "link", url: node.url, text: label };
+    }
+    case "user":
+      return isString(node.user_id) ? { type: "user", user_id: node.user_id } : null;
+    case "channel":
+      return isString(node.channel_id) ? { type: "channel", channel_id: node.channel_id } : null;
+    case "usergroup":
+      return isString(node.usergroup_id) ? { type: "usergroup", usergroup_id: node.usergroup_id } : null;
+    case "emoji":
+      return isString(node.name) ? { type: "emoji", name: node.name } : null;
+    case "broadcast":
+      return node.range === "here" || node.range === "channel" || node.range === "everyone" ? { type: "broadcast", range: node.range } : null;
+    default:
+      return null;
+  }
+}
+const ATTACHMENT_TEXT_KEYS = ["text", "fallback", "pretext", "title", "author_name", "footer"];
+const ATTACHMENT_URL_KEYS = ["title_link", "from_url", "original_url"];
+function projectAttachment(attachment, state) {
+  const projected = {};
+  for (const key of ATTACHMENT_TEXT_KEYS) if (isString(attachment[key])) projected[key] = attachment[key];
+  for (const key of ATTACHMENT_URL_KEYS) if (httpUrl(attachment[key])) projected[key] = attachment[key];
+  if (typeof attachment.is_share === "boolean") projected.is_share = attachment.is_share;
+  if (typeof attachment.is_msg_unfurl === "boolean") projected.is_msg_unfurl = attachment.is_msg_unfurl;
+  if (Array.isArray(attachment.message_blocks)) {
+    projected.message_blocks = attachment.message_blocks.filter(isRecord).map((forwarded) => ({
+      message: { blocks: projectBlocks(isRecord(forwarded.message) ? forwarded.message.blocks : void 0, state) ?? [] }
+    }));
+  }
+  return projected;
+}
+function projectFile(file) {
+  const projected = {};
+  for (const key of ["name", "title", "filetype", "mimetype"]) if (isString(file[key])) projected[key] = file[key];
+  if (Number.isSafeInteger(file.size) && file.size >= 0) projected.size = file.size;
+  return projected;
+}
+function httpUrl(value) {
+  return isString(value) && value.length <= MAX_URL_LENGTH && /^https?:\/\//i.test(value);
+}
+function parseChannelNormalizeRequest(value) {
+  const request = plainRecord(value, "normalize request");
+  exactKeySet(request, ["apiVersion", "channelId", "connectionId", "provider", "connectionRevision", "requestId", "purpose", "userLabels", "items"], "normalize request");
+  if (request.apiVersion !== 2 || request.provider !== "slack") fail("normalize request is channel API 2 Slack only");
+  if (request.purpose !== "currentInput" && request.purpose !== "threadHistory") fail("invalid normalize purpose");
+  if (!Number.isSafeInteger(request.connectionRevision) || request.connectionRevision < 1) fail("invalid normalize connection revision");
+  const labels = plainRecord(request.userLabels, "normalize userLabels");
+  if (Object.keys(labels).length > MAX_USER_LABELS || Object.entries(labels).some(([key, label]) => key.length === 0 || key.length > 64 || !isString(label) || label.length > 256)) {
+    fail("invalid normalize userLabels");
+  }
+  if (!Array.isArray(request.items) || request.items.length < 1 || request.items.length > MAX_NORMALIZE_ITEMS) fail("invalid normalize items");
+  const refs = /* @__PURE__ */ new Set();
+  const items = request.items.map((value2) => {
+    const item = plainRecord(value2, "normalize item");
+    exactKeySet(item, ["itemRef", "primaryText", "projection", "maxAdditionsBytes"], "normalize item");
+    if (!isString(item.itemRef) || !ITEM_REF.test(item.itemRef) || refs.has(item.itemRef)) fail("invalid normalize itemRef");
+    refs.add(item.itemRef);
+    if (!isString(item.primaryText) || utf8Bytes(item.primaryText) > MAX_PRIMARY_BYTES) fail("invalid normalize primaryText");
+    if (!Number.isSafeInteger(item.maxAdditionsBytes) || item.maxAdditionsBytes < 1 || item.maxAdditionsBytes > MAX_ADDITIONS_BYTES) fail("invalid normalize maxAdditionsBytes");
+    const projected = projectSlackMessage(item.projection);
+    if (!isRecord(item.projection) || projected.truncated || !sameJson(projected.projection, item.projection)) fail("normalize projection is not a Core projection");
+    return { itemRef: item.itemRef, primaryText: item.primaryText, projection: projected.projection, maxAdditionsBytes: item.maxAdditionsBytes };
+  });
+  return {
+    apiVersion: 2,
+    provider: "slack",
+    purpose: request.purpose,
+    channelId: boundedText(request.channelId, "channelId"),
+    connectionId: boundedText(request.connectionId, "connectionId"),
+    connectionRevision: request.connectionRevision,
+    requestId: boundedText(request.requestId, "requestId"),
+    userLabels: { ...labels },
+    items
+  };
+}
+function parseChannelNormalizeResult(request, value) {
+  const result = plainRecord(value, "normalize result");
+  exactKeySet(result, ["items"], "normalize result");
+  if (!Array.isArray(result.items)) fail("invalid normalize result items");
+  const wanted = new Map(request.items.map((item) => [item.itemRef, item]));
+  const parsed = /* @__PURE__ */ new Map();
+  for (const value2 of result.items) {
+    const item = plainRecord(value2, "normalize result item");
+    exactKeySet(item, ["itemRef", "additions", "truncated"], "normalize result item");
+    const requested = isString(item.itemRef) ? wanted.get(item.itemRef) : void 0;
+    if (!requested || parsed.has(requested.itemRef)) fail("normalize result items differ from the request");
+    if (typeof item.truncated !== "boolean" || !Array.isArray(item.additions)) fail("invalid normalize result item");
+    let bytes = 0;
+    const additions = item.additions.map((value3) => {
+      const addition = plainRecord(value3, "normalize addition");
+      exactKeySet(addition, ["source", "text"], "normalize addition");
+      if (!NORMALIZE_ADDITION_SOURCES.includes(addition.source) || !isString(addition.text) || addition.text.includes("\0") || hasLoneSurrogate(addition.text)) fail("invalid normalize addition");
+      bytes += utf8Bytes(addition.text);
+      return { source: addition.source, text: addition.text };
+    });
+    if (bytes > requested.maxAdditionsBytes) fail("normalize additions exceed their budget");
+    parsed.set(requested.itemRef, { itemRef: requested.itemRef, additions: withoutRepeatedLines(requested.primaryText, additions), truncated: item.truncated });
+  }
+  if (parsed.size !== wanted.size) fail("normalize result items differ from the request");
+  return request.items.map((item) => parsed.get(item.itemRef));
+}
+function withoutRepeatedLines(primaryText, additions) {
+  const fold = (line) => line.replace(/\s+/gu, " ").trim();
+  const known = new Set(primaryText.split("\n").map(fold).filter(Boolean));
+  const kept = [];
+  for (const addition of additions) {
+    const lines2 = addition.text.split("\n");
+    const remaining = lines2.filter((line) => fold(line) === "" || !known.has(fold(line)));
+    for (const line of lines2) if (fold(line)) known.add(fold(line));
+    if (remaining.some((line) => fold(line) !== "")) kept.push({ source: addition.source, text: remaining.join("\n") });
+  }
+  return kept;
+}
+function exactKeySet(record2, keys2, path2) {
+  const actual = Object.keys(record2);
+  if (actual.length !== keys2.length || !keys2.every((key) => actual.includes(key))) fail(`${path2} has unexpected keys`);
+}
+function boundedText(value, path2) {
+  if (!isString(value) || value.length === 0 || value.length > 200) fail(`invalid normalize ${path2}`);
+  return value;
+}
+function sameJson(a, b) {
+  if (Array.isArray(a) || Array.isArray(b)) {
+    return Array.isArray(a) && Array.isArray(b) && a.length === b.length && a.every((item, index) => sameJson(item, b[index]));
+  }
+  if (isRecord(a) && isRecord(b)) {
+    const keys2 = Object.keys(a);
+    return keys2.length === Object.keys(b).length && keys2.every((key) => Object.hasOwn(b, key) && sameJson(a[key], b[key]));
+  }
+  return Object.is(a, b);
+}
+const utf8Bytes = (text2) => new TextEncoder().encode(text2).length;
+const hasLoneSurrogate = (text2) => /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/.test(text2);
 function finiteNumber(value, path2) {
   if (typeof value !== "number" || !Number.isFinite(value)) fail(`${path2} must be a finite number`);
   return value;
@@ -1162,13 +1430,15 @@ function parseRequest(message) {
         "maxChunkUtf16Units",
         "maxChunks"
       ];
+      const v2 = params.apiVersion === 2;
       exactKeys(
         params,
-        "approval" in params ? [...formatKeys, "approval"] : formatKeys,
+        v2 ? [...formatKeys, "mode", "dialect"] : "approval" in params ? [...formatKeys, "approval"] : formatKeys,
         "request.params"
       );
+      if (v2 && (params.mode !== "verbatim" && params.mode !== "rendered" || params.dialect !== "slack-mrkdwn" || params.kind === "approval")) fail("invalid channel API 2 formatter request");
       const lifecycle = parseRequest({ kind: "request", id: id2, method: "channel.lifecycle", params: {
-        apiVersion: params.apiVersion,
+        apiVersion: v2 ? 1 : params.apiVersion,
         channelId: params.channelId,
         connectionId: params.connectionId,
         provider: params.provider,
@@ -1184,16 +1454,26 @@ function parseRequest(message) {
       }
       const approval = params.approval === void 0 ? void 0 : parseChannelApprovalRequest(params.approval);
       const { state: _state, ...identity } = lifecycle.params;
+      const bounds = { requestId, text: body, maxChunks: Number(params.maxChunks), maxChunkUtf16Units: Number(params.maxChunkUtf16Units) };
+      if (v2) {
+        return { kind: "request", id: id2, method, params: {
+          ...identity,
+          ...bounds,
+          apiVersion: 2,
+          kind: params.kind,
+          mode: params.mode,
+          dialect: "slack-mrkdwn"
+        } };
+      }
       return { kind: "request", id: id2, method, params: {
         ...identity,
-        requestId,
-        text: body,
+        ...bounds,
         kind: params.kind,
-        maxChunks: Number(params.maxChunks),
-        maxChunkUtf16Units: Number(params.maxChunkUtf16Units),
         ...approval ? { approval } : {}
       } };
     }
+    case "channel.normalizeMessages":
+      return { kind: "request", id: id2, method, params: parseChannelNormalizeRequest(params) };
     case "invokeCommand": {
       exactKeys(params, ["commandId", "args"], "request.params");
       if (!Array.isArray(params.args)) fail("request.params.args must be an array");
@@ -1276,6 +1556,17 @@ function parseExtensionWireMessage(value) {
   if (message.kind === "event") return parseEvent(message);
   fail("message.kind is unknown");
 }
+function parseChannelRenderedReplyResult(value) {
+  const result = plainRecord(value, "channel rendered result");
+  if (Object.keys(result).join() !== "rendered" || !Array.isArray(result.rendered)) fail("invalid channel rendered result");
+  return {
+    rendered: result.rendered.map((value2) => {
+      const chunk = plainRecord(value2, "channel rendered chunk");
+      if (Object.keys(chunk).sort().join() !== "sourceEnd,sourceStart,text" || typeof chunk.text !== "string" || !Number.isSafeInteger(chunk.sourceStart) || !Number.isSafeInteger(chunk.sourceEnd)) fail("invalid channel rendered chunk");
+      return { text: chunk.text, sourceStart: chunk.sourceStart, sourceEnd: chunk.sourceEnd };
+    })
+  };
+}
 const TIMEOUT = Symbol("extension-request-timeout");
 function requestEnvelope(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return null;
@@ -1297,6 +1588,7 @@ class ExtensionHostRuntime {
   widgets = /* @__PURE__ */ new Map();
   channelHandlers = /* @__PURE__ */ new Map();
   channelFormatters = /* @__PURE__ */ new Map();
+  channelNormalizers = /* @__PURE__ */ new Map();
   channelIntakeHandlers = /* @__PURE__ */ new Map();
   channelStates = /* @__PURE__ */ new Map();
   channelCalls = /* @__PURE__ */ new Map();
@@ -1432,6 +1724,7 @@ class ExtensionHostRuntime {
       this.commandHandlers.clear();
       this.channelHandlers.clear();
       this.channelFormatters.clear();
+      this.channelNormalizers.clear();
       this.channelIntakeHandlers.clear();
       this.channelStates.clear();
       this.channelCalls.clear();
@@ -1475,6 +1768,7 @@ class ExtensionHostRuntime {
         this.commandHandlers.clear();
         this.channelHandlers.clear();
         this.channelFormatters.clear();
+        this.channelNormalizers.clear();
         this.channelIntakeHandlers.clear();
         this.channelStates.clear();
         this.channelCalls.clear();
@@ -1495,6 +1789,7 @@ class ExtensionHostRuntime {
     }
     if (request.method === "channel.lifecycle") return this.deliverChannel(request.params);
     if (request.method === "channel.formatReply") return this.formatChannelReply(request.params);
+    if (request.method === "channel.normalizeMessages") return this.normalizeChannelMessages(request.params);
     if (request.method === "channel.intake") return this.deliverChannelIntake(request.params);
     const handler = this.commandHandlers.get(request.params.commandId);
     if (!handler) {
@@ -1507,7 +1802,7 @@ class ExtensionHostRuntime {
   }
   async deliverChannel(event) {
     const contribution = this.options.manifest.contributes.channels?.find((channel) => channel.id === event.channelId);
-    if (this.options.manifest.channelApiVersion !== 1 || !contribution || contribution.provider !== event.provider) {
+    if (!isSupportedChannelApiVersion(this.options.manifest.channelApiVersion) || !contribution || contribution.provider !== event.provider) {
       throw { code: "CHANNEL_NOT_DECLARED", message: "channel contribution/provider is not declared" };
     }
     const key = JSON.stringify([event.channelId, event.connectionId]);
@@ -1553,16 +1848,29 @@ class ExtensionHostRuntime {
     return null;
   }
   async formatChannelReply(input) {
-    const key = JSON.stringify([input.channelId, input.connectionId]);
-    const current = this.channelStates.get(key);
-    const epoch = this.channelEpoch;
+    const isCurrent = this.channelCallIsCurrent(input);
     const formatter = this.channelFormatters.get(input.channelId);
-    const isCurrent = () => !this.disposed && !this.deactivating && this.active && epoch === this.channelEpoch && this.channelStates.get(key) === current && current?.state === "start" && current.provider === input.provider && current.connectionRevision === input.connectionRevision;
     if (!isCurrent() || !formatter) throw { code: "CHANNEL_FORMAT_UNAVAILABLE", message: "channel formatter is not active" };
     const result = await formatter(Object.freeze({ ...input }));
     if (!isCurrent()) throw { code: "CHANNEL_FORMAT_WITHDRAWN", message: "channel formatter stopped" };
+    if (input.apiVersion === 2 && input.mode === "rendered") return parseChannelRenderedReplyResult(result);
     return parseChannelReplyFormatResult(result, input);
   }
+  async normalizeChannelMessages(input) {
+    const isCurrent = this.channelCallIsCurrent(input);
+    const normalizer = this.channelNormalizers.get(input.channelId);
+    if (!isCurrent() || !normalizer) throw { code: "CHANNEL_NORMALIZE_UNAVAILABLE", message: "channel normalizer is not active" };
+    const result = await normalizer(Object.freeze({ ...input }));
+    if (!isCurrent()) throw { code: "CHANNEL_NORMALIZE_WITHDRAWN", message: "channel normalizer stopped" };
+    return { items: parseChannelNormalizeResult(input, result) };
+  }
+  /** A formatter or normalizer answers only for the started connection generation it was asked about. */
+  channelCallIsCurrent(input) {
+    const key = JSON.stringify([input.channelId, input.connectionId]);
+    const current = this.channelStates.get(key);
+    const epoch = this.channelEpoch;
+    return () => !this.disposed && !this.deactivating && this.active && epoch === this.channelEpoch && this.channelStates.get(key) === current && current?.state === "start" && current.provider === input.provider && current.connectionRevision === input.connectionRevision;
+  }
   async withTimeout(operation) {
     let timer;
     const timeout = new Promise((resolve2) => {
@@ -1596,6 +1904,7 @@ class ExtensionHostRuntime {
       const registered = /* @__PURE__ */ new Map();
       const registeredChannels = /* @__PURE__ */ new Map();
       const registeredFormatters = /* @__PURE__ */ new Map();
+      const registeredNormalizers = /* @__PURE__ */ new Map();
       const registeredIntake = /* @__PURE__ */ new Map();
       await loaded.activate({
         extensionId: this.options.manifest.id,
@@ -1605,19 +1914,26 @@ class ExtensionHostRuntime {
         } },
         channels: {
           register: (channelId, handler) => {
-            if (!this.activating || this.options.manifest.channelApiVersion !== 1 || !this.options.manifest.contributes.channels?.some((channel) => channel.id === channelId) || typeof handler !== "function" || registeredChannels.has(channelId)) {
+            if (!this.activating || !isSupportedChannelApiVersion(this.options.manifest.channelApiVersion) || !this.options.manifest.contributes.channels?.some((channel) => channel.id === channelId) || typeof handler !== "function" || registeredChannels.has(channelId)) {
               throw { code: "INVALID_CHANNEL_REGISTRATION", message: "channel must be declared and registered once" };
             }
             registeredChannels.set(channelId, handler);
           },
           registerFormatter: (channelId, formatter) => {
-            if (!this.activating || this.options.manifest.channelApiVersion !== 1 || !this.options.manifest.contributes.channels?.some((channel) => channel.id === channelId) || typeof formatter !== "function" || registeredFormatters.has(channelId)) {
+            if (!this.activating || !isSupportedChannelApiVersion(this.options.manifest.channelApiVersion) || !this.options.manifest.contributes.channels?.some((channel) => channel.id === channelId) || typeof formatter !== "function" || registeredFormatters.has(channelId)) {
               throw { code: "INVALID_CHANNEL_REGISTRATION", message: "formatter must be declared and registered once" };
             }
             registeredFormatters.set(channelId, formatter);
           },
+          registerNormalizer: (channelId, normalizer) => {
+            const manifest = this.options.manifest;
+            if (!this.activating || (manifest.channelApiVersion ?? 0) < 2 || !manifest.permissions.includes("channels.normalize") || !manifest.contributes.channels?.some((channel) => channel.id === channelId) || typeof normalizer !== "function" || registeredNormalizers.has(channelId)) {
+              throw { code: "INVALID_CHANNEL_REGISTRATION", message: "normalizer needs channel API 2, channels.normalize and one registration" };
+            }
+            registeredNormalizers.set(channelId, normalizer);
+          },
           onIntake: (channelId, handler) => {
-            if (!this.activating || this.options.manifest.channelApiVersion !== 1 || !this.options.manifest.contributes.channels?.some((channel) => channel.id === channelId) || typeof handler !== "function" || registeredIntake.has(channelId)) {
+            if (!this.activating || !isSupportedChannelApiVersion(this.options.manifest.channelApiVersion) || !this.options.manifest.contributes.channels?.some((channel) => channel.id === channelId) || typeof handler !== "function" || registeredIntake.has(channelId)) {
               throw { code: "INVALID_CHANNEL_REGISTRATION", message: "intake handler must be declared and registered once" };
             }
             registeredIntake.set(channelId, handler);
@@ -1639,7 +1955,9 @@ class ExtensionHostRuntime {
       for (const [id2, render] of registeredWidgets) this.widgets.set(id2, render);
       this.channelHandlers.clear();
       this.channelFormatters.clear();
+      this.channelNormalizers.clear();
       for (const [id2, formatter] of registeredFormatters) this.channelFormatters.set(id2, formatter);
+      for (const [id2, normalizer] of registeredNormalizers) this.channelNormalizers.set(id2, normalizer);
       this.channelIntakeHandlers.clear();
       for (const [id2, handler] of registeredIntake) this.channelIntakeHandlers.set(id2, handler);
       for (const [id2, handler] of registeredChannels) this.channelHandlers.set(id2, handler);