@qwen-code/qwen-code 0.21.0 → 0.21.1-simplify-system-prompt.0

package/chunks/{agent-headless-7BYQTMHW.js → agent-headless-K4ZMMNBD.js}

@@ -4,7 +4,7 @@ import {
   AgentHeadless,
   ContextState,
   templateString
-} from "./chunk-PHOF65IG.js";
+} from "./chunk-DM4Q4JJH.js";
 import "./chunk-5M6IDOMF.js";
 import "./chunk-TWPJO254.js";
 import "./chunk-H6XPXXMH.js";
@@ -17,7 +17,7 @@ import "./chunk-ZOIFNCKL.js";
 import "./chunk-PWTZEM3C.js";
 import "./chunk-KRXPRVGL.js";
 import "./chunk-6PVPNMXU.js";
-import "./chunk-MZAXJAUM.js";
+import "./chunk-PSWQZHEA.js";
 import "./chunk-SZRN75WQ.js";
 import "./chunk-HTO4JFDZ.js";
 import "./chunk-CPBF7KYF.js";
@@ -37,16 +37,17 @@ import "./chunk-XVNQMZ2I.js";
 import "./chunk-FODK6UMO.js";
 import "./chunk-GLNBDYUX.js";
 import "./chunk-DJ2GSRLV.js";
-import "./chunk-ZJHVAS7M.js";
-import "./chunk-NIBLUX3Y.js";
+import "./chunk-YAF5VNU7.js";
+import "./chunk-BO4XCS7P.js";
 import "./chunk-BPJSQIJX.js";
 import "./chunk-P3QQPMQA.js";
 import "./chunk-6FGBXPWM.js";
 import "./chunk-LS77BEZP.js";
-import "./chunk-CIKQ7KKO.js";
+import "./chunk-SQBYH7PX.js";
+import "./chunk-RWS5VYWC.js";
 import "./chunk-VGC4I5JJ.js";
 import "./chunk-MUP3T3AD.js";
-import "./chunk-IKCX4CCL.js";
+import "./chunk-U7TXFVUN.js";
 import "./chunk-46UV252V.js";
 import "./chunk-A4UCTEB5.js";
 import "./chunk-XWRJCPHC.js";
@@ -54,9 +55,9 @@ import "./chunk-UW5EOVUN.js";
 import "./chunk-2JZBVYTU.js";
 import "./chunk-5I2IWRSH.js";
 import "./chunk-A5L3JMUA.js";
-import "./chunk-MB4MZHMJ.js";
-import "./chunk-HTR4WV6U.js";
-import "./chunk-BULDBTYC.js";
+import "./chunk-SRZ6DXVG.js";
+import "./chunk-W4RQUHY3.js";
+import "./chunk-INADJJGW.js";
 import "./chunk-U7ZFW55U.js";
 import "./chunk-UUUTRMI2.js";
 import "./chunk-PR75REBZ.js";

package/chunks/{anthropicContentGenerator-75BKLTSP.js → anthropicContentGenerator-LXUXMOE7.js}

@@ -33,8 +33,12 @@ import {
   setToolCallPreparations
 } from "./chunk-LS77BEZP.js";
 import {
-  reportAnthropicRequest
-} from "./chunk-LEH5C7FV.js";
+  reportAnthropicEvent,
+  reportAnthropicFollowingRequest,
+  reportAnthropicRequest,
+  reportAnthropicResponse
+} from "./chunk-FY3M44RD.js";
+import "./chunk-SQBYH7PX.js";
 import {
   normalizeMcpToolName
 } from "./chunk-46UV252V.js";
@@ -5089,12 +5093,13 @@ var AnthropicContentGenerator = class {
     try {
       const anthropicRequest = await this.buildRequest(request);
       runtimeDiagnostics.recordAnthropicWireRequest(anthropicRequest);
-      reportAnthropicRequest(anthropicRequest);
+      const telemetryAttempt = reportAnthropicRequest(anthropicRequest);
       const headers = this.buildPerRequestHeaders(anthropicRequest);
       response = await this.client.messages.create(anthropicRequest, {
         signal: perRequestAc?.signal,
         ...headers ? { headers } : {}
       });
+      reportAnthropicResponse(telemetryAttempt, response);
     } catch (error) {
       throw redactProxyError(error);
     } finally {
@@ -5110,7 +5115,7 @@ var AnthropicContentGenerator = class {
       stream: true
     };
     runtimeDiagnostics.recordAnthropicWireRequest(streamingRequest);
-    reportAnthropicRequest(streamingRequest);
+    const telemetryAttempt = reportAnthropicRequest(streamingRequest);
     const perRequestAc = createChildAbortController(
       request.config?.abortSignal
     );
@@ -5131,7 +5136,8 @@ var AnthropicContentGenerator = class {
       this.redactStreamErrors(stream),
       anthropicRequest,
       perRequestAc.signal,
-      headers
+      headers,
+      telemetryAttempt
     );
     async function* drainThenCleanup() {
       try {
@@ -5541,7 +5547,7 @@ var AnthropicContentGenerator = class {
       throw redactProxyError(error);
     }
   }
-  async *processStream(stream) {
+  async *processStream(stream, telemetryAttempt) {
     let messageId;
     let model;
     let cachedTokens = 0;
@@ -5569,6 +5575,7 @@ var AnthropicContentGenerator = class {
       });
     }, "takePendingMessageStartUsage");
     for await (const event of stream) {
+      reportAnthropicEvent(telemetryAttempt, event);
       switch (event.type) {
         case "message_start": {
           messageId = event.message.id ?? messageId;
@@ -5772,10 +5779,10 @@ var AnthropicContentGenerator = class {
   // limits hit mid-proxy). When that happens we probe once with the same
   // request in non-streaming mode so the real provider error surfaces
   // instead of the generic "stream ended without a finish reason".
-  async *processStreamWithEmptyFallback(stream, fallbackRequest, abortSignal, headers) {
+  async *processStreamWithEmptyFallback(stream, fallbackRequest, abortSignal, headers, telemetryAttempt) {
     let hasAssistantPayload = false;
     let hasFinishReason = false;
-    for await (const chunk of this.processStream(stream)) {
+    for await (const chunk of this.processStream(stream, telemetryAttempt)) {
       const candidates = chunk.candidates ?? [];
       hasFinishReason ||= candidates.some(
         (candidate) => candidate.finishReason !== void 0
@@ -5796,11 +5803,15 @@ var AnthropicContentGenerator = class {
     let response;
     try {
       runtimeDiagnostics.recordAnthropicWireRequest(fallbackRequest);
-      reportAnthropicRequest(fallbackRequest);
+      const fallbackAttempt = reportAnthropicFollowingRequest(
+        fallbackRequest,
+        telemetryAttempt
+      );
       response = await this.client.messages.create(fallbackRequest, {
         signal: abortSignal,
         ...headers ? { headers } : {}
       });
+      reportAnthropicResponse(fallbackAttempt, response);
       yield this.converter.convertAnthropicResponseToGemini(response);
     } catch (error) {
       throw redactProxyError(error);

package/chunks/{bridge-ZUB64FAE.js → bridge-LGPZCFHO.js}

@@ -6,18 +6,18 @@ import {
   createHttpAcpBridge,
   extractErrorCode,
   extractErrorMessage
-} from "./chunk-KIM5GUMA.js";
+} from "./chunk-66RMLJHC.js";
 import "./chunk-GLWP3FDB.js";
-import "./chunk-UH3WSE5L.js";
 import "./chunk-COH43MRJ.js";
 import "./chunk-3SJ43L4W.js";
-import "./chunk-7JURR4JT.js";
-import "./chunk-VIA5XA4U.js";
+import "./chunk-UH3WSE5L.js";
+import "./chunk-A6UO2C7C.js";
+import "./chunk-KU5XMLDK.js";
 import "./chunk-2RFKHEXL.js";
 import "./chunk-BK2UNYWD.js";
 import "./chunk-M5GB774H.js";
 import "./chunk-UDXSXLER.js";
-import "./chunk-PHOF65IG.js";
+import "./chunk-DM4Q4JJH.js";
 import "./chunk-5M6IDOMF.js";
 import "./chunk-TWPJO254.js";
 import "./chunk-H6XPXXMH.js";
@@ -30,7 +30,7 @@ import "./chunk-ZOIFNCKL.js";
 import "./chunk-PWTZEM3C.js";
 import "./chunk-KRXPRVGL.js";
 import "./chunk-6PVPNMXU.js";
-import "./chunk-MZAXJAUM.js";
+import "./chunk-PSWQZHEA.js";
 import "./chunk-SZRN75WQ.js";
 import "./chunk-HTO4JFDZ.js";
 import "./chunk-CPBF7KYF.js";
@@ -50,16 +50,17 @@ import "./chunk-XVNQMZ2I.js";
 import "./chunk-FODK6UMO.js";
 import "./chunk-GLNBDYUX.js";
 import "./chunk-DJ2GSRLV.js";
-import "./chunk-ZJHVAS7M.js";
-import "./chunk-NIBLUX3Y.js";
+import "./chunk-YAF5VNU7.js";
+import "./chunk-BO4XCS7P.js";
 import "./chunk-BPJSQIJX.js";
 import "./chunk-P3QQPMQA.js";
 import "./chunk-6FGBXPWM.js";
 import "./chunk-LS77BEZP.js";
-import "./chunk-CIKQ7KKO.js";
+import "./chunk-SQBYH7PX.js";
+import "./chunk-RWS5VYWC.js";
 import "./chunk-VGC4I5JJ.js";
 import "./chunk-MUP3T3AD.js";
-import "./chunk-IKCX4CCL.js";
+import "./chunk-U7TXFVUN.js";
 import "./chunk-46UV252V.js";
 import "./chunk-A4UCTEB5.js";
 import "./chunk-XWRJCPHC.js";
@@ -67,9 +68,9 @@ import "./chunk-UW5EOVUN.js";
 import "./chunk-2JZBVYTU.js";
 import "./chunk-5I2IWRSH.js";
 import "./chunk-A5L3JMUA.js";
-import "./chunk-MB4MZHMJ.js";
-import "./chunk-HTR4WV6U.js";
-import "./chunk-BULDBTYC.js";
+import "./chunk-SRZ6DXVG.js";
+import "./chunk-W4RQUHY3.js";
+import "./chunk-INADJJGW.js";
 import "./chunk-U7ZFW55U.js";
 import "./chunk-UUUTRMI2.js";
 import "./chunk-PR75REBZ.js";

package/chunks/channel-management-service-G74LFADV.js

@@ -0,0 +1,403 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  resolveChannelCwd
+} from "./chunk-W4CQXHT6.js";
+import {
+  getPlugin
+} from "./chunk-MK7VQDN3.js";
+import {
+  canonicalizeWorkspace
+} from "./chunk-2RFKHEXL.js";
+import {
+  normalizeWorkerDiagnostic
+} from "./chunk-HV3G62R6.js";
+import {
+  isAllChannelSelectionName
+} from "./chunk-ALMR3E6Q.js";
+import {
+  redactLogCredentials
+} from "./chunk-M5GB774H.js";
+import {
+  PairingStore,
+  sanitizeLogText
+} from "./chunk-ML52PL6O.js";
+import "./chunk-UDXSXLER.js";
+import "./chunk-TWPJO254.js";
+import "./chunk-H6XPXXMH.js";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/cli/src/serve/channel-management-service.ts
+init_esbuild_shims();
+var ChannelManagementError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "ChannelManagementError";
+  }
+  static {
+    __name(this, "ChannelManagementError");
+  }
+};
+function diagnostic(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return sanitizeLogText(
+    redactLogCredentials(normalizeWorkerDiagnostic(message)),
+    512
+  );
+}
+__name(diagnostic, "diagnostic");
+function usesEnvironment(value) {
+  return typeof value === "string" && /^\$[A-Za-z_][A-Za-z0-9_]*$/.test(value);
+}
+__name(usesEnvironment, "usesEnvironment");
+function createChannelManagementService(opts) {
+  const diagnostics = /* @__PURE__ */ new Map();
+  let mutationTail = Promise.resolve();
+  const inMutationLane = /* @__PURE__ */ __name((mutation) => {
+    const result = mutationTail.then(mutation, mutation);
+    mutationTail = result.then(
+      () => void 0,
+      () => void 0
+    );
+    return result;
+  }, "inMutationLane");
+  const assertExpectedRevision = /* @__PURE__ */ __name((snapshot, expectedRevision) => {
+    if (snapshot.revision !== expectedRevision) {
+      throw new ChannelManagementError(
+        "channel_settings_conflict",
+        "Channel settings changed; reload before trying again."
+      );
+    }
+  }, "assertExpectedRevision");
+  const workerFor = /* @__PURE__ */ __name((name) => {
+    const matches = opts.manager.state().workers.filter(
+      (worker) => worker.adapters?.some((adapter) => adapter.name === name) || worker.requestedChannels?.includes(name) || worker.channels.includes(name)
+    );
+    return matches;
+  }, "workerFor");
+  const workspaceCommittedNames = /* @__PURE__ */ __name(() => opts.manager.committedChannelNames().filter(
+    (name) => workerFor(name).some((w) => w.workspaceCwd === opts.workspaceCwd)
+  ), "workspaceCommittedNames");
+  const assertOwnedRuntime = /* @__PURE__ */ __name((name) => {
+    if (!workspaceCommittedNames().includes(name)) return;
+    const workers = workerFor(name).filter(
+      (worker) => worker.workspaceCwd === opts.workspaceCwd
+    );
+    if (workers.length !== 1) {
+      throw new ChannelManagementError(
+        "channel_runtime_owner_mismatch",
+        `Channel "${name}" does not have one confirmed runtime owner in this workspace.`
+      );
+    }
+  }, "assertOwnedRuntime");
+  const runtimeFor = /* @__PURE__ */ __name((name) => {
+    const retainedError = diagnostics.get(name);
+    if (retainedError) return { state: "error", lastError: retainedError };
+    if (!workspaceCommittedNames().includes(name)) {
+      return { state: "stopped" };
+    }
+    const state = opts.manager.state();
+    const workers = workerFor(name).filter(
+      (worker2) => worker2.workspaceCwd === opts.workspaceCwd
+    );
+    if (workers.length !== 1) {
+      return {
+        state: "error",
+        lastError: "Channel runtime owner is unknown or ambiguous."
+      };
+    }
+    const worker = workers[0];
+    const adapter = worker.adapters?.find((item) => item.name === name);
+    if (adapter?.state === "connected") return { state: "connected" };
+    if (adapter?.state === "error") {
+      return {
+        state: "error",
+        ...adapter.error ? { lastError: diagnostic(adapter.error) } : {}
+      };
+    }
+    if (adapter?.state === "starting" || state.transition === "starting" || state.transition === "reconciling") {
+      return { state: "starting" };
+    }
+    if (worker.state === "running") return { state: "partial" };
+    return {
+      state: "error",
+      ...worker.error ? { lastError: diagnostic(worker.error) } : {}
+    };
+  }, "runtimeFor");
+  const instanceFrom = /* @__PURE__ */ __name(async (name, rawConfig, startupNames) => {
+    const type = typeof rawConfig["type"] === "string" ? rawConfig["type"] : "";
+    const plugin = type ? await getPlugin(type) : void 0;
+    if (!plugin?.management) {
+      return {
+        name,
+        config: type ? { type } : {},
+        secrets: {},
+        startsWithServe: startupNames.some(isAllChannelSelectionName) || startupNames.includes(name),
+        runtime: runtimeFor(name)
+      };
+    }
+    const secretKeys = new Set(
+      plugin.management.fields.filter((field) => field.kind === "secret").map((field) => field.key)
+    );
+    const config = {};
+    const secrets = {};
+    for (const [key, value] of Object.entries(rawConfig)) {
+      if (!secretKeys.has(key)) {
+        config[key] = value;
+        continue;
+      }
+      secrets[key] = {
+        present: value !== void 0,
+        ...value !== void 0 ? { source: usesEnvironment(value) ? "environment" : "literal" } : {}
+      };
+    }
+    for (const key of secretKeys) {
+      secrets[key] ??= { present: false };
+    }
+    return {
+      name,
+      config,
+      secrets,
+      startsWithServe: startupNames.some(isAllChannelSelectionName) || startupNames.includes(name),
+      runtime: runtimeFor(name)
+    };
+  }, "instanceFrom");
+  const listFrom = /* @__PURE__ */ __name(async (persisted) => {
+    const entries = await Promise.all(
+      Object.entries(persisted.channels).map(
+        async ([name, config]) => [
+          name,
+          await instanceFrom(name, config, persisted.startupNames)
+        ]
+      )
+    );
+    return {
+      revision: persisted.revision,
+      instances: Object.fromEntries(entries)
+    };
+  }, "listFrom");
+  const resultFor = /* @__PURE__ */ __name(async (name, persisted = opts.store.snapshot()) => {
+    const snapshot = await listFrom(persisted);
+    const instance = Object.hasOwn(snapshot.instances, name) ? snapshot.instances[name] : {
+      name,
+      config: {},
+      secrets: {},
+      startsWithServe: false,
+      runtime: runtimeFor(name)
+    };
+    return { snapshot, instance };
+  }, "resultFor");
+  const stopChannel = /* @__PURE__ */ __name((name) => opts.manager.setChannelEnabled(
+    { name, workspaceCwd: opts.workspaceCwd },
+    false
+  ), "stopChannel");
+  const assertManageableInstanceName = /* @__PURE__ */ __name((name) => {
+    if (isAllChannelSelectionName(name)) {
+      throw new ChannelManagementError(
+        "invalid_channel_instance_name",
+        'Channel instance name "all" is reserved for startup selection.'
+      );
+    }
+  }, "assertManageableInstanceName");
+  const assertWorkspaceConfig = /* @__PURE__ */ __name((config) => {
+    const rawCwd = config["cwd"];
+    if (typeof rawCwd !== "string") return;
+    const workspaceCwd = canonicalizeWorkspace(opts.workspaceCwd);
+    const channelCwd = canonicalizeWorkspace(
+      resolveChannelCwd(rawCwd, workspaceCwd)
+    );
+    if (channelCwd !== workspaceCwd) {
+      throw new ChannelManagementError(
+        "channel_workspace_mismatch",
+        "Channel workspace must match the selected workspace."
+      );
+    }
+  }, "assertWorkspaceConfig");
+  const pairingStoreFor = /* @__PURE__ */ __name((name) => {
+    assertManageableInstanceName(name);
+    const channels = opts.store.snapshot().channels;
+    if (!Object.hasOwn(channels, name)) {
+      throw new ChannelManagementError(
+        "channel_instance_not_found",
+        `Channel "${name}" is not configured in this workspace.`
+      );
+    }
+    const config = channels[name];
+    assertWorkspaceConfig(config);
+    if (config["senderPolicy"] !== "pairing") {
+      throw new ChannelManagementError(
+        "channel_pairing_not_enabled",
+        `Channel "${name}" does not use pairing mode.`
+      );
+    }
+    return new PairingStore(name, opts.workspaceCwd);
+  }, "pairingStoreFor");
+  const service = {
+    async list() {
+      return listFrom(opts.store.snapshot());
+    },
+    async upsert(name, request) {
+      assertManageableInstanceName(name);
+      assertWorkspaceConfig(request.config);
+      const active = workspaceCommittedNames().includes(name);
+      if (active) assertOwnedRuntime(name);
+      const persisted = await opts.store.upsert(name, request);
+      diagnostics.delete(name);
+      if (active) {
+        try {
+          await opts.manager.reloadWorkspace(opts.workspaceCwd, name);
+        } catch (error) {
+          diagnostics.set(name, diagnostic(error));
+          try {
+            await stopChannel(name);
+          } catch {
+          }
+        }
+      }
+      return resultFor(name, persisted);
+    },
+    async remove(name, request) {
+      assertManageableInstanceName(name);
+      const current = opts.store.snapshot();
+      if (!Object.hasOwn(current.channels, name)) {
+        throw new ChannelManagementError(
+          "channel_instance_not_found",
+          `Channel "${name}" is not configured in this workspace.`
+        );
+      }
+      assertWorkspaceConfig(current.channels[name]);
+      assertExpectedRevision(current, request.expectedRevision);
+      if (workspaceCommittedNames().includes(name)) {
+        assertOwnedRuntime(name);
+        await stopChannel(name);
+      }
+      const persisted = await opts.store.remove(name, request);
+      diagnostics.delete(name);
+      return resultFor(name, persisted);
+    },
+    async setStartup(name, request) {
+      assertManageableInstanceName(name);
+      const current = opts.store.snapshot();
+      if (!Object.hasOwn(current.channels, name)) {
+        throw new ChannelManagementError(
+          "channel_instance_not_found",
+          `Channel "${name}" is not configured in this workspace.`
+        );
+      }
+      assertWorkspaceConfig(current.channels[name]);
+      const startsAll = current.startupNames.some(isAllChannelSelectionName);
+      if (startsAll && request.enabled) {
+        assertExpectedRevision(current, request.expectedRevision);
+        return resultFor(name, current);
+      }
+      const startupNames = startsAll ? Object.keys(current.channels).filter(
+        (item) => !isAllChannelSelectionName(item) && item !== name
+      ) : request.enabled ? current.startupNames.includes(name) ? current.startupNames : [...current.startupNames, name] : current.startupNames.filter((item) => item !== name);
+      const persisted = await opts.store.setStartupNames(startupNames, {
+        expectedRevision: request.expectedRevision
+      });
+      return resultFor(name, persisted);
+    },
+    async start(name) {
+      assertManageableInstanceName(name);
+      const persisted = opts.store.snapshot();
+      if (!Object.hasOwn(persisted.channels, name)) {
+        throw new ChannelManagementError(
+          "channel_instance_not_found",
+          `Channel "${name}" is not configured in this workspace.`
+        );
+      }
+      assertWorkspaceConfig(persisted.channels[name]);
+      await opts.manager.setChannelEnabled(
+        { name, workspaceCwd: opts.workspaceCwd },
+        true
+      );
+      diagnostics.delete(name);
+      return resultFor(name, persisted);
+    },
+    async stop(name) {
+      assertManageableInstanceName(name);
+      const persisted = opts.store.snapshot();
+      if (!Object.hasOwn(persisted.channels, name)) {
+        throw new ChannelManagementError(
+          "channel_instance_not_found",
+          `Channel "${name}" is not configured in this workspace.`
+        );
+      }
+      assertWorkspaceConfig(persisted.channels[name]);
+      await opts.manager.setChannelEnabled(
+        { name, workspaceCwd: opts.workspaceCwd },
+        false
+      );
+      diagnostics.delete(name);
+      return resultFor(name, persisted);
+    },
+    async restart(name) {
+      assertManageableInstanceName(name);
+      const persisted = opts.store.snapshot();
+      if (!Object.hasOwn(persisted.channels, name)) {
+        throw new ChannelManagementError(
+          "channel_instance_not_found",
+          `Channel "${name}" is not configured in this workspace.`
+        );
+      }
+      assertWorkspaceConfig(persisted.channels[name]);
+      if (!workspaceCommittedNames().includes(name)) {
+        throw new ChannelManagementError(
+          "channel_worker_not_enabled",
+          `Channel "${name}" is not running.`
+        );
+      }
+      assertOwnedRuntime(name);
+      try {
+        await opts.manager.reloadWorkspace(opts.workspaceCwd, name);
+        diagnostics.delete(name);
+      } catch (error) {
+        diagnostics.set(name, diagnostic(error));
+        throw error;
+      }
+      return resultFor(name, persisted);
+    },
+    async pairingRequests(name) {
+      return { requests: pairingStoreFor(name).listPending() };
+    },
+    async approvePairing(name, code) {
+      const store = pairingStoreFor(name);
+      const approved = store.approve(code);
+      if (!approved) {
+        throw new ChannelManagementError(
+          "channel_pairing_request_not_found",
+          "Pairing request was not found or has expired."
+        );
+      }
+      return { approved, requests: store.listPending() };
+    }
+  };
+  return {
+    list: /* @__PURE__ */ __name(() => service.list(), "list"),
+    upsert: /* @__PURE__ */ __name((name, request) => inMutationLane(() => service.upsert(name, request)), "upsert"),
+    remove: /* @__PURE__ */ __name((name, request) => inMutationLane(() => service.remove(name, request)), "remove"),
+    setStartup: /* @__PURE__ */ __name((name, request) => inMutationLane(() => service.setStartup(name, request)), "setStartup"),
+    start: /* @__PURE__ */ __name((name) => inMutationLane(() => service.start(name)), "start"),
+    stop: /* @__PURE__ */ __name((name) => inMutationLane(() => service.stop(name)), "stop"),
+    restart: /* @__PURE__ */ __name((name) => inMutationLane(() => service.restart(name)), "restart"),
+    pairingRequests: /* @__PURE__ */ __name((name) => service.pairingRequests(name), "pairingRequests"),
+    approvePairing: /* @__PURE__ */ __name((name, code) => inMutationLane(() => service.approvePairing(name, code)), "approvePairing")
+  };
+}
+__name(createChannelManagementService, "createChannelManagementService");
+export {
+  ChannelManagementError,
+  createChannelManagementService
+};
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */