@qwen-code/qwen-code 0.23.3 → 0.23.4-dev.codemode-responses.20260914.87437db784

package/chunks/{chunk-3BTSSIJO.js → chunk-3DOAKZYD.js}

@@ -4,22 +4,23 @@ import {
   OpenAIContentConverter,
   TaggedThinkingParser,
   openaiRequestCaptureContext
-} from "./chunk-MOS5OAOG.js";
+} from "./chunk-SROLVJFY.js";
 import {
   applyOfficialOpenAIPromptCaching,
-  isOfficialOpenAIEndpoint
-} from "./chunk-SAH4BD2J.js";
+  isOfficialOpenAIEndpoint,
+  trailingReattachPartCount
+} from "./chunk-WFNEY5G7.js";
 import {
   DashScopeOpenAICompatibleProvider,
   DefaultOpenAICompatibleProvider,
   isOpenRouterHostname
-} from "./chunk-CXTPVBFA.js";
+} from "./chunk-GSS4SZNG.js";
 import {
   getCurrentAgentId
-} from "./chunk-U7O65WKL.js";
+} from "./chunk-BW2SMO6L.js";
 import {
   isInForkExecution
-} from "./chunk-FN3JNDRU.js";
+} from "./chunk-VVI7MK3V.js";
 import {
   extractTextFromContents
 } from "./chunk-AYEJOTIU.js";
@@ -36,8 +37,9 @@ import {
 } from "./chunk-VNOVK4I7.js";
 import {
   InvalidStreamError,
-  getToolCallPreparations
-} from "./chunk-CFKIH3D3.js";
+  getToolCallPreparations,
+  markFlushedToolCallPark
+} from "./chunk-S7UQ3V2H.js";
 import {
   safeJsonParse
 } from "./chunk-GSKX53AN.js";
@@ -47,7 +49,7 @@ import {
 import {
   getRateLimitErrorDetails,
   getTransportCode
-} from "./chunk-4ALNJDHL.js";
+} from "./chunk-ZKIAGIGH.js";
 import {
   reportOpenAiChunk,
   reportOpenAiRequest,
@@ -56,17 +58,17 @@ import {
 import {
   ProtocolTagSanitizedEvent,
   logProtocolTagSanitized
-} from "./chunk-HBU7EKY4.js";
+} from "./chunk-NRUKL236.js";
 import {
   isQwenFamilyWireModel,
   isTieredEffortWireModel
-} from "./chunk-ZHKTKHMO.js";
+} from "./chunk-7MIBD3LG.js";
 import {
   REASONING_EFFORT_TIERS,
   getGptReasoningCapabilities,
   isReasoningEffortPlaceholder,
   parseModelReasoningCapabilities
-} from "./chunk-3FPYT6QC.js";
+} from "./chunk-ARDHE6MM.js";
 import {
   reconcileMaxTokens
 } from "./chunk-FPGTNKCP.js";
@@ -476,6 +478,49 @@ var CerebrasOpenAICompatibleProvider = class extends DefaultOpenAICompatibleProv
   }
 };
 
+// packages/core/src/core/openaiContentGenerator/provider/fireworks.ts
+init_esbuild_shims();
+var FIREWORKS_API_HOST = "api.fireworks.ai";
+function isFireworksProvider(config) {
+  const baseUrl = config.baseUrl ?? "";
+  if (!baseUrl) return false;
+  try {
+    const hostname = new URL(baseUrl).hostname.toLowerCase();
+    return hostname === FIREWORKS_API_HOST || hostname.endsWith(`.${FIREWORKS_API_HOST}`);
+  } catch {
+    return false;
+  }
+}
+__name(isFireworksProvider, "isFireworksProvider");
+var FireworksOpenAICompatibleProvider = class extends DefaultOpenAICompatibleProvider {
+  static {
+    __name(this, "FireworksOpenAICompatibleProvider");
+  }
+  static isFireworksProvider = isFireworksProvider;
+  buildRequest(request, userPromptId) {
+    const baseRequest = super.buildRequest(request, userPromptId);
+    return {
+      ...baseRequest,
+      messages: baseRequest.messages.map(unmirrorReasoningField)
+    };
+  }
+};
+function unmirrorReasoningField(message) {
+  if (message.role !== "assistant") {
+    return message;
+  }
+  const assistant = message;
+  if (assistant.reasoning !== assistant.reasoning_content) {
+    return message;
+  }
+  if (typeof assistant.reasoning !== "string") {
+    return message;
+  }
+  const { reasoning: _drop, ...rest } = assistant;
+  return rest;
+}
+__name(unmirrorReasoningField, "unmirrorReasoningField");
+
 // packages/core/src/core/openaiContentGenerator/provider/mimo.ts
 init_esbuild_shims();
 function isMiMoProvider(contentGeneratorConfig) {
@@ -1118,6 +1163,14 @@ function isSSECompatibleContentType(contentType) {
   return mediaType === "text/event-stream" || mediaType === "application/x-ndjson" || mediaType === "application/stream+json";
 }
 __name(isSSECompatibleContentType, "isSSECompatibleContentType");
+function hasNonThoughtCandidateParts(response) {
+  return Boolean(
+    response.candidates?.some(
+      (candidate) => candidate.content?.parts?.some((part) => !part.thought)
+    )
+  );
+}
+__name(hasNonThoughtCandidateParts, "hasNonThoughtCandidateParts");
 var NonSSEResponseError = class extends Error {
   constructor(contentType, httpStatus, bodyPrefix, requestId) {
     const preview = bodyPrefix.length > 0 ? ` Body prefix: ${bodyPrefix}` : "";
@@ -1293,6 +1346,7 @@ var ContentGenerationPipeline = class {
   async *processStreamWithLogging(stream, context, request, userPromptId, telemetryAttempt) {
     let pendingFinishResponse = null;
     let finishYielded = false;
+    let contentYielded = request.continuationInFlight === true;
     let pendingFinishProtocolTagSanitized;
     const logPendingProtocolTagSanitized = /* @__PURE__ */ __name((response, sanitization) => {
       if (!sanitization) return;
@@ -1364,9 +1418,10 @@ var ContentGenerationPipeline = class {
               pendingFinishResponse,
               pendingFinishProtocolTagSanitized
             );
-            yield pendingFinishResponse;
             finishYielded = true;
+            yield pendingFinishResponse;
           } else {
+            contentYielded ||= hasNonThoughtCandidateParts(response);
             logPendingProtocolTagSanitized(response, sanitization);
             yield response;
           }
@@ -1384,6 +1439,7 @@ var ContentGenerationPipeline = class {
               index: 0
             }
           ];
+          contentYielded ||= hasNonThoughtCandidateParts(response);
           yield response;
         }
       } else if (context.pendingThinkingTagCandidate || context.responseParsingOptions?.taggedThinkingTagsAfterReasoning && context.taggedThinkingParser?.hasUnclosedThought()) {
@@ -1397,12 +1453,33 @@ var ContentGenerationPipeline = class {
           pendingFinishResponse,
           pendingFinishProtocolTagSanitized
         );
+        finishYielded = true;
         yield pendingFinishResponse;
       }
     } catch (error) {
       if (error instanceof InvalidStreamError) {
         throw error;
       }
+      const parked = pendingFinishResponse;
+      const parkedHasToolCall = parked?.candidates?.some(
+        (candidate) => candidate.content?.parts?.some((part) => part.functionCall)
+      );
+      if (pendingFinishResponse && !finishYielded && // A cancellation is not a stream failure to recover from: synthesising
+      // a delivery here hands the consumer a finish it was never shown, and
+      // cancellation persistence keeps whatever the consumer received.
+      // Spelled exactly as the PROTOCOL_TAG_LEAK branch below spells it, so
+      // one catch does not hold two notions of "aborted".
+      request.config?.abortSignal?.aborted !== true && (!parkedHasToolCall || contentYielded)) {
+        logPendingProtocolTagSanitized(
+          pendingFinishResponse,
+          pendingFinishProtocolTagSanitized
+        );
+        if (parkedHasToolCall) {
+          markFlushedToolCallPark(pendingFinishResponse);
+        }
+        yield pendingFinishResponse;
+        finishYielded = true;
+      }
       if (error instanceof StreamContentError) {
         throw redactProxyError(error);
       }
@@ -1528,7 +1605,8 @@ var ContentGenerationPipeline = class {
     }
     let providerRequest = this.config.provider.buildRequest(
       baseRequest,
-      userPromptId
+      userPromptId,
+      trailingReattachPartCount(request.contents)
     );
     if (this.contentGeneratorConfig.enableCacheControl !== false && isOfficialOpenAIEndpoint(this.contentGeneratorConfig)) {
       providerRequest = applyOfficialOpenAIPromptCaching(
@@ -2018,6 +2096,12 @@ function determineProvider(contentGeneratorConfig, cliConfig) {
       cliConfig
     );
   }
+  if (FireworksOpenAICompatibleProvider.isFireworksProvider(config)) {
+    return new FireworksOpenAICompatibleProvider(
+      contentGeneratorConfig,
+      cliConfig
+    );
+  }
   return new DefaultOpenAICompatibleProvider(contentGeneratorConfig, cliConfig);
 }
 __name(determineProvider, "determineProvider");
@@ -2027,6 +2111,7 @@ export {
   MiniMaxOpenAICompatibleProvider,
   MistralOpenAICompatibleProvider,
   CerebrasOpenAICompatibleProvider,
+  FireworksOpenAICompatibleProvider,
   MiMoOpenAICompatibleProvider,
   ContentGenerationPipeline,
   EnhancedErrorHandler,

package/chunks/{chunk-F53KKZUD.js → chunk-3LMDSCLU.js}

@@ -21,6 +21,14 @@ import {
 init_esbuild_shims();
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
+var MAX_CRON_TASK_ROUTING_ID_LENGTH = 256;
+function isValidCronTaskRoutingId(value) {
+  return typeof value === "string" && value.length > 0 && value.length <= MAX_CRON_TASK_ROUTING_ID_LENGTH && !Array.from(value).some((character) => {
+    const code = character.charCodeAt(0);
+    return code <= 31 || code === 127;
+  });
+}
+__name(isValidCronTaskRoutingId, "isValidCronTaskRoutingId");
 var MAX_TASK_RUNS = 20;
 var MAX_CHANNEL_DELIVERY_NAME_LENGTH = 2048;
 var MAX_CHANNEL_DELIVERY_TARGET_ID_LENGTH = 2048;
@@ -68,6 +76,7 @@ var UPDATE_LOCK_STALE_MS = 2e3;
 var UPDATE_LOCK_TIMEOUT_MS = 3e3;
 var updateStaleSeq = 0;
 var updateMutexes = /* @__PURE__ */ new Map();
+var MAX_TASK_DELETION_GENERATIONS = 1e4;
 function getUpdateMutex(filePath) {
   let mutex = updateMutexes.get(filePath);
   if (!mutex) {
@@ -77,6 +86,60 @@ function getUpdateMutex(filePath) {
   return mutex;
 }
 __name(getUpdateMutex, "getUpdateMutex");
+async function readTaskDeletionGenerations(filePath) {
+  const statePath = `${filePath}.deletions`;
+  let raw;
+  try {
+    raw = await fs.readFile(statePath, "utf-8");
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return { generations: /* @__PURE__ */ new Map(), watermark: 0 };
+    }
+    throw error;
+  }
+  const parsed = JSON.parse(raw);
+  if (parsed.version !== 2 || !Number.isSafeInteger(parsed.watermark) || parsed.watermark < 0 || !Array.isArray(parsed.entries)) {
+    throw new Error(`Invalid scheduled-task deletion state: ${statePath}`);
+  }
+  const generations = /* @__PURE__ */ new Map();
+  let maximumGeneration = 0;
+  for (const entry of parsed.entries) {
+    if (!Array.isArray(entry) || entry.length !== 2 || typeof entry[0] !== "string" || !Number.isSafeInteger(entry[1]) || entry[1] < 1 || generations.has(entry[0])) {
+      throw new Error(`Invalid scheduled-task deletion state: ${statePath}`);
+    }
+    generations.set(entry[0], entry[1]);
+    maximumGeneration = Math.max(maximumGeneration, entry[1]);
+  }
+  const watermark = parsed.watermark;
+  if (watermark < maximumGeneration) {
+    throw new Error(`Invalid scheduled-task deletion state: ${statePath}`);
+  }
+  return { generations, watermark };
+}
+__name(readTaskDeletionGenerations, "readTaskDeletionGenerations");
+async function readTaskDeletionGenerationsOrUnknown(filePath) {
+  try {
+    return await readTaskDeletionGenerations(filePath);
+  } catch (error) {
+    console.warn(
+      `Ignoring unreadable scheduled-task deletion state at ${filePath}.deletions (${error instanceof Error ? error.message : String(error)}) \u2014 task updates proceed without it; delete the file to rebuild it.`
+    );
+    return void 0;
+  }
+}
+__name(readTaskDeletionGenerationsOrUnknown, "readTaskDeletionGenerationsOrUnknown");
+async function writeTaskDeletionGenerations(filePath, deletionState, assertCanCommit) {
+  const state = {
+    version: 2,
+    watermark: deletionState.watermark,
+    entries: [...deletionState.generations]
+  };
+  await atomicWriteJSON(`${filePath}.deletions`, state, {
+    noFollow: true,
+    assertCanCommit
+  });
+}
+__name(writeTaskDeletionGenerations, "writeTaskDeletionGenerations");
 function getCronFilePath(projectRoot) {
   return path.join(
     Storage.getGlobalTempDir(),
@@ -107,14 +170,25 @@ async function readCronTasks(projectRoot) {
       `Expected a JSON array in ${filePath} \u2014 fix or delete the file; refusing to treat it as an empty schedule.`
     );
   }
-  for (const [index, task] of parsed.entries()) {
+  const normalized = parsed.map((entry) => {
+    if (typeof entry !== "object" || entry === null) return entry;
+    const record = entry;
+    if ((record["modelServiceId"] !== void 0 || record["groupId"] !== void 0) && record["sessionMode"] !== "per_run") {
+      const copy = { ...record };
+      delete copy["modelServiceId"];
+      delete copy["groupId"];
+      return copy;
+    }
+    return entry;
+  });
+  for (const [index, task] of normalized.entries()) {
     if (!isValidTask(task)) {
       throw new Error(
         `Invalid task entry at index ${index} in ${filePath} \u2014 fix or delete the entry; refusing to drop it from the schedule.`
       );
     }
   }
-  return parsed;
+  return normalized;
 }
 __name(readCronTasks, "readCronTasks");
 async function writeCronTasks(projectRoot, tasks, options = {}) {
@@ -171,13 +245,76 @@ async function acquireUpdateLock(filePath) {
   }
 }
 __name(acquireUpdateLock, "acquireUpdateLock");
+function cronTaskSessionDeletionId(sessionId) {
+  const canonicalId = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(
+    sessionId
+  ) ? sessionId.toLowerCase() : sessionId;
+  return `session:${canonicalId}`;
+}
+__name(cronTaskSessionDeletionId, "cronTaskSessionDeletionId");
 async function updateCronTasks(projectRoot, mutate, options = {}) {
   const filePath = getCronFilePath(projectRoot);
   return getUpdateMutex(filePath).runExclusive(async () => {
     const release = await acquireUpdateLock(filePath);
     try {
       const tasks = await readCronTasks(projectRoot);
+      const observedIds = new Set(
+        typeof options.observeDeletionIds === "function" ? options.observeDeletionIds(tasks) : options.observeDeletionIds ?? []
+      );
+      let deletionState;
+      let deletionStateUnknown = false;
+      const loadDeletionState = /* @__PURE__ */ __name(async () => {
+        if (deletionState === void 0 && !deletionStateUnknown) {
+          const state = await readTaskDeletionGenerationsOrUnknown(filePath);
+          if (state === void 0) {
+            deletionStateUnknown = true;
+          } else {
+            deletionState = state;
+          }
+        }
+        return deletionState;
+      }, "loadDeletionState");
+      if (observedIds.size > 0) {
+        const observedDeletionState = await loadDeletionState();
+        if (observedDeletionState !== void 0) {
+          options.onDeletionGenerations?.(
+            new Map(
+              [...observedIds].map((id) => [
+                id,
+                observedDeletionState.generations.get(id) ?? 0
+              ])
+            )
+          );
+        }
+      }
       const next = mutate(tasks);
+      const deletionIds = typeof options.deletionIds === "function" ? options.deletionIds() : options.deletionIds;
+      if (deletionIds?.length) {
+        deletionState = await loadDeletionState() ?? {
+          generations: /* @__PURE__ */ new Map(),
+          watermark: 0
+        };
+        for (const id of new Set(deletionIds)) {
+          if (deletionState.watermark === Number.MAX_SAFE_INTEGER) {
+            throw new Error(
+              `Scheduled-task deletion generation overflow for ${id}`
+            );
+          }
+          deletionState.watermark += 1;
+          deletionState.generations.delete(id);
+          deletionState.generations.set(id, deletionState.watermark);
+        }
+        while (deletionState.generations.size > MAX_TASK_DELETION_GENERATIONS) {
+          const oldest = deletionState.generations.keys().next().value;
+          if (oldest === void 0) break;
+          deletionState.generations.delete(oldest);
+        }
+        await writeTaskDeletionGenerations(
+          filePath,
+          deletionState,
+          options.assertCanCommit
+        );
+      }
       if (next !== tasks) {
         await writeCronTasks(projectRoot, next, options);
       }
@@ -193,14 +330,22 @@ async function addCronTask(projectRoot, task) {
 __name(addCronTask, "addCronTask");
 async function removeCronTasks(projectRoot, ids) {
   const idSet = new Set(ids);
-  const current = await readCronTasks(projectRoot);
-  if (!current.some((t) => idSet.has(t.id))) return 0;
+  try {
+    await fs.access(getCronFilePath(projectRoot));
+  } catch (error) {
+    if (error.code === "ENOENT") return 0;
+    throw error;
+  }
   let removed = 0;
-  await updateCronTasks(projectRoot, (tasks) => {
-    const remaining = tasks.filter((t) => !idSet.has(t.id));
-    removed = tasks.length - remaining.length;
-    return removed === 0 ? tasks : remaining;
-  });
+  await updateCronTasks(
+    projectRoot,
+    (tasks) => {
+      const remaining = tasks.filter((t) => !idSet.has(t.id));
+      removed = tasks.length - remaining.length;
+      return removed === 0 ? tasks : remaining;
+    },
+    { deletionIds: ids }
+  );
   return removed;
 }
 __name(removeCronTasks, "removeCronTasks");
@@ -242,11 +387,13 @@ function isValidTask(value) {
   (obj["name"] === void 0 || typeof obj["name"] === "string") && (obj["enabled"] === void 0 || typeof obj["enabled"] === "boolean") && (obj["disabledByArchive"] === void 0 || typeof obj["disabledByArchive"] === "boolean") && // A bound sessionId must be a NON-EMPTY string: an empty string would pass
   // a bare `typeof` check but the scheduler's truthy `task.sessionId` guard
   // would treat it as unbound, so a "bound" task would silently run unbound.
-  (obj["sessionId"] === void 0 || typeof obj["sessionId"] === "string" && obj["sessionId"].length > 0) && (obj["sessionOwnedByTask"] === void 0 || typeof obj["sessionOwnedByTask"] === "boolean") && (obj["sessionMode"] === void 0 || obj["sessionMode"] === "persistent" || obj["sessionMode"] === "per_run") && (obj["delivery"] === void 0 || isValidDelivery(obj["delivery"])) && (obj["runs"] === void 0 || isValidRuns(obj["runs"]));
+  (obj["sessionId"] === void 0 || typeof obj["sessionId"] === "string" && obj["sessionId"].length > 0) && (obj["sessionOwnedByTask"] === void 0 || typeof obj["sessionOwnedByTask"] === "boolean") && (obj["sessionMode"] === void 0 || obj["sessionMode"] === "persistent" || obj["sessionMode"] === "per_run") && (obj["modelServiceId"] === void 0 || isValidCronTaskRoutingId(obj["modelServiceId"])) && (obj["groupId"] === void 0 || isValidCronTaskRoutingId(obj["groupId"])) && (obj["delivery"] === void 0 || isValidDelivery(obj["delivery"])) && (obj["runs"] === void 0 || isValidRuns(obj["runs"]));
 }
 __name(isValidTask, "isValidTask");
 
 export {
+  MAX_CRON_TASK_ROUTING_ID_LENGTH,
+  isValidCronTaskRoutingId,
   MAX_CHANNEL_DELIVERY_NAME_LENGTH,
   MAX_CHANNEL_DELIVERY_TARGET_ID_LENGTH,
   annotateCronRunSession,
@@ -257,6 +404,7 @@ export {
   CRON_TASKS_DISPLAY_PATH,
   getCronFilePath,
   readCronTasks,
+  cronTaskSessionDeletionId,
   updateCronTasks,
   addCronTask,
   removeCronTasks

package/chunks/{chunk-2ZN3O5FT.js → chunk-457DR2MC.js}

@@ -2,19 +2,19 @@
 "use strict";
 import {
   loadSettings
-} from "./chunk-7BXXIQG4.js";
+} from "./chunk-J73WJIMT.js";
 import {
   getCurrentLanguage
-} from "./chunk-VZUCTJ2P.js";
+} from "./chunk-I6YJZGHS.js";
 import {
   isWorkspaceTrusted
-} from "./chunk-53GWJOLP.js";
+} from "./chunk-NTCFKGQF.js";
 import {
   require_strip_json_comments
 } from "./chunk-NPQ5ZKRP.js";
 import {
   hashMcpServerConfig
-} from "./chunk-BZM5U74J.js";
+} from "./chunk-BS7ON54G.js";
 import {
   Config,
   ExtensionManager,
@@ -25,11 +25,11 @@ import {
   isGatedMcpScope,
   normalizeClaudeMcpServer,
   runWithTimeout
-} from "./chunk-N7VWZDWW.js";
+} from "./chunk-CFSBWJBB.js";
 import {
   getMCPServerLastError,
   getMCPServerStatus
-} from "./chunk-HBU7EKY4.js";
+} from "./chunk-NRUKL236.js";
 import {
   atomicWriteFile
 } from "./chunk-XFFRI3WM.js";

package/chunks/{chunk-WG7BL3FY.js → chunk-473RJLIH.js}

@@ -6,7 +6,7 @@ import {
   conversationRuntimeInUseError,
   conversationRuntimeOwnershipCompromisedError,
   conversationRuntimeUnavailableError
-} from "./chunk-2Z3T52OC.js";
+} from "./chunk-Y5TM7SBV.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-W5ZQMAEM.js → chunk-4Y2I3CI3.js}

@@ -1226,7 +1226,7 @@ function initializeTelemetry(config) {
   telemetryInitPromise ??= (async () => {
     const debugLogger3 = createDebugLogger("OTEL");
     try {
-      const { startTelemetrySdk } = await import("./sdk-impl-G6FVTBQZ.js");
+      const { startTelemetrySdk } = await import("./sdk-impl-4WF3VZ2F.js");
       if (telemetryInitialized) return;
       const started = await startTelemetrySdk(config);
       if (!started) return;

package/chunks/{chunk-HGEUHUEV.js → chunk-54B2LTKP.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   SkillError
-} from "./chunk-2SZH22YO.js";
+} from "./chunk-NJ2OFVUX.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-IRH27ZC2.js → chunk-5EZRLTLQ.js}

@@ -117,9 +117,9 @@ function matches(cronExpr, date) {
 __name(matches, "matches");
 function nextFireTime(cronExpr, after) {
   const fields = parseCron(cronExpr);
-  const candidate = new Date(after.getTime());
-  candidate.setSeconds(0, 0);
-  candidate.setMinutes(candidate.getMinutes() + 1);
+  const candidate = new Date(
+    Math.floor(after.getTime() / 6e4) * 6e4 + 6e4
+  );
   const maxIterations = 4 * 366 * 24 * 60;
   for (let i = 0; i < maxIterations; i++) {
     const minuteOk = fields.minute.has(candidate.getMinutes());
@@ -131,7 +131,7 @@ function nextFireTime(cronExpr, after) {
     if (minuteOk && hourOk && monthOk && dayOk) {
       return candidate;
     }
-    candidate.setMinutes(candidate.getMinutes() + 1);
+    candidate.setTime(candidate.getTime() + 6e4);
   }
   throw new Error(
     `No matching fire time found within 4 years for: "${cronExpr}"`

package/chunks/{chunk-DLH7YIX6.js → chunk-5FK4MSHB.js}

@@ -2,11 +2,11 @@
 "use strict";
 import {
   createTask
-} from "./chunk-XKBFYTCD.js";
+} from "./chunk-WK6DEH3Q.js";
 import {
   getPlanRequiredTeammatePreApprovalMessage,
   isPlanRequiredTeammateAwaitingApproval
-} from "./chunk-PLLIWEM3.js";
+} from "./chunk-AEWCOE64.js";
 import {
   resolveActiveTeamName
 } from "./chunk-S6LOFUVP.js";
@@ -15,7 +15,7 @@ import {
   BaseToolInvocation,
   ToolDisplayNames,
   ToolNames
-} from "./chunk-TP6FYVQT.js";
+} from "./chunk-RSWBT7AZ.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-CUEXOHQH.js → chunk-5ODRE7E5.js}

@@ -27,12 +27,6 @@ var FIELD_KINDS = /* @__PURE__ */ new Set([
   "object"
 ]);
 var SHARED_ACCESS_FIELDS = [
-  {
-    key: "messagePrefix",
-    label: "Message Prefix",
-    kind: "string",
-    description: "Only dispatch user messages that start with this exact prefix after any leading @mentions. The prefix is removed before the task runs"
-  },
   {
     key: "senderPolicy",
     label: "Sender Policy",
@@ -255,15 +249,15 @@ function ensureBuiltins() {
   if (!builtinsPromise) {
     builtinsPromise = (async () => {
       const labelled = [
-        { name: "telegram", promise: import("./dist-H6G3K26N.js") },
-        { name: "weixin", promise: import("./dist-AHJYPSJL.js") },
-        { name: "dingtalk", promise: import("./dist-AIKC5E5P.js") },
-        { name: "dws", promise: import("./dist-F2DVGTL3.js") },
-        { name: "wecom", promise: import("./dist-KLZ7XGEQ.js") },
-        { name: "feishu", promise: import("./dist-KJGRVIGJ.js") },
-        { name: "qqbot", promise: import("./dist-GWNQVPZT.js") },
-        { name: "github", promise: import("./dist-ZXTZTE54.js") },
-        { name: "gitlab", promise: import("./dist-ZA52JXAS.js") }
+        { name: "telegram", promise: import("./dist-T6DDPDLQ.js") },
+        { name: "weixin", promise: import("./dist-GUB7QRYA.js") },
+        { name: "dingtalk", promise: import("./dist-SE4J6Z4O.js") },
+        { name: "dws", promise: import("./dist-NIOJXMGY.js") },
+        { name: "wecom", promise: import("./dist-2QYIVNS6.js") },
+        { name: "feishu", promise: import("./dist-PA7WPFVE.js") },
+        { name: "qqbot", promise: import("./dist-TFGETXFN.js") },
+        { name: "github", promise: import("./dist-MPUZZOG5.js") },
+        { name: "gitlab", promise: import("./dist-VDLSBCLM.js") }
       ];
       const results = await Promise.allSettled(labelled.map((l) => l.promise));
       for (let i = 0; i < results.length; i++) {

package/chunks/{chunk-532WHF4F.js → chunk-5VQR2DD7.js}

@@ -5,13 +5,13 @@ import {
 } from "./chunk-ELRMZTPF.js";
 import {
   isSubagentLikeExecutionContext
-} from "./chunk-PLLIWEM3.js";
+} from "./chunk-AEWCOE64.js";
 import {
   BaseDeclarativeTool,
   BaseToolInvocation,
   ToolDisplayNames,
   ToolNames
-} from "./chunk-TP6FYVQT.js";
+} from "./chunk-RSWBT7AZ.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";