@qwen-code/qwen-code 0.19.5 → 0.19.6

package/chunks/record-artifact-URK3YUDJ.js

@@ -0,0 +1,343 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  BaseDeclarativeTool,
+  BaseToolInvocation,
+  ToolDisplayNames,
+  ToolNames
+} from "./chunk-MJKMIQMK.js";
+import "./chunk-AVQDCKNF.js";
+import "./chunk-Z2Z3GUXZ.js";
+import {
+  init_esbuild_shims
+} from "./chunk-A4BMJM77.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/core/src/tools/record-artifact.ts
+init_esbuild_shims();
+import path from "node:path";
+var DESCRIPTION = `Registers a session artifact so clients can show it in an artifacts panel. Use it after creating a useful file, URL, image, report, notebook, or other intermediate result that the user may want to open later.
+
+This tool only records metadata. It does not publish, upload, read, write, or verify the referenced resource. Provide exactly one locator: workspacePath, managedId, or url. Use the Artifact tool, not record_artifact, for published interactive HTML artifacts.`;
+var RecordArtifactInvocation = class extends BaseToolInvocation {
+  static {
+    __name(this, "RecordArtifactInvocation");
+  }
+  getDescription() {
+    return `Recording artifact ${this.params.title}`;
+  }
+  execute(_signal) {
+    const artifact = {
+      title: this.params.title.trim(),
+      kind: this.params.kind,
+      storage: this.params.storage ?? inferStorage(this.params),
+      description: trimOptional(this.params.description),
+      workspacePath: trimOptional(this.params.workspacePath),
+      managedId: trimOptional(this.params.managedId),
+      url: trimOptional(this.params.url),
+      mimeType: trimOptional(this.params.mimeType),
+      sizeBytes: this.params.sizeBytes,
+      metadata: this.params.metadata
+    };
+    return Promise.resolve({
+      llmContent: `Recorded artifact "${artifact.title}".`,
+      returnDisplay: `Recorded artifact **${artifact.title}**.`,
+      artifacts: [artifact]
+    });
+  }
+};
+var RecordArtifactTool = class _RecordArtifactTool extends BaseDeclarativeTool {
+  static {
+    __name(this, "RecordArtifactTool");
+  }
+  static Name = ToolNames.RECORD_ARTIFACT;
+  constructor() {
+    super(
+      _RecordArtifactTool.Name,
+      ToolDisplayNames.RECORD_ARTIFACT,
+      DESCRIPTION,
+      "other" /* Other */,
+      {
+        type: "object",
+        properties: {
+          title: {
+            type: "string",
+            description: "Concise title shown in the client artifact list."
+          },
+          kind: {
+            type: "string",
+            enum: [
+              "file",
+              "link",
+              "html",
+              "image",
+              "video",
+              "audio",
+              "pdf",
+              "notebook",
+              "other"
+            ],
+            description: "Best-effort artifact type for client rendering."
+          },
+          storage: {
+            type: "string",
+            enum: ["workspace", "external_url", "managed"],
+            description: "Storage class. Omit it to infer from the provided locator."
+          },
+          description: {
+            type: "string",
+            description: "Optional short description for the user."
+          },
+          workspacePath: {
+            type: "string",
+            description: "Workspace-relative path for a file produced in the current workspace."
+          },
+          managedId: {
+            type: "string",
+            description: "Opaque identifier for a resource managed by an extension or tool."
+          },
+          url: {
+            type: "string",
+            description: "HTTP or HTTPS URL that the user can open for details."
+          },
+          mimeType: {
+            type: "string",
+            description: "Optional MIME type."
+          },
+          sizeBytes: {
+            type: "integer",
+            minimum: 0,
+            description: "Optional size in bytes."
+          },
+          metadata: {
+            type: "object",
+            additionalProperties: {
+              anyOf: [
+                { type: "string" },
+                { type: "number" },
+                { type: "boolean" },
+                { type: "null" }
+              ]
+            },
+            description: "Small primitive metadata bag for client-specific display hints."
+          }
+        },
+        required: ["title"]
+      },
+      true,
+      false,
+      true,
+      false,
+      "artifact url link file image report notebook dashboard"
+    );
+  }
+  validateToolParamValues(params) {
+    params.title = (params.title ?? "").trim();
+    const titleError = validateString(params.title, "title", 200, true);
+    if (titleError) {
+      return titleError;
+    }
+    const descriptionError = validateString(
+      params.description,
+      "description",
+      1e3,
+      false
+    );
+    if (descriptionError) {
+      return descriptionError;
+    }
+    const mimeTypeError = validateString(
+      params.mimeType,
+      "mimeType",
+      120,
+      false
+    );
+    if (mimeTypeError) {
+      return mimeTypeError;
+    }
+    if (params.kind && !isArtifactKind(params.kind)) {
+      return '"kind" must be a supported artifact kind';
+    }
+    if (params.storage && params.storage !== "workspace" && params.storage !== "external_url" && params.storage !== "managed") {
+      return '"storage" must be workspace, external_url, or managed';
+    }
+    const locators = [
+      trimOptional(params.workspacePath),
+      trimOptional(params.managedId),
+      trimOptional(params.url)
+    ].filter(Boolean);
+    if (locators.length !== 1) {
+      return 'Provide exactly one of "workspacePath", "managedId", or "url"';
+    }
+    const inferredStorage = inferStorage(params);
+    if (params.storage && params.storage !== inferredStorage) {
+      return `"storage" must be "${inferredStorage}" for the provided locator`;
+    }
+    if (params.workspacePath) {
+      const workspacePathError = validateWorkspacePath(params.workspacePath);
+      if (workspacePathError) {
+        return workspacePathError;
+      }
+    }
+    if (params.managedId) {
+      const managedIdError = validateManagedId(params.managedId);
+      if (managedIdError) {
+        return managedIdError;
+      }
+    }
+    if (params.url) {
+      try {
+        const parsed = new URL(params.url);
+        if (parsed.username || parsed.password) {
+          return '"url" must not include credentials';
+        }
+        if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+          return '"url" must use http or https';
+        }
+      } catch {
+        return '"url" must be a valid URL';
+      }
+    }
+    if (params.sizeBytes !== void 0 && (!Number.isSafeInteger(params.sizeBytes) || params.sizeBytes < 0)) {
+      return '"sizeBytes" must be a non-negative safe integer';
+    }
+    const metadataError = validateMetadata(params.metadata);
+    if (metadataError) {
+      return metadataError;
+    }
+    return null;
+  }
+  createInvocation(params) {
+    return new RecordArtifactInvocation(params);
+  }
+};
+function inferStorage(params) {
+  if (trimOptional(params.workspacePath)) {
+    return "workspace";
+  }
+  if (trimOptional(params.managedId)) {
+    return "managed";
+  }
+  return "external_url";
+}
+__name(inferStorage, "inferStorage");
+function trimOptional(value) {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : void 0;
+}
+__name(trimOptional, "trimOptional");
+function validateString(value, field, maxLength, required) {
+  const trimmed = value?.trim();
+  if (!trimmed) {
+    return required ? `Missing or empty "${field}"` : null;
+  }
+  if (trimmed.length > maxLength) {
+    return `"${field}" exceeds ${maxLength} characters`;
+  }
+  if (hasControlCharacter(trimmed, field === "description")) {
+    return `"${field}" contains control characters`;
+  }
+  if (isDisplayField(field) && hasUnsafeDisplayPayload(trimmed)) {
+    return `"${field}" contains unsafe markup`;
+  }
+  return null;
+}
+__name(validateString, "validateString");
+function validateManagedId(value) {
+  const trimmed = value.trim();
+  const stringError = validateString(trimmed, "managedId", 200, true);
+  if (stringError) {
+    return stringError;
+  }
+  if (trimmed.includes("/") || trimmed.includes("\\") || trimmed.includes("..") || path.isAbsolute(trimmed) || path.win32.isAbsolute(trimmed)) {
+    return '"managedId" must be an opaque managed resource id';
+  }
+  return null;
+}
+__name(validateManagedId, "validateManagedId");
+function isDisplayField(field) {
+  return field === "title" || field === "description" || field === "mimeType" || field === "workspacePath" || field === "managedId";
+}
+__name(isDisplayField, "isDisplayField");
+function hasControlCharacter(value, allowLineWhitespace = false) {
+  for (let i = 0; i < value.length; i++) {
+    const code = value.charCodeAt(i);
+    if (allowLineWhitespace && (code === 9 || code === 10 || code === 13)) {
+      continue;
+    }
+    if (code <= 31 || code === 127 || code >= 8203 && code <= 8207 || code === 8232 || code === 8233 || code >= 8234 && code <= 8238 || code >= 8294 && code <= 8297 || code === 65279) {
+      return true;
+    }
+  }
+  return false;
+}
+__name(hasControlCharacter, "hasControlCharacter");
+function hasUnsafeDisplayPayload(value) {
+  return /<\s*\/?[a-z!]|&(?:#[0-9]+|#x[0-9a-f]+|[a-z][a-z0-9]+);|javascript\s*:|data\s*:\s*(?:text\/(?:html|javascript)|application\/javascript|image\/svg\+xml)/i.test(
+    value
+  ) || /(?:^|[\s"'`<])on[a-z][a-z0-9-]*\s*=/i.test(value);
+}
+__name(hasUnsafeDisplayPayload, "hasUnsafeDisplayPayload");
+function validateWorkspacePath(value) {
+  const trimmed = value.trim();
+  const stringError = validateString(trimmed, "workspacePath", 500, true);
+  if (stringError) {
+    return stringError;
+  }
+  if (path.isAbsolute(trimmed)) {
+    return '"workspacePath" must be relative to the workspace';
+  }
+  const normalized = path.normalize(trimmed);
+  if (normalized === ".." || normalized.startsWith(`..${path.sep}`) || path.isAbsolute(normalized)) {
+    return '"workspacePath" must stay inside the workspace';
+  }
+  return null;
+}
+__name(validateWorkspacePath, "validateWorkspacePath");
+function validateMetadata(metadata) {
+  if (metadata === void 0) {
+    return null;
+  }
+  if (typeof metadata !== "object" || metadata === null || Array.isArray(metadata)) {
+    return '"metadata" must be an object';
+  }
+  for (const [key, value] of Object.entries(metadata)) {
+    if (!key) {
+      return '"metadata" keys must not be empty';
+    }
+    if (key.length > 120) {
+      return '"metadata" keys must be 120 characters or fewer';
+    }
+    if (hasControlCharacter(key) || hasUnsafeDisplayPayload(key)) {
+      return '"metadata" keys contain unsafe content';
+    }
+    if (value !== null && typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean") {
+      return '"metadata" values must be primitive';
+    }
+    if (typeof value === "number" && !Number.isFinite(value)) {
+      return '"metadata" numbers must be finite';
+    }
+    if (typeof value === "string" && (hasControlCharacter(value) || hasUnsafeDisplayPayload(value))) {
+      return '"metadata" string values contain unsafe content';
+    }
+  }
+  if (Buffer.byteLength(JSON.stringify(metadata), "utf8") > 4096) {
+    return '"metadata" must be 4096 bytes or fewer';
+  }
+  return null;
+}
+__name(validateMetadata, "validateMetadata");
+function isArtifactKind(kind) {
+  return kind === "file" || kind === "link" || kind === "html" || kind === "image" || kind === "video" || kind === "audio" || kind === "pdf" || kind === "notebook" || kind === "other";
+}
+__name(isArtifactKind, "isArtifactKind");
+export {
+  RecordArtifactTool
+};
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{ripGrep-DIUGLJE5.js → ripGrep-JD5O2FLX.js}

@@ -3,42 +3,42 @@
 import {
   RipGrepTool,
   _resetRipGrepCachesForTest
-} from "./chunk-6QTCOQX7.js";
+} from "./chunk-AGZF43UV.js";
 import "./chunk-5P5XGNYH.js";
-import "./chunk-K5PGHDBN.js";
 import "./chunk-SKAZWEV5.js";
+import "./chunk-K5PGHDBN.js";
+import "./chunk-CLQPBI4H.js";
 import "./chunk-QOMAHFYI.js";
 import "./chunk-G7OQ3RFJ.js";
 import "./chunk-LKWAVAB5.js";
-import "./chunk-L7OJ3ZO3.js";
-import "./chunk-R6RI2HIC.js";
+import "./chunk-5ES5YPED.js";
 import "./chunk-2MPVVENX.js";
 import "./chunk-ZTQ26VBE.js";
-import "./chunk-SJBIFVD2.js";
+import "./chunk-DMSNJDWG.js";
 import "./chunk-MLZQVCF3.js";
 import "./chunk-LQ7TMOCE.js";
 import "./chunk-E5A7LHNN.js";
-import "./chunk-BPFJQGY7.js";
+import "./chunk-LM3YCCZJ.js";
 import "./chunk-GO6LNQXT.js";
 import "./chunk-B236XPGF.js";
-import "./chunk-YXK4GPYO.js";
+import "./chunk-NVFJSIAX.js";
 import "./chunk-TOAUDIS7.js";
 import "./chunk-NPQWQYU6.js";
-import "./chunk-CHY5C5T4.js";
+import "./chunk-JN2VJ33O.js";
 import "./chunk-E6US47KI.js";
 import "./chunk-UWCTAVOD.js";
 import "./chunk-OFEVLU4C.js";
 import "./chunk-OMX7CUOE.js";
 import "./chunk-MOUXUCXQ.js";
 import "./chunk-BZHLWC6T.js";
-import "./chunk-DG573EOO.js";
-import "./chunk-MTNTVOJR.js";
+import "./chunk-RZORUN6X.js";
+import "./chunk-MJKMIQMK.js";
 import "./chunk-TENOUWY2.js";
 import "./chunk-GLPV75ES.js";
 import "./chunk-22IFUCVR.js";
 import "./chunk-T42ACHFI.js";
 import "./chunk-SIUQ3YYX.js";
-import "./chunk-YTFBURQD.js";
+import "./chunk-KYTQOCDE.js";
 import "./chunk-YPCPZSZB.js";
 import "./chunk-IRJWHZWU.js";
 import "./chunk-SYCJMSIJ.js";

package/chunks/{run-qwen-serve-CME3AKM4.js → run-qwen-serve-FADLRJUN.js}

@@ -3,6 +3,9 @@
 import {
   findCliEntryPath
 } from "./chunk-AHNXYU4O.js";
+import {
+  RUNTIME_STARTUP_CANCELLED_MESSAGE
+} from "./chunk-GHOTR7HL.js";
 import {
   CAPABILITIES_SCHEMA_VERSION,
   ClientMcpSenderRegistry,
@@ -23,36 +26,33 @@ import {
   positiveFiniteOrNull,
   require_express,
   resolveWebShellDir
-} from "./chunk-YCU7QV7Q.js";
+} from "./chunk-N4YJQTRL.js";
 import {
   isLoopbackBind
 } from "./chunk-RNBYOUGV.js";
 import "./chunk-3HX5LZ6R.js";
 import "./chunk-7RYW5LQV.js";
 import {
-  RUNTIME_STARTUP_CANCELLED_MESSAGE
-} from "./chunk-GHOTR7HL.js";
-import {
-  getCliVersion
-} from "./chunk-RSBQS6M4.js";
-import "./chunk-EWALXUAD.js";
-import {
-  canonicalizeWorkspace
-} from "./chunk-SEZC2725.js";
+  loadServeFastPathSettings,
+  preResolveServeFastPathHomeEnvOverrides
+} from "./chunk-DNV4FSN5.js";
 import {
   QWEN_SERVER_TOKEN_ENV
 } from "./chunk-S6RLAIUR.js";
 import {
   channelSelectionNames
 } from "./chunk-MX2YXRER.js";
-import {
-  loadServeFastPathSettings,
-  preResolveServeFastPathHomeEnvOverrides
-} from "./chunk-KKQWC6WS.js";
 import {
   getGlobalQwenDirLite,
   resolveConfigPathLite
-} from "./chunk-PPFWEV7G.js";
+} from "./chunk-4RQIB5UZ.js";
+import "./chunk-EWALXUAD.js";
+import {
+  canonicalizeWorkspace
+} from "./chunk-SEZC2725.js";
+import {
+  getCliVersion
+} from "./chunk-SL2P3JUA.js";
 import {
   writeStderrLine,
   writeStdoutLine
@@ -531,8 +531,8 @@ __name(withSettingsLock, "withSettingsLock");
 var channelWorkerRuntimePromise;
 async function loadChannelWorkerRuntime() {
   channelWorkerRuntimePromise ??= Promise.all([
-    import("./channel-worker-supervisor-EVPAYNZ5.js"),
-    import("./pidfile-FNZM2DDH.js")
+    import("./channel-worker-supervisor-JUYQ5Z4R.js"),
+    import("./pidfile-HFXSHR64.js")
   ]).then(([supervisor, pidfile]) => ({
     createChannelWorkerSupervisor: supervisor.createChannelWorkerSupervisor,
     channelServicePidfile: pidfile
@@ -603,7 +603,7 @@ function shouldPreheatBridge(deps) {
 __name(shouldPreheatBridge, "shouldPreheatBridge");
 var coreRuntimePromise;
 function loadCoreRuntime() {
-  coreRuntimePromise ??= import("./src-T5A7P7FS.js");
+  coreRuntimePromise ??= import("./src-HITDGVRM.js");
   return coreRuntimePromise;
 }
 __name(loadCoreRuntime, "loadCoreRuntime");
@@ -633,9 +633,9 @@ __name(resolveDaemonLogBaseDirForRun, "resolveDaemonLogBaseDirForRun");
 var settingsRuntimePromise;
 function loadSettingsRuntimeModules() {
   settingsRuntimePromise ??= Promise.all([
-    import("./settings-3EEQI4MN.js"),
-    import("./loadedSettingsAdapter-C63OUYZC.js"),
-    import("./trustedFolders-7HQY6T6X.js")
+    import("./settings-LC4CCWQQ.js"),
+    import("./loadedSettingsAdapter-XV74KOSR.js"),
+    import("./trustedFolders-JD4QX6UJ.js")
   ]).then(([settings, loadedSettingsAdapter, trustedFolders]) => ({
     settings,
     loadedSettingsAdapter,
@@ -655,14 +655,14 @@ async function loadServeRuntimeModules() {
     workspaceProvidersStatusModule,
     workspaceSkillsStatusModule
   ] = await Promise.all([
-    import("./server-QSQ45QFR.js"),
-    import("./bridge-DHZHQ4UV.js"),
-    import("./spawnChannel-3CBN3ZLK.js"),
-    import("./workspace-service-YOBYVDXH.js"),
+    import("./server-WKDQA6XR.js"),
+    import("./bridge-DF3IJQ5V.js"),
+    import("./spawnChannel-B6JJPBPV.js"),
+    import("./workspace-service-GX3GGZLU.js"),
     import("./types-QX5C3CHJ.js"),
-    import("./daemon-status-provider-P72STMLB.js"),
-    import("./workspace-providers-status-LJT5AQDS.js"),
-    import("./workspace-skills-status-ONEPXJV6.js")
+    import("./daemon-status-provider-2EWTHT7Y.js"),
+    import("./workspace-providers-status-XGW5OZTD.js"),
+    import("./workspace-skills-status-LFK5WV2V.js")
   ]);
   return {
     createServeApp: serverModule.createServeApp,
@@ -1445,6 +1445,7 @@ async function runQwenServe(optsIn, deps = {}) {
   let runtimeApp;
   let runtimeAppForCleanup;
   let bridgeRef = deps.bridge;
+  let daemonEventLoopMonitor;
   let runtimeStartupError;
   let runtimeStarting;
   let markRuntimeReady;
@@ -1459,6 +1460,10 @@ async function runQwenServe(optsIn, deps = {}) {
   });
   void runtimeReady.catch(() => {
   });
+  const disposeDaemonEventLoopMonitor = /* @__PURE__ */ __name(() => {
+    daemonEventLoopMonitor?.dispose();
+    daemonEventLoopMonitor = void 0;
+  }, "disposeDaemonEventLoopMonitor");
   let channelWorker = createDisabledChannelWorkerSupervisor();
   const getChannelWorkerSnapshot = /* @__PURE__ */ __name(() => channelWorker.snapshot(), "getChannelWorkerSnapshot");
   const writeChannelWorkerPidfile = /* @__PURE__ */ __name((snapshot = channelWorker.snapshot(), options = {}) => {
@@ -1532,6 +1537,27 @@ async function runQwenServe(optsIn, deps = {}) {
       )
     );
     core.initializeDaemonMetrics();
+    daemonEventLoopMonitor?.dispose();
+    daemonEventLoopMonitor = core.startEventLoopLagMonitor({
+      onNewMaxStall: /* @__PURE__ */ __name((maxMs) => {
+        daemonLog.warn("daemon event loop stall detected", { maxMs });
+      }, "onNewMaxStall")
+    });
+    const currentDaemonEventLoopMonitor = daemonEventLoopMonitor;
+    core.registerDaemonEventLoopLagGauge(
+      () => currentDaemonEventLoopMonitor.snapshot()
+    );
+    const pipeStats = {
+      inbound: { count: 0, totalBytes: 0, maxBytes: 0 },
+      outbound: { count: 0, totalBytes: 0, maxBytes: 0 }
+    };
+    const recordPipeMessage = /* @__PURE__ */ __name((direction, bytes) => {
+      const stats = pipeStats[direction];
+      stats.count += 1;
+      stats.totalBytes += bytes;
+      stats.maxBytes = Math.max(stats.maxBytes, bytes);
+      core.recordDaemonPipeMessage(direction, bytes);
+    }, "recordPipeMessage");
     const daemonTelemetry = core.createDaemonBridgeTelemetry();
     daemonTelemetry.metrics = {
       sessionLifecycle(action) {
@@ -1577,6 +1603,10 @@ async function runQwenServe(optsIn, deps = {}) {
     });
     const channelFactory = runtime.createSpawnChannelFactory({
       onDiagnosticLine: diagnosticSink,
+      pipeHooks: {
+        onMessageSent: /* @__PURE__ */ __name((bytes) => recordPipeMessage("outbound", bytes), "onMessageSent"),
+        onMessageReceived: /* @__PURE__ */ __name((bytes) => recordPipeMessage("inbound", bytes), "onMessageReceived")
+      },
       ...opts.experimentalLsp === true ? { extraArgs: ["--experimental-lsp"] } : {}
     });
     const statusProvider = runtime.createDaemonStatusProvider();
@@ -1697,6 +1727,13 @@ async function runQwenServe(optsIn, deps = {}) {
       fsFactory,
       daemonLog,
       getChannelWorkerSnapshot,
+      getPerfSnapshot: /* @__PURE__ */ __name(() => ({
+        eventLoop: currentDaemonEventLoopMonitor.snapshot(),
+        pipe: {
+          inbound: { ...pipeStats.inbound },
+          outbound: { ...pipeStats.outbound }
+        }
+      }), "getPerfSnapshot"),
       workspace: workspaceService,
       // Reverse tool channel (#5626): the SAME registry wired into `bridge` above,
       // so the WS provider and the child-answering bridge share one sender map.
@@ -1951,6 +1988,7 @@ async function runQwenServe(optsIn, deps = {}) {
         writeStderrLine(`qwen serve: runtime startup failed: ${message}`);
         daemonLog.error("runtime startup failed", error);
         await stopChannelWorkerAfterFailedStartup();
+        disposeDaemonEventLoopMonitor();
         removeCurrentServePidfile();
         await shutdownBridgeAfterFailedStartup(bridgeForCleanup ?? bridgeRef);
         markRuntimeFailed(error);
@@ -2163,6 +2201,7 @@ async function runQwenServe(optsIn, deps = {}) {
                 rl.setDraining(true);
                 rl.dispose();
               }
+              disposeDaemonEventLoopMonitor();
               await channelWorker.stop().catch((err) => {
                 daemonLog.error(
                   "channel worker stop error",

package/chunks/{scheduler-L7F6GDDT.js → scheduler-Q65SB7DJ.js}

@@ -6,42 +6,42 @@ import {
 import {
   FILE_HISTORY_DIR,
   getSubagentsRootDir
-} from "./chunk-6QTCOQX7.js";
+} from "./chunk-AGZF43UV.js";
 import "./chunk-5P5XGNYH.js";
-import "./chunk-K5PGHDBN.js";
 import "./chunk-SKAZWEV5.js";
+import "./chunk-K5PGHDBN.js";
+import "./chunk-CLQPBI4H.js";
 import "./chunk-QOMAHFYI.js";
 import "./chunk-G7OQ3RFJ.js";
 import "./chunk-LKWAVAB5.js";
-import "./chunk-L7OJ3ZO3.js";
-import "./chunk-R6RI2HIC.js";
+import "./chunk-5ES5YPED.js";
 import "./chunk-2MPVVENX.js";
 import "./chunk-ZTQ26VBE.js";
-import "./chunk-SJBIFVD2.js";
+import "./chunk-DMSNJDWG.js";
 import "./chunk-MLZQVCF3.js";
 import "./chunk-LQ7TMOCE.js";
 import "./chunk-E5A7LHNN.js";
-import "./chunk-BPFJQGY7.js";
+import "./chunk-LM3YCCZJ.js";
 import "./chunk-GO6LNQXT.js";
 import "./chunk-B236XPGF.js";
-import "./chunk-YXK4GPYO.js";
+import "./chunk-NVFJSIAX.js";
 import "./chunk-TOAUDIS7.js";
 import "./chunk-NPQWQYU6.js";
-import "./chunk-CHY5C5T4.js";
+import "./chunk-JN2VJ33O.js";
 import "./chunk-E6US47KI.js";
 import "./chunk-UWCTAVOD.js";
 import "./chunk-OFEVLU4C.js";
 import "./chunk-OMX7CUOE.js";
 import "./chunk-MOUXUCXQ.js";
 import "./chunk-BZHLWC6T.js";
-import "./chunk-DG573EOO.js";
-import "./chunk-MTNTVOJR.js";
+import "./chunk-RZORUN6X.js";
+import "./chunk-MJKMIQMK.js";
 import "./chunk-TENOUWY2.js";
 import "./chunk-GLPV75ES.js";
 import "./chunk-22IFUCVR.js";
 import "./chunk-T42ACHFI.js";
 import "./chunk-SIUQ3YYX.js";
-import "./chunk-YTFBURQD.js";
+import "./chunk-KYTQOCDE.js";
 import "./chunk-YPCPZSZB.js";
 import "./chunk-IRJWHZWU.js";
 import "./chunk-SYCJMSIJ.js";

package/chunks/{send-message-33PYFMCT.js → send-message-L7OLQEKH.js}

@@ -6,7 +6,7 @@ import {
 import {
   getPlanRequiredTeammatePreApprovalMessage,
   isPlanRequiredTeammateAwaitingApproval
-} from "./chunk-BPFJQGY7.js";
+} from "./chunk-LM3YCCZJ.js";
 import {
   getAgentName,
   isTeammate
@@ -16,7 +16,7 @@ import {
   BaseToolInvocation,
   ToolDisplayNames,
   ToolNames
-} from "./chunk-MTNTVOJR.js";
+} from "./chunk-MJKMIQMK.js";
 import "./chunk-AVQDCKNF.js";
 import "./chunk-Z2Z3GUXZ.js";
 import {