newmark-agent 0.4.8 → 0.5.0

package/dist/conversation-utility-host.bundle.cjs

@@ -329452,6 +329452,7 @@ var LLMProvider = class _LLMProvider {
   thinkingTierMaps;
   static nodeHttpTransport = null;
   static powershellTransport = null;
+  temperatureUnsupported = /* @__PURE__ */ new Set();
   effectiveRequestTimeout(timeoutMs) {
     const requested = Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs : DEFAULT_PROVIDER_REQUEST_TIMEOUT_MS;
     const configured = Number.isFinite(this.requestTimeoutMs) && this.requestTimeoutMs > 0 ? this.requestTimeoutMs : DEFAULT_PROVIDER_REQUEST_TIMEOUT_MS;
@@ -329593,7 +329594,46 @@ var LLMProvider = class _LLMProvider {
       "X-GitHub-Api-Version": "2022-11-28"
     };
   }
+  temperatureCapabilityKey(url, body) {
+    return `${url}|${String(body.model || "")}`;
+  }
+  unsupportedTemperatureError(status, raw) {
+    if (status !== 400) return false;
+    try {
+      const parsed = JSON.parse(String(raw || ""));
+      if (String(parsed?.error?.param || "").toLowerCase() === "temperature") return true;
+      return /unsupported parameter[^\n]*temperature|temperature[^\n]*not supported/i.test(String(parsed?.error?.message || ""));
+    } catch {
+      return /unsupported parameter[^\n]*temperature|temperature[^\n]*not supported/i.test(String(raw || ""));
+    }
+  }
+  requestBodyForTemperatureCapability(url, body) {
+    const prepared = { ...body };
+    if (this.temperatureUnsupported.has(this.temperatureCapabilityKey(url, body))) delete prepared.temperature;
+    return prepared;
+  }
   async postJsonWithFetchFallback(url, headers, body, timeoutMs = 12e4, signal) {
+    const prepared = this.requestBodyForTemperatureCapability(url, body);
+    const response = await this.postJsonOnce(url, headers, prepared, timeoutMs, signal);
+    if (prepared.temperature === void 0 || response.status !== 400) return response;
+    const cloneable = typeof response.clone === "function";
+    const errorText = await (cloneable ? response.clone() : response).text();
+    if (!this.unsupportedTemperatureError(response.status, errorText)) {
+      if (cloneable) return response;
+      return {
+        ok: response.ok,
+        status: response.status,
+        headers: response.headers,
+        text: async () => errorText,
+        json: async () => JSON.parse(errorText || "{}")
+      };
+    }
+    this.temperatureUnsupported.add(this.temperatureCapabilityKey(url, body));
+    const retryBody = { ...body };
+    delete retryBody.temperature;
+    return this.postJsonOnce(url, headers, retryBody, timeoutMs, signal);
+  }
+  async postJsonOnce(url, headers, body, timeoutMs = 12e4, signal) {
     const effectiveTimeout = this.effectiveRequestTimeout(timeoutMs);
     if (this.isPlainHttpLoopback(url)) {
       const pathname = (() => {
@@ -330262,6 +330302,7 @@ ${responsePath}
    */
   buildProviderAdapterTransport() {
     return async (request, signal) => {
+      request.body = this.requestBodyForTemperatureCapability(request.url, request.body);
       if (request.body?.stream === true) {
         const abort = new AbortController();
         const forwardAbort = () => abort.abort(signal?.reason);
@@ -330271,12 +330312,27 @@ ${responsePath}
         const timer = setTimeout(() => abort.abort(providerTimeoutError(effectiveTimeout)), effectiveTimeout);
         try {
           try {
-            return await fetch(request.url, {
+            let response2 = await fetch(request.url, {
               method: "POST",
               headers: request.headers,
               body: JSON.stringify(request.body),
               signal: abort.signal
             });
+            if (request.body.temperature !== void 0 && response2.status === 400) {
+              const errorText = await response2.clone().text();
+              if (this.unsupportedTemperatureError(response2.status, errorText)) {
+                this.temperatureUnsupported.add(this.temperatureCapabilityKey(request.url, request.body));
+                const retryBody = { ...request.body };
+                delete retryBody.temperature;
+                response2 = await fetch(request.url, {
+                  method: "POST",
+                  headers: request.headers,
+                  body: JSON.stringify(retryBody),
+                  signal: abort.signal
+                });
+              }
+            }
+            return response2;
           } catch (error) {
             if (signal?.aborted) throw abortFailure(signal);
             if (abort.signal.aborted) throw abortFailure(abort.signal);
@@ -340983,7 +341039,7 @@ async function runAgentKernel(agent) {
             return;
           }
           const publicError = normalizePublicProviderError(error, [currentAgent.activeModelConfig()?.api_key]);
-          if (/\b402\b|insufficient balance|insufficient funds|payment required|余额不足/i.test(publicError)) {
+          if (/\b402\b|insufficient balance|insufficient funds|payment required|insufficient[_ -]?quota|quota (?:exceeded|exhausted)|credit(?:s| balance)? (?:exhausted|depleted)|billing hard limit|budget exhausted|余额不足|额度不足|配额(?:不足|耗尽|超限)/i.test(publicError)) {
             currentAgent.noteProviderBalanceFailure();
           }
           const final = assistantMessage2(model, [{ type: "text", text: `[Error] ${publicError}` }], "error");
@@ -343051,8 +343107,8 @@ function classifyRouteFailure(error) {
   if (statusCode === 400 || /bad request|invalid parameter|invalid request/i.test(text)) {
     return { type: "invalid_request", retryable: false, switchAllowed: false, statusCode };
   }
-  if (statusCode === 402 || /insufficient balance|insufficient funds|payment required|余额不足/i.test(text)) {
-    return { type: "balance_exhausted", retryable: false, switchAllowed: false, statusCode: 402 };
+  if (statusCode === 402 || /insufficient balance|insufficient funds|payment required|insufficient[_ -]?quota|quota (?:exceeded|exhausted)|credit(?:s| balance)? (?:exhausted|depleted)|billing hard limit|budget exhausted|余额不足|额度不足|配额(?:不足|耗尽|超限)/i.test(text)) {
+    return { type: "balance_exhausted", retryable: false, switchAllowed: true, statusCode: statusCode || 402 };
   }
   if (statusCode === 429 || /rate limit|too many requests/i.test(text)) {
     return { type: "rate_limited", retryable: true, switchAllowed: true, statusCode: 429, retryAfterMs };
@@ -343190,13 +343246,13 @@ var AutoRouter = class {
   }
   planAttempts(decision, candidates, failure) {
     const current = decision.resolvedDeployment;
-    if (!current || !failure.error.retryable || !failure.error.switchAllowed || failure.streamCommitted || failure.sideEffectCommitted) return [];
+    if (!current || !failure.error.switchAllowed || failure.streamCommitted || failure.sideEffectCommitted) return [];
     const remainingAttempts = Math.max(0, 3 - decision.attempts.length);
     if (!remainingAttempts) return [];
     const attempts = [];
     const retryDelayMs = failure.error.retryAfterMs ?? 250;
     const alreadyRetriedCurrent = decision.attempts.some((attempt) => attempt.kind === "retry_same_deployment" && sameDeployment(attempt.deployment, current));
-    if (!alreadyRetriedCurrent && retryDelayMs <= (decision.retryBudgetMs ?? 5e3)) {
+    if (failure.error.retryable && !alreadyRetriedCurrent && retryDelayMs <= (decision.retryBudgetMs ?? 5e3)) {
       attempts.push({
         deployment: { ...current },
         kind: "retry_same_deployment",
@@ -343217,11 +343273,16 @@ var AutoRouter = class {
     const eligible = candidates.filter((candidate) => candidate.enabled && inScope(candidate.deployment, scope) && inSubset(candidate.deployment, subset) && !sameDeployment(candidate.deployment, current) && !attemptedDeployments.some((attempted) => sameDeployment(candidate.deployment, attempted)) && validationEligible(candidate, now2).length === 0 && this.passedInitialHardFilters(decision, candidate) && this.circuitState(candidate.deployment, now2, false) !== "open");
     const equivalent = currentGroup ? eligible.find((candidate) => candidate.deployment.logicalModelGroupId === currentGroup && !candidate.fallbackOnly) : void 0;
     const fallback = eligible.find((candidate) => candidate.fallbackOnly);
-    for (const next of [equivalent, fallback]) {
+    const rankedAlternates = decision.rankedCandidates.map((ranked) => eligible.find((candidate) => sameDeployment(candidate.deployment, ranked.deployment))).filter((candidate) => !!candidate && candidate !== equivalent && candidate !== fallback && !candidate.fallbackOnly);
+    for (const candidate of eligible) {
+      if (candidate === equivalent || candidate === fallback || candidate.fallbackOnly || rankedAlternates.some((existing) => sameDeployment(existing.deployment, candidate.deployment))) continue;
+      rankedAlternates.push(candidate);
+    }
+    for (const next of [equivalent, fallback, ...rankedAlternates]) {
       if (!next || attempts.length >= 2) continue;
       attempts.push({
         deployment: { ...next.deployment },
-        kind: next === equivalent ? "equivalent_deployment" : "fallback_model",
+        kind: next === equivalent ? "equivalent_deployment" : next === fallback ? "fallback_model" : "alternate_model",
         status: "planned",
         errorType: failure.error.type,
         streamCommitted: false,
@@ -343464,7 +343525,7 @@ function percentile(values, fraction) {
 }
 function failureFromType(type) {
   const retryable = type === "timeout" || type === "rate_limited" || type === "transport" || type === "server_error" || type === "empty_response";
-  return { type, retryable, switchAllowed: retryable };
+  return { type, retryable, switchAllowed: retryable || type === "balance_exhausted" };
 }
 
 // src/context/services/agent-context-manager.ts
@@ -345570,7 +345631,9 @@ var Agent4 = class _Agent {
   }
   updateProviders(value) {
     const before = this.config.providers();
-    this.config.set("models", "providers", mergeProviderSecrets(value, before));
+    const merged = mergeProviderSecrets(value, before);
+    resetEditedModelValidationEvidence(merged, before);
+    this.config.set("models", "providers", merged);
     const after = this.config.providers();
     const beforeById = new Map(before.map((provider) => [provider.id, provider]));
     const afterById = new Map(after.map((provider) => [provider.id, provider]));
@@ -347656,6 +347719,19 @@ Review this persisted peer result and summarize or continue the parent task as n
     this.writeStoredConversationState(stored, targetWs);
     return true;
   }
+  reorderConversationContinuations(orderedIds) {
+    const currentIds = this.continuations.filter((item) => item.queueMode === "followUp" && !!item.clientMessageId).map((item) => String(item.clientMessageId));
+    const completeOrder = orderedIds.length === currentIds.length && new Set(orderedIds).size === orderedIds.length && orderedIds.every((id) => currentIds.includes(id));
+    if (!completeOrder) throw new Error("A complete queue order with unique current item ids is required");
+    const byId = new Map(this.continuations.flatMap((item) => item.queueMode === "followUp" && item.clientMessageId ? [[String(item.clientMessageId), item]] : []));
+    let nextIndex = 0;
+    this.continuations = this.continuations.map((item) => {
+      if (item.queueMode !== "followUp" || !item.clientMessageId) return item;
+      return byId.get(orderedIds[nextIndex++]);
+    });
+    this.saveWorkspaceConversationState(true);
+    return this.conversationContinuations();
+  }
   renameConversation(id, title, ws = this.workspace.current) {
     const targetWs = ws || this.workspace.current;
     if (!targetWs) return false;
@@ -350461,6 +350537,9 @@ ${msg.content}
     const fallbackEnabled = this.config.getBool("models", "fallback_on_unavailable");
     const observedFailure = classifyRouteFailure(errorText);
     const observedDeployment = this.activeDeployment();
+    if (observedFailure.type === "balance_exhausted" && observedDeployment) {
+      this.providerBalanceBlockedUntilByDeployment.set(deploymentIdentity(observedDeployment), Date.now() + 5 * 6e4);
+    }
     const previousAttempt = observedDeployment && this.lastRouteDecision ? [...this.lastRouteDecision.attempts].reverse().find((attempt) => deploymentIdentity(attempt.deployment) === deploymentIdentity(observedDeployment)) : void 0;
     if (this.model === "auto" && this.routeAttemptStartedAt === 0 && (this.lastRouteDecision?.finalStatus === "failed" || this.lastRouteDecision?.finalStatus === "blocked") && previousAttempt?.status === "failed" && previousAttempt.errorType === observedFailure.type) {
       return null;
@@ -350511,14 +350590,12 @@ ${msg.content}
       return current2.modelId;
     }
     if (!fallbackEnabled) return null;
-    if (!observedFailure.retryable || !observedFailure.switchAllowed || this.routeStreamCommitted || this.routeSideEffectCommitted) return null;
+    if (!observedFailure.switchAllowed || this.routeStreamCommitted || this.routeSideEffectCommitted) return null;
     const current = this.model;
-    const all = this.scopedSwitchModels(current).filter((m2) => m2.name !== current);
+    const currentDeployment = observedDeployment;
+    const all = this.scopedSwitchModels(current).filter((m2) => !currentDeployment || deploymentIdentity(this.deploymentRef(m2)) !== deploymentIdentity(currentDeployment));
     if (!all.length) return null;
-    const usable = all.filter((m2) => {
-      const status = String(m2.evaluation?.status || "unknown").toLowerCase();
-      return status !== "unavailable" && !status.startsWith("error");
-    });
+    const usable = all.filter((m2) => !this.isBalanceBlockedDeployment(this.deploymentRef(m2)) && !modelConfigIsUnavailable(m2));
     if (!usable.length) return null;
     const pref = this.config.autoSwitchPreference();
     const ranked = [...usable].sort((a3, b2) => this.modelScore(b2, pref, false, false) - this.modelScore(a3, pref, false, false));
@@ -351194,7 +351271,7 @@ ${persisted.map((guide, index) => `Guide ${index + 1}: ${guide.text}`).join("\n"
         throw e3;
       }
       const msg = e3 instanceof Error ? e3.message : String(e3);
-      if (/\b402\b|insufficient balance|insufficient funds|payment required|余额不足/i.test(msg)) {
+      if (/\b402\b|insufficient balance|insufficient funds|payment required|insufficient[_ -]?quota|quota (?:exceeded|exhausted)|credit(?:s| balance)? (?:exhausted|depleted)|billing hard limit|budget exhausted|余额不足|额度不足|配额(?:不足|耗尽|超限)/i.test(msg)) {
         this.noteProviderBalanceFailure();
       }
       this.status = "error";
@@ -353102,11 +353179,63 @@ function routeProviderFingerprint(provider) {
     enabled: provider.enabled,
     models: (provider.models || []).map((model) => ({
       name: model.name,
+      display: model.display,
+      description: model.description,
+      maxTokens: model.max_tokens,
+      vision: model.vision,
+      thinking: !!model.thinking,
+      imageOutput: !!model.image_output,
       enabled: model.enabled !== false,
-      logicalModelGroupId: model.logical_model_group_id || ""
+      preview: !!model.preview,
+      logicalModelGroupId: model.logical_model_group_id || "",
+      privacy: model.privacy || [],
+      capabilities: model.capabilities || [],
+      supportedParameters: model.supported_parameters || [],
+      routePreference: model.route_preference,
+      fallbackOnly: !!model.fallback_only,
+      thinkingTierMap: model.thinking_tier_map || {}
     }))
   });
 }
+function modelConfigurationFingerprint(model) {
+  const { validation, evaluation, _previous_name, previous_name, ...configuration } = model;
+  void validation;
+  void evaluation;
+  void _previous_name;
+  void previous_name;
+  return JSON.stringify(configuration);
+}
+function resetEditedModelValidationEvidence(incomingProviders, existingProviders) {
+  const existingById = new Map(existingProviders.map((provider) => [provider.id, provider]));
+  const existingByName = new Map(existingProviders.map((provider) => [provider.name, provider]));
+  for (const rawProvider of incomingProviders) {
+    if (!rawProvider || typeof rawProvider !== "object" || Array.isArray(rawProvider)) continue;
+    const provider = rawProvider;
+    const previousProvider = existingById.get(String(provider.id || "")) || existingByName.get(String(provider._previous_name || provider.previous_name || provider.name || ""));
+    const models = Array.isArray(provider.models) ? provider.models : [];
+    const providerConnectionChanged = !!previousProvider && (String(provider.base_url || provider.endpoint || "") !== previousProvider.base_url || String(provider.protocol || "") !== previousProvider.protocol);
+    for (const rawModel of models) {
+      if (!rawModel || typeof rawModel !== "object" || Array.isArray(rawModel)) continue;
+      const model = rawModel;
+      const previousName = String(model._previous_name || model.previous_name || model.name || "");
+      const previousModel = previousProvider?.models.find((candidate) => candidate.name === previousName);
+      const edited = providerConnectionChanged || !!previousModel && modelConfigurationFingerprint(model) !== modelConfigurationFingerprint(previousModel);
+      delete model._previous_name;
+      delete model.previous_name;
+      if (!edited) continue;
+      model.validation = { level: "discovered", status: "degraded", checked_at: "", capabilities: {} };
+      delete model.evaluation;
+      model.speed_rating = "unknown";
+      model.capability_rating = "unknown";
+    }
+  }
+}
+function modelConfigIsUnavailable(model) {
+  const validationStatus = effectiveModelValidationStatus(model);
+  if (model.validation?.level !== "discovered" && (validationStatus === "unavailable" || validationStatus === "auth_error" || validationStatus === "invalid_config")) return true;
+  const evaluationStatus = validationStatus === "degraded" ? "degraded" : String(model.evaluation?.status || "").toLowerCase();
+  return evaluationStatus === "unavailable" || evaluationStatus.startsWith("error");
+}
 function parseDeploymentSelectionValue2(value) {
   const marker = String(value || "").trim();
   if (!marker.startsWith("deployment:")) return null;
@@ -353123,9 +353252,9 @@ function parseDeploymentSelectionValue2(value) {
 function effectiveModelValidationStatus(model) {
   const raw = String(model.validation?.status || "").toLowerCase();
   if (raw === "auth_error") return raw;
+  if (String(model.validation?.level || "").toLowerCase() === "discovered") return "degraded";
   const textEvidence = model.validation?.capabilities?.text === true || model.validation?.capabilities?.text_input === true || model.validation?.capabilities?.text_output === true || model.evaluation?.text_input === true || model.evaluation?.text_output === true;
   if (textEvidence && raw === "unavailable") return "degraded";
-  if (!raw && String(model.validation?.level || "").toLowerCase() === "discovered") return "degraded";
   return ["verified", "degraded", "unavailable", "auth_error", "rate_limited", "invalid_config"].includes(raw) ? raw : "unavailable";
 }
 function routeToolIsReadOnly(name50, rawArgs) {
@@ -353332,6 +353461,33 @@ ${text}`;
     this.emitQueueUpdate(runtime);
     return true;
   }
+  reorderQueueItems(target, orderedIdsInput) {
+    const runtime = this.findRuntime(target);
+    if (!runtime) throw new Error("Target conversation runtime is unavailable");
+    const currentItems = this.queueItems(runtime.target);
+    const orderedIds = Array.isArray(orderedIdsInput) ? orderedIdsInput.map((id) => String(id || "").trim()) : [];
+    const currentIds = currentItems.map((item) => item.id);
+    const completeOrder = orderedIds.length === currentIds.length && new Set(orderedIds).size === orderedIds.length && orderedIds.every((id) => currentIds.includes(id));
+    if (!completeOrder) throw new Error("A complete queue order with unique current item ids is required");
+    const persistedIds = runtime.runner.conversationContinuations().filter((item) => item.queueMode === "followUp" && !!item.clientMessageId).map((item) => String(item.clientMessageId));
+    if (persistedIds.length !== currentIds.length || new Set(persistedIds).size !== persistedIds.length || persistedIds.some((id) => !currentIds.includes(id))) {
+      throw new Error("Persisted queue does not match the complete queue order");
+    }
+    const pendingById = new Map(runtime.pendingNextTurn.flatMap((item) => {
+      if (item.queueMode !== "followUp" || typeof item.message === "string" || !item.message.clientMessageId) return [];
+      return [[String(item.message.clientMessageId), item]];
+    }));
+    const reorderedPending = orderedIds.map((id) => pendingById.get(id));
+    let nextIndex = 0;
+    runtime.pendingNextTurn = runtime.pendingNextTurn.map((item) => {
+      if (item.queueMode !== "followUp" || typeof item.message === "string" || !item.message.clientMessageId) return item;
+      return reorderedPending[nextIndex++];
+    });
+    runtime.runner.reorderConversationContinuations(orderedIds);
+    runtime.queued.followUp = orderedIds.map((id) => pendingById.get(id)).map((item) => typeof item.message === "string" ? item.message : item.message.text);
+    this.emitQueueUpdate(runtime);
+    return this.queueItems(runtime.target);
+  }
   setQueuePaused(target, paused) {
     const runtime = this.findRuntime(target);
     if (!runtime) throw new Error("Target conversation runtime is unavailable");
@@ -353358,6 +353514,8 @@ ${text}`;
       this.updateQueueItem(runtime.target, String(input.id || ""), String(input.text || ""));
     } else if (action === "delete") {
       if (!this.deleteQueueItem(runtime.target, String(input.id || ""))) throw new Error("Queue item was not found");
+    } else if (action === "reorder") {
+      this.reorderQueueItems(runtime.target, input.orderedIds || []);
     } else if (action === "toggle_pause") {
       this.setQueuePaused(runtime.target, !runtime.queuePaused);
     } else if (action === "guide") {
@@ -353469,7 +353627,7 @@ ${item.goalObjective}` : item.text,
     if (!clientMessageId) return { ...base2, reason: "clientMessageId is required" };
     const existing = runtime ? this.guideReceipt(runtime, clientMessageId) : void 0;
     if (existing) return existing;
-    if (!runtime?.activePromise || !runtime.runId) {
+    if (!runtime?.runId) {
       return { ...base2, reason: "Target conversation is not running" };
     }
     if (requestedRunId && requestedRunId !== runtime.runId) {
@@ -353477,6 +353635,10 @@ ${item.goalObjective}` : item.text,
       runtime.guideReceipts.set(clientMessageId, rejected);
       return runtime.runner.recordGuideReceipt(rejected);
     }
+    const canReactivateFinalizingRun = !runtime.activePromise && runtime.guideAcceptanceClosedRunId === runtime.runId && (!requestedRunId || requestedRunId === runtime.runId);
+    if (!runtime.activePromise && !canReactivateFinalizingRun) {
+      return { ...base2, reason: "Target conversation is not running" };
+    }
     let safeImages = [];
     let safeAttachments = [];
     try {
@@ -353571,6 +353733,8 @@ ${item.goalObjective}` : item.text,
         attachments: safeAttachments.map((attachment) => ({ ...attachment })),
         createdAt: deferred2.createdAt
       }]);
+      this.trackQueuedMessage(runtime, safeEnvelope.text, "steer");
+      this.emitQueueUpdate(runtime);
       this.activateAcceptedGoal(runtime, envelope.goalObjective);
       this.schedulePendingRuntimeContinuation(runtime, runtime.runId);
       return deferred2;
@@ -353835,6 +353999,7 @@ ${item.goalObjective}` : item.text,
     activePromise = (async () => {
       let result = null;
       let stopped = false;
+      let failed = false;
       try {
         result = await this.run(runtime, message, options);
         stopped = runtime.runId === runId && runtime.stopRequestedRunId === runId;
@@ -353842,6 +354007,8 @@ ${item.goalObjective}` : item.text,
         if (runtime.runId === runId && runtime.stopRequestedRunId === runId) {
           stopped = true;
         } else {
+          failed = true;
+          this.stopAutomaticContinuationAfterError(runtime, runId);
           runtime.runner.finishConversationWorkRun(
             runId,
             "error",
@@ -353856,12 +354023,12 @@ ${item.goalObjective}` : item.text,
           if (runtime.stopRequestedRunId === runId) {
             stopped = true;
             this.settleCooperativeStop(runtime, runId);
-          } else if (!runtime.queuePaused && runtime.pendingNextTurn.length > 0) {
+          } else if (!failed && !runtime.queuePaused && runtime.pendingNextTurn.length > 0) {
             this.schedulePendingRuntimeContinuation(runtime, runId);
           }
         }
       }
-      if (!stopped && runtime.runId === runId) this.scheduleGoalContinuation(runtime, runId);
+      if (!failed && !stopped && runtime.runId === runId) this.scheduleGoalContinuation(runtime, runId);
       if (stopped) {
         const settled = this.result(runtime, []);
         if (result?.tokens) settled.tokens = result.tokens;
@@ -353883,6 +354050,28 @@ ${item.goalObjective}` : item.text,
     this.emitQueueUpdate(runtime);
     return true;
   }
+  stopAutomaticContinuationAfterError(runtime, runId) {
+    if (runtime.runId !== runId) return;
+    if (runtime.goalContinuationTimer) {
+      clearTimeout(runtime.goalContinuationTimer);
+      runtime.goalContinuationTimer = void 0;
+    }
+    runtime.pendingContinuationRunId = void 0;
+    this.rejectOutstandingGuides(runtime, "The provider failed before this Guide could be applied; submit again to retry.");
+    runtime.pendingNextTurn = runtime.pendingNextTurn.filter((item) => {
+      const automatic = item.queueMode === "steer" || typeof item.message !== "string" && item.message.hiddenUserInput === true;
+      if (automatic) {
+        runtime.runner.consumeConversationContinuation({
+          content: typeof item.message === "string" ? item.message : item.message.text,
+          queueMode: item.queueMode,
+          clientMessageId: typeof item.message === "string" ? void 0 : item.message.clientMessageId
+        });
+      }
+      return !automatic;
+    });
+    this.queueState(runtime);
+    this.emitQueueUpdate(runtime);
+  }
   async run(runtime, message, options) {
     this.applyOptions(runtime.runner, options);
     let lastTokens = await this.runSingle(runtime, message);
@@ -353976,7 +354165,13 @@ Review this persisted peer result and summarize or continue the parent task as n
     this.consumeQueuedMessage(runtime, typeof message === "string" ? message : message.text);
     const timeoutMs = this.processTimeoutMs(runtime);
     if (timeoutMs <= 0) {
-      const tokens = await runtime.runner.process(message);
+      let tokens;
+      try {
+        tokens = await runtime.runner.process(message);
+      } catch (error) {
+        this.consumeFailedAutomaticContinuation(runtime, message, continuationMode);
+        throw error;
+      }
       if (continuationMode) runtime.runner.consumeConversationContinuation({
         content: typeof message === "string" ? message : message.text,
         queueMode: continuationMode,
@@ -353986,12 +354181,18 @@ Review this persisted peer result and summarize or continue the parent task as n
     }
     let timeout;
     try {
-      const tokens = await Promise.race([
-        runtime.runner.process(message),
-        new Promise((_3, reject) => {
-          timeout = setTimeout(() => reject(new Error(`Process timeout (${Math.round(timeoutMs / 1e3)}s)`)), timeoutMs);
-        })
-      ]);
+      let tokens;
+      try {
+        tokens = await Promise.race([
+          runtime.runner.process(message),
+          new Promise((_3, reject) => {
+            timeout = setTimeout(() => reject(new Error(`Process timeout (${Math.round(timeoutMs / 1e3)}s)`)), timeoutMs);
+          })
+        ]);
+      } catch (error) {
+        this.consumeFailedAutomaticContinuation(runtime, message, continuationMode);
+        throw error;
+      }
       if (continuationMode) runtime.runner.consumeConversationContinuation({
         content: typeof message === "string" ? message : message.text,
         queueMode: continuationMode,
@@ -354002,6 +354203,14 @@ Review this persisted peer result and summarize or continue the parent task as n
       if (timeout) clearTimeout(timeout);
     }
   }
+  consumeFailedAutomaticContinuation(runtime, message, continuationMode) {
+    if (!continuationMode || typeof message === "string" || message.hiddenUserInput !== true) return;
+    runtime.runner.consumeConversationContinuation({
+      content: message.text,
+      queueMode: continuationMode,
+      clientMessageId: message.clientMessageId
+    });
+  }
   processTimeoutMs(runtime) {
     const raw = runtime.runner.config.getNum("agent", "process_timeout_ms") || this.host.config.getNum("agent", "process_timeout_ms");
     if (!Number.isFinite(raw) || raw <= 0) return 0;

package/dist/core/agent.d.ts

@@ -670,6 +670,7 @@ export declare class Agent {
     isBranchCommunicationEnabled(): boolean;
     switchConversationBranch(conversationId: string, branchId: string, branchGroupId?: string): ConversationSnapshot;
     setConversationPinned(id: string, pinned: boolean, ws?: WorkspaceInfo | null): boolean;
+    reorderConversationContinuations(orderedIds: string[]): ConversationContinuation[];
     renameConversation(id: string, title: string, ws?: WorkspaceInfo | null): boolean;
     /** 为指定工作区创建空白对话，不临时切换全局前台工作区。 */
     createConversationInWorkspace(ws: WorkspaceInfo, title?: string): {