newmark-agent 0.4.9 → 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);
@@ -353571,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) {
@@ -353579,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 {
@@ -353673,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;
@@ -353937,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;
@@ -353944,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",
@@ -353958,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;
@@ -353985,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);
@@ -354078,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,
@@ -354088,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,
@@ -354104,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/conversationKernel.d.ts

@@ -271,6 +271,7 @@ export declare class ConversationKernel {
     rewind(target: ConversationTargetInput, messageIndex: number): ReturnType<Agent['rewindConversation']>;
     prompt(message: string | AgentPromptMessage, target: ConversationTargetInput, options: ConversationKernelRunOptions, queueMode?: ConversationQueueMode): Promise<ConversationKernelRunResult>;
     private settleCooperativeStop;
+    private stopAutomaticContinuationAfterError;
     private run;
     /**
      * Apply a model selection recorded while a Build block was running. The
@@ -280,6 +281,7 @@ export declare class ConversationKernel {
      */
     private syncPendingModel;
     private runSingle;
+    private consumeFailedAutomaticContinuation;
     private processTimeoutMs;
     private runtime;
     private scheduleGoalContinuation;

package/dist/core/conversationKernel.js

@@ -353,7 +353,7 @@ class ConversationKernel {
         const existing = runtime ? this.guideReceipt(runtime, clientMessageId) : undefined;
         if (existing)
             return existing;
-        if (!runtime?.activePromise || !runtime.runId) {
+        if (!runtime?.runId) {
             return { ...base, reason: 'Target conversation is not running' };
         }
         if (requestedRunId && requestedRunId !== runtime.runId) {
@@ -361,6 +361,12 @@ class ConversationKernel {
             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 { ...base, reason: 'Target conversation is not running' };
+        }
         let safeImages = [];
         let safeAttachments = [];
         try {
@@ -460,6 +466,8 @@ class ConversationKernel {
                     attachments: safeAttachments.map(attachment => ({ ...attachment })),
                     createdAt: deferred.createdAt,
                 }]);
+            this.trackQueuedMessage(runtime, safeEnvelope.text, 'steer');
+            this.emitQueueUpdate(runtime);
             this.activateAcceptedGoal(runtime, envelope.goalObjective);
             this.schedulePendingRuntimeContinuation(runtime, runtime.runId);
             return deferred;
@@ -754,6 +762,7 @@ class ConversationKernel {
         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;
@@ -763,6 +772,8 @@ class ConversationKernel {
                     stopped = true;
                 }
                 else {
+                    failed = true;
+                    this.stopAutomaticContinuationAfterError(runtime, runId);
                     runtime.runner.finishConversationWorkRun(runId, 'error', undefined, error instanceof Error ? error.message : String(error));
                     throw error;
                 }
@@ -774,7 +785,7 @@ class ConversationKernel {
                         stopped = true;
                         this.settleCooperativeStop(runtime, runId);
                     }
-                    else if (!runtime.queuePaused && runtime.pendingNextTurn.length > 0) {
+                    else if (!failed && !runtime.queuePaused && runtime.pendingNextTurn.length > 0) {
                         // A renderer/IPC Guide can arrive after the final-drain barrier's
                         // last check but before this promise settles. Do not leave the
                         // deferred continuation queued on an idle runtime.
@@ -782,7 +793,7 @@ class ConversationKernel {
                     }
                 }
             }
-            if (!stopped && runtime.runId === runId)
+            if (!failed && !stopped && runtime.runId === runId)
                 this.scheduleGoalContinuation(runtime, runId);
             if (stopped) {
                 const settled = this.result(runtime, []);
@@ -809,6 +820,30 @@ class ConversationKernel {
         this.emitQueueUpdate(runtime);
         return true;
     }
+    stopAutomaticContinuationAfterError(runtime, runId) {
+        if (runtime.runId !== runId)
+            return;
+        if (runtime.goalContinuationTimer) {
+            clearTimeout(runtime.goalContinuationTimer);
+            runtime.goalContinuationTimer = undefined;
+        }
+        runtime.pendingContinuationRunId = undefined;
+        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' ? undefined : 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);
@@ -914,7 +949,14 @@ class ConversationKernel {
         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,
@@ -925,12 +967,19 @@ class ConversationKernel {
         }
         let timeout;
         try {
-            const tokens = await Promise.race([
-                runtime.runner.process(message),
-                new Promise((_, reject) => {
-                    timeout = setTimeout(() => reject(new Error(`Process timeout (${Math.round(timeoutMs / 1000)}s)`)), timeoutMs);
-                }),
-            ]);
+            let tokens;
+            try {
+                tokens = await Promise.race([
+                    runtime.runner.process(message),
+                    new Promise((_, reject) => {
+                        timeout = setTimeout(() => reject(new Error(`Process timeout (${Math.round(timeoutMs / 1000)}s)`)), timeoutMs);
+                    }),
+                ]);
+            }
+            catch (error) {
+                this.consumeFailedAutomaticContinuation(runtime, message, continuationMode);
+                throw error;
+            }
             if (continuationMode)
                 runtime.runner.consumeConversationContinuation({
                     content: typeof message === 'string' ? message : message.text,
@@ -944,6 +993,15 @@ class ConversationKernel {
                 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)

package/dist/core/workEventCoalescer.d.ts

@@ -0,0 +1,16 @@
+import type { AgentWorkEvent } from './types';
+/**
+ * Bounds cross-process traffic for high-rate streaming text without changing
+ * durable work-run events. Non-text events always flush pending text first.
+ */
+export declare class WorkEventCoalescer {
+    private readonly emit;
+    private readonly windowMs;
+    private readonly pending;
+    constructor(emit: (event: AgentWorkEvent) => void, windowMs?: number);
+    push(event: AgentWorkEvent): void;
+    flush(key: string): void;
+    flushAll(): void;
+    pendingCount(): number;
+}
+//# sourceMappingURL=workEventCoalescer.d.ts.map

package/dist/core/workEventCoalescer.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkEventCoalescer = void 0;
+/**
+ * Bounds cross-process traffic for high-rate streaming text without changing
+ * durable work-run events. Non-text events always flush pending text first.
+ */
+class WorkEventCoalescer {
+    emit;
+    windowMs;
+    pending = new Map();
+    constructor(emit, windowMs = 16) {
+        this.emit = emit;
+        this.windowMs = windowMs;
+    }
+    push(event) {
+        if (event.type !== 'text') {
+            this.flushAll();
+            this.emit(event);
+            return;
+        }
+        const key = `${event.workspaceId || ''}::${event.conversationId}::${event.runtimeKey || ''}::${event.runId || ''}`;
+        const current = this.pending.get(key);
+        if (current) {
+            current.content += event.content;
+            current.event = event;
+            return;
+        }
+        const entry = {
+            event,
+            content: event.content,
+            timer: setTimeout(() => this.flush(key), this.windowMs),
+        };
+        this.pending.set(key, entry);
+    }
+    flush(key) {
+        const entry = this.pending.get(key);
+        if (!entry)
+            return;
+        this.pending.delete(key);
+        clearTimeout(entry.timer);
+        if (entry.content)
+            this.emit({ ...entry.event, content: entry.content });
+    }
+    flushAll() {
+        for (const key of [...this.pending.keys()])
+            this.flush(key);
+    }
+    pendingCount() { return this.pending.size; }
+}
+exports.WorkEventCoalescer = WorkEventCoalescer;
+//# sourceMappingURL=workEventCoalescer.js.map

package/dist/llm/provider.d.ts

@@ -33,6 +33,7 @@ export declare class LLMProvider {
     thinkingTierMaps?: Record<string, Record<string, string>> | undefined;
     static nodeHttpTransport: ((method: 'GET' | 'POST', url: string, headers: Record<string, string>, body?: string) => Promise<NodeHttpResult>) | null;
     static powershellTransport: ((method: 'GET' | 'POST', url: string, headers: Record<string, string>, body?: string) => Promise<NodeHttpResult>) | null;
+    private readonly temperatureUnsupported;
     constructor(name: string, baseUrl: string, apiKey: string, explicitProtocol?: ProviderProtocol | undefined, openAIMode?: OpenAITransportMode | boolean, useProviderAdaptersV2?: boolean, requestTimeoutMs?: number, 
     /** dev-0.4.3 模型原生思考强度档位映射（模型名 → { 模型原生档位: Newmark 档位 }）。 */
     thinkingTierMaps?: Record<string, Record<string, string>> | undefined);
@@ -60,7 +61,11 @@ export declare class LLMProvider {
     private isPlainHttpLoopback;
     private transportDiagnostic;
     private githubModelsHeaders;
+    private temperatureCapabilityKey;
+    private unsupportedTemperatureError;
+    private requestBodyForTemperatureCapability;
     private postJsonWithFetchFallback;
+    private postJsonOnce;
     private getJsonWithFetchFallback;
     private shouldUseNodeHttpFallback;
     private nodeHttpJson;

package/dist/llm/provider.js

@@ -101,6 +101,7 @@ class LLMProvider {
     thinkingTierMaps;
     static nodeHttpTransport = null;
     static powershellTransport = null;
+    temperatureUnsupported = new Set();
     constructor(name, baseUrl, apiKey, explicitProtocol, openAIMode = 'chat_stream', useProviderAdaptersV2 = false, requestTimeoutMs = DEFAULT_PROVIDER_REQUEST_TIMEOUT_MS, 
     /** dev-0.4.3 模型原生思考强度档位映射（模型名 → { 模型原生档位: Newmark 档位 }）。 */
     thinkingTierMaps) {
@@ -286,7 +287,52 @@ 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 = 120000, signal) {
+        const prepared = this.requestBodyForTemperatureCapability(url, body);
+        const response = await this.postJsonOnce(url, headers, prepared, timeoutMs, signal);
+        if (prepared.temperature === undefined || 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 = 120000, signal) {
         const effectiveTimeout = this.effectiveRequestTimeout(timeoutMs);
         // Electron utility processes can leave an undici response body pending when
         // several isolated workers concurrently call a plain-HTTP local provider.
@@ -1024,6 +1070,7 @@ class LLMProvider {
      */
     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);
@@ -1035,12 +1082,27 @@ class LLMProvider {
                 const timer = setTimeout(() => abort.abort(providerTimeoutError(effectiveTimeout)), effectiveTimeout);
                 try {
                     try {
-                        return await fetch(request.url, {
+                        let response = await fetch(request.url, {
                             method: 'POST',
                             headers: request.headers,
                             body: JSON.stringify(request.body),
                             signal: abort.signal,
                         });
+                        if (request.body.temperature !== undefined && response.status === 400) {
+                            const errorText = await response.clone().text();
+                            if (this.unsupportedTemperatureError(response.status, errorText)) {
+                                this.temperatureUnsupported.add(this.temperatureCapabilityKey(request.url, request.body));
+                                const retryBody = { ...request.body };
+                                delete retryBody.temperature;
+                                response = await fetch(request.url, {
+                                    method: 'POST',
+                                    headers: request.headers,
+                                    body: JSON.stringify(retryBody),
+                                    signal: abort.signal,
+                                });
+                            }
+                        }
+                        return response;
                     }
                     catch (error) {
                         if (signal?.aborted)

package/dist/main.js

@@ -76,6 +76,7 @@ const runtimeLifecycle_1 = require("./core/runtimeLifecycle");
 const compat_1 = require("./core/compat");
 const dshCompatibility_1 = require("./core/dshCompatibility");
 const mcpManager_1 = require("./core/mcpManager");
+const workEventCoalescer_1 = require("./core/workEventCoalescer");
 const cli_help_1 = require("./cli-help");
 const APP_NAME = 'Newmark Agent';
 const APP_ID = 'ai.newmark.agent';
@@ -289,7 +290,7 @@ async function resetWslAgentClient() {
     if (wslAgentClient)
         await wslAgentClient.resetAgent();
 }
-function broadcastAgentWorkEvent(event, mirrorToMobile = true) {
+function dispatchAgentWorkEvent(event, mirrorToMobile = true) {
     const workEvent = event;
     if ((workEvent.type === 'done' || workEvent.type === 'error') && workEvent.runtimeKey) {
         browserUseEngine?.clearRuntime(workEvent.runtimeKey);
@@ -309,6 +310,20 @@ function broadcastAgentWorkEvent(event, mirrorToMobile = true) {
         }
     }
 }
+const workEventCoalescer = new workEventCoalescer_1.WorkEventCoalescer(event => dispatchAgentWorkEvent(event, true));
+const workEventNoMobileCoalescer = new workEventCoalescer_1.WorkEventCoalescer(event => dispatchAgentWorkEvent(event, false));
+function broadcastAgentWorkEvent(event, mirrorToMobile = true) {
+    const workEvent = event;
+    // Text deltas are the only high-frequency event. They are coalesced at the
+    // IPC/SSE boundary; all lifecycle/tool events retain immediate ordering.
+    if (workEvent.type === 'text') {
+        (mirrorToMobile ? workEventCoalescer : workEventNoMobileCoalescer).push(workEvent);
+        return;
+    }
+    workEventCoalescer.flushAll();
+    workEventNoMobileCoalescer.flushAll();
+    dispatchAgentWorkEvent(event, mirrorToMobile);
+}
 function ensureConversationKernel(root) {
     if (!agent)
         return null;
@@ -1967,7 +1982,11 @@ else {
                                         ? await ensureWslConversationPool().snapshot(target)
                                         : await ensureElectronUtilityPool().snapshot(target);
                                     const runtime = snapshot.runtime;
-                                    if (!guideText || !runtime?.running || !runtime.runId) {
+                                    // `running` may turn false one IPC task before a finalization-
+                                    // window Guide reaches the worker. Preserve the authoritative
+                                    // runId and let ConversationKernel decide whether that run can
+                                    // be reactivated or must reject a genuinely stale request.
+                                    if (!guideText || !runtime?.runId) {
                                         return { ok: false, error: action === 'goal_guide'
                                                 ? 'There is no active Build for this Goal Guide.'
                                                 : 'Target conversation is not running.' };

package/dist/server.d.ts

@@ -38,6 +38,7 @@ export interface HostedMobileServerStatus {
     checkedAt: string;
     startedAt: number;
 }
+export declare const MOBILE_WORKSPACE_UPLOAD_MAX_BYTES: number;
 export declare function configureHostedServer(root: string, options?: HostedMobileServerOptions): void;
 export declare function stopHostedServer(): Promise<void>;
 export declare function hostedServerStatus(enabled?: boolean, probeHost?: string): Promise<HostedMobileServerStatus>;