newmark-agent 0.5.4 → 0.5.8

package/dist/core/agent.js

@@ -1016,7 +1016,13 @@ class Agent {
     beginRouteAttempt() {
         this.routeAttemptStartedAt = Date.now();
     }
-    async waitForPlannedRouteRetry() {
+    async waitForPlannedRouteRetry(explicitDelayMs) {
+        if (explicitDelayMs !== undefined) {
+            if (explicitDelayMs <= 0)
+                return;
+            await new Promise(resolve => setTimeout(resolve, explicitDelayMs));
+            return;
+        }
         const waitBudgetMs = Math.max(0, Math.min(15_000, this.lastRouteDecision?.retryBudgetMs ?? 5_000));
         const delay = Math.max(0, Math.min(waitBudgetMs, this.lastRouteRetryDelayMs));
         this.lastRouteRetryDelayMs = 0;
@@ -2298,6 +2304,7 @@ class Agent {
             status: input.status,
             guide: !isToolEvent && input.guide ? this.normalizeGuideReceipt(input.guide) : undefined,
             displayImage: isToolEvent ? this.hydrateDisplayImage(input.displayImage) : undefined,
+            fallback: input.fallback,
         };
         if (activeRun && this.isPersistablePublicWorkEvent(event)) {
             activeRun.sequence = Number(sequence || activeRun.sequence + 1);
@@ -5587,10 +5594,22 @@ class Agent {
     }
     compressionBuildBlockStart(messages) {
         const activeRunId = this.currentWorkRunId();
-        if (!activeRunId)
-            return 0;
-        const index = messages.findIndex(message => String(message.run_id || message.runId || '') === activeRunId);
-        return index >= 0 ? index : 0;
+        if (activeRunId) {
+            const index = messages.findIndex(message => String(message.run_id || message.runId || '') === activeRunId);
+            if (index >= 0)
+                return index;
+        }
+        // dev-0.5.6: 空闲对话（无活动 run）时不得把全部历史算进当前 Build Block，
+        // 否则上下文显示窗口的长期历史恒为 0。回退语义：
+        // - 存在带 run_id 的消息：boundary 取最后一个 run 的起点之后（该 run 及其
+        //   之前的历史属于长期历史，其后无归属的消息属于当前未命名区块）；
+        // - 完全没有 run_id：全部历史都是长期历史（不存在当前 Build Block）。
+        let lastRunBoundary = -1;
+        for (let index = 0; index < messages.length; index += 1) {
+            if (String(messages[index]?.run_id || messages[index]?.runId || ''))
+                lastRunBoundary = index + 1;
+        }
+        return lastRunBoundary >= 0 ? lastRunBoundary : messages.length;
     }
     recentContextSuffix(messages, maxMessages, tokenBudget) {
         if (!messages.length)
@@ -6651,17 +6670,12 @@ class Agent {
                 if (this.routeAttemptStartedAt > 0)
                     currentAttempt.durationMs = Math.max(0, Date.now() - this.routeAttemptStartedAt);
             }
-            if (!fallbackEnabled) {
-                this.lastRouteDecision.finalStatus = 'failed';
-                this.routeAttemptStartedAt = 0;
-                this.persistRouteDecision(this.lastRouteDecision);
-                return null;
-            }
             if (!this.pendingAutoAttempts.length) {
                 this.pendingAutoAttempts = this.autoRouter.planAttempts(this.lastRouteDecision, this.autoRouteCandidates(), {
                     error: failure,
                     streamCommitted: this.routeStreamCommitted,
                     sideEffectCommitted: this.routeSideEffectCommitted,
+                    allowModelFallback: fallbackEnabled,
                 });
             }
             const next = this.pendingAutoAttempts.shift();
@@ -6702,8 +6716,11 @@ class Agent {
             return null;
         this.model = next.name;
         this.fixedDeployment = this.deploymentRef(next);
-        if (next.provider)
-            this.config.set('models', 'auto_switch_anchor_provider', next.provider);
+        // Do NOT rewrite auto_switch_anchor_provider here. The anchor describes
+        // the user's Auto-routing scope; a fixed-model recovery must never
+        // repoint it (a single transient failure would otherwise silently move
+        // every future Auto route — and every future fallback pool — to the
+        // recovery provider, which is the cross-provider leak users observed).
         return current;
     }
     isLlmErrorText(text) {
@@ -6711,18 +6728,23 @@ class Agent {
     }
     scopedSwitchModels(currentModelName) {
         const all = this.config.allModels();
-        if (this.config.autoSwitchScope() !== 'provider')
-            return all;
-        const current = currentModelName === 'auto' ? undefined : this.config.findModel(currentModelName);
-        const providerId = current?.provider_id ||
-            this.config.autoSwitchAnchorProvider() ||
-            this.config.findModel(this.config.getStr('models', 'default_model'))?.provider_id ||
-            all[0]?.provider_id ||
-            '';
+        // Fixed-model recovery is always provider-local. A same-named model on a
+        // different provider is a different deployment and must never receive the
+        // failed provider's credentials or become an implicit fallback.
+        // Resolution order is strictly deployment-first: the pinned deployment,
+        // then the exact active deployment. The global auto anchor is deliberately
+        // NOT consulted here — it belongs to Auto routing only and can point at a
+        // different provider (for example after a previous cross-provider switch),
+        // which is exactly the same-name cross-provider leak this guard exists to
+        // prevent. When no provider can be established unambiguously, return an
+        // empty pool: failing the switch is safe, crossing providers is not.
+        const current = currentModelName === 'auto' ? this.activeModelConfig() : this.config.findModel(currentModelName);
+        const providerId = current?.provider_id
+            || this.fixedDeployment?.providerId
+            || (currentModelName !== 'auto' ? this.activeDeployment()?.providerId : undefined);
         if (!providerId)
-            return all;
-        const provider = this.config.findProvider(providerId);
-        return all.filter(m => m.provider_id === (provider?.id || providerId));
+            return [];
+        return all.filter(m => m.provider_id === providerId);
     }
     async validateModels(selectedNames, options = {}) {
         if (this.modelValidationPromise)
@@ -8224,9 +8246,17 @@ class Agent {
             return '[Subagent] Not found.';
         const requestedModel = this.normalizeSubagentModelSelection(sa.model && sa.model !== 'default' ? sa.model : this.modelSelectionValue() || this.model);
         const requestedDeployment = parseDeploymentSelectionValue(requestedModel);
-        const assignedModel = requestedModel === 'auto'
+        let assignedModel = requestedModel === 'auto'
             ? this.activeModelConfig()
             : (requestedDeployment ? this.config.findDeployment(requestedDeployment) : this.config.findModel(requestedModel));
+        // Imported presets (and stale records) may reference a bare model name
+        // that no longer exists in the configured catalog. Resolving by name must
+        // never guess a provider; instead the peer inherits the parent deployment
+        // so the job can still run. Qualified deployment values keep failing
+        // closed — they are exact references, not guesses.
+        if (!assignedModel && !requestedDeployment && requestedModel !== 'auto') {
+            assignedModel = this.activeModelConfig();
+        }
         const model = assignedModel?.name || (requestedModel === 'auto' ? this.activeModelName() : requestedModel);
         const activeModel = this.activeModelConfig();
         const activeProvider = this.engineModel();

package/dist/core/agentKernelRunner.js

@@ -46,6 +46,7 @@ const toolPolicy_1 = require("./toolPolicy");
 const performanceDiagnostics_1 = require("./performanceDiagnostics");
 const agentKernelDiagnostics_1 = require("./agentKernelDiagnostics");
 const toolchain_1 = require("../toolchain");
+const emptyResponseRetry_1 = require("./emptyResponseRetry");
 const publicStreamFilters = new WeakMap();
 const brokerOnlyAssistantBuffers = new WeakMap();
 const BROKER_PREFACE_BUFFER_CHARS = 96;
@@ -206,7 +207,7 @@ function kernelTurnFailed(agent, turn) {
     return turn.stopReason === 'error' || agent.isLlmErrorText(turn.text);
 }
 function providerTurnIsEmpty(turn) {
-    return /provider returned an empty response/i.test(`${turn.errorMessage}\n${turn.text}`);
+    return !turn.activity && /provider returned an empty response/i.test(`${turn.errorMessage}\n${turn.text}`);
 }
 function removeTrailingFailedAssistant(agent, messages) {
     const last = messages[messages.length - 1];
@@ -216,6 +217,14 @@ function removeTrailingFailedAssistant(agent, messages) {
     if (last.stopReason === 'error' || agent.isLlmErrorText(text))
         messages.pop();
 }
+function removeTrailingThoughtOnlyAssistant(messages) {
+    const last = messages[messages.length - 1];
+    if (last?.role !== 'assistant')
+        return;
+    const hasToolCall = last.content.some(content => content.type === 'toolCall');
+    if (!KernelMessageText(last).trim() && !hasToolCall)
+        messages.pop();
+}
 function normalizePublicProviderError(error, secrets = []) {
     let raw = '';
     if (error instanceof Error) {
@@ -369,8 +378,22 @@ async function runAgentKernel(agent) {
     const tokens = [];
     const runOnce = async (promptMessages, appendPromptToAgentHistory) => {
         let lastAssistant = null;
+        let observedActivity = false;
+        let observedThought = false;
         const unsubscribe = kernel.subscribe(async (event) => {
             await handleKernelEvent(agent, event, tokens);
+            if (event.type === 'message_update') {
+                const delta = event.assistantMessageEvent;
+                const deltaText = typeof delta.delta === 'string'
+                    ? delta.delta
+                    : '';
+                const thoughtDelta = delta.type === 'thinking_delta' && !!deltaText.trim();
+                observedThought = observedThought || thoughtDelta;
+                observedActivity = observedActivity ||
+                    thoughtDelta ||
+                    (delta.type === 'text_delta' && !!deltaText.trim()) ||
+                    (delta.type === 'toolcall_end');
+            }
             if (event.type === 'message_end' && event.message.role === 'assistant') {
                 lastAssistant = event.message;
             }
@@ -390,11 +413,14 @@ async function runAgentKernel(agent) {
             const text = assistant ? KernelMessageText(assistant) : '';
             const hasToolCall = !!assistant?.content?.some(content => content.type === 'toolCall');
             const emptyResponse = !assistant
-                || (!text.trim() && !hasToolCall && String(assistant?.stopReason || '') !== 'aborted');
+                || (!text.trim() && !hasToolCall && !observedActivity && String(assistant?.stopReason || '') !== 'aborted');
             return {
                 text: emptyResponse ? '[Error] Provider returned an empty response.' : text,
                 stopReason: String(assistant?.stopReason || ''),
                 errorMessage: String(assistant?.errorMessage || (emptyResponse ? 'Provider returned an empty response.' : '')),
+                activity: observedActivity || !!text.trim() || hasToolCall,
+                thoughtOnly: observedThought && !text.trim() && !hasToolCall
+                    && !['error', 'aborted'].includes(String(assistant?.stopReason || '')),
             };
         }
         finally {
@@ -440,16 +466,31 @@ async function runAgentKernel(agent) {
             agent.recordWorkStatus('Final visual fallback used: local mini OCR plus conservative text correction.');
         }
         if (modelBeforeKernelRun && modelBeforeKernelRun !== agent.model && !tokens.some(t => t.text?.includes('[Model fallback]'))) {
-            tokens.unshift({ type: 'text', text: `[Model fallback] ${modelBeforeKernelRun} unavailable; switched to ${agent.model}.` });
+            const notice = `[Model fallback] ${modelBeforeKernelRun} unavailable; switched to ${agent.model}.`;
+            tokens.unshift({ type: 'text', text: notice });
+            agent.emitWorkEvent({
+                type: 'status',
+                content: notice,
+                fallback: { from: modelBeforeKernelRun, to: agent.model, providerId: agent.activeDeployment()?.providerId },
+            });
         }
-        let emptyResponseRetries = 0;
-        while (providerTurnIsEmpty(lastTurn) && emptyResponseRetries < 2) {
+        let consecutiveEmptyResponses = 0;
+        for (;;) {
+            const emptyResponseState = (0, emptyResponseRetry_1.observeEmptyResponseOutcome)(consecutiveEmptyResponses, providerTurnIsEmpty(lastTurn));
+            consecutiveEmptyResponses = emptyResponseState.consecutiveEmptyResponses;
+            if (lastTurn.thoughtOnly) {
+                removeTrailingThoughtOnlyAssistant(kernel.state.messages);
+                lastTurn = await runWithCompressionResume([], false);
+                continue;
+            }
+            if (!emptyResponseState.retry)
+                break;
             removeTrailingFailedAssistant(agent, kernel.state.messages);
-            emptyResponseRetries += 1;
-            const notice = `[Model retry] Provider returned an empty response; retrying the same deployment (${emptyResponseRetries}/2).`;
+            const retryNumber = consecutiveEmptyResponses;
+            const notice = `[Model retry] Provider returned an empty response; retrying the same deployment (${retryNumber}/${emptyResponseRetry_1.MAX_EMPTY_RESPONSE_RETRIES}) after ${(0, emptyResponseRetry_1.emptyResponseRetryDelayMs)(consecutiveEmptyResponses)}ms.`;
             tokens.push({ type: 'text', text: notice });
             agent.recordWorkStatus(notice);
-            await agent.waitForPlannedRouteRetry();
+            await agent.waitForPlannedRouteRetry((0, emptyResponseRetry_1.emptyResponseRetryDelayMs)(consecutiveEmptyResponses));
             lastTurn = await runWithCompressionResume([], false);
         }
         let routeRetries = 0;
@@ -462,6 +503,11 @@ async function runAgentKernel(agent) {
             const notice = routeTransitionNotice(agent, previous);
             tokens.push({ type: 'text', text: notice });
             agent.recordWorkStatus(notice);
+            agent.emitWorkEvent({
+                type: 'status',
+                content: notice,
+                fallback: { from: previous, to: agent.model, providerId: agent.activeDeployment()?.providerId },
+            });
             kernel.state.model = toKernelModel(agent);
             const fallbackToolSurface = refreshToolSurface(true);
             kernel.state.systemPrompt = [agent.buildSystemPrompt(), fallbackToolSurface.systemPromptNotice].filter(Boolean).join('\n\n');
@@ -656,7 +702,7 @@ async function runAgentKernel(agent) {
                     }
                     if (textStarted)
                         finalContent.push({ type: 'text', text });
-                    if (!finalContent.length) {
+                    if (!finalContent.length && !thinking.trim()) {
                         text = '[Error] Provider returned an empty response.';
                         finalContent.push({ type: 'text', text });
                     }

package/dist/core/autoRouter.d.ts

@@ -153,6 +153,7 @@ export declare class AutoRouter {
         error: RouteFailure;
         streamCommitted: boolean;
         sideEffectCommitted: boolean;
+        allowModelFallback?: boolean;
     }): PlannedRouteAttempt[];
     recordEndpointFailure(deployment: DeploymentRef, failure: RouteFailureType | RouteFailure): void;
     recordEndpointSuccess(deployment: DeploymentRef, latencyMs?: number, throughput?: number): void;

package/dist/core/autoRouter.js

@@ -290,15 +290,24 @@ class AutoRouter {
                 retryDelayMs,
             });
         }
+        if (failure.allowModelFallback === false)
+            return attempts.slice(0, remainingAttempts);
         const selection = decision.requestedSelection;
         if (selection.kind === 'fixed')
             return attempts.slice(0, remainingAttempts);
         const scope = selection.kind === 'auto' ? selection.scope : { kind: 'provider', providerId: current.providerId };
         const subset = selection.kind === 'auto' ? selection.subset : undefined;
         const currentGroup = current.logicalModelGroupId;
+        const currentProviderId = current.providerId;
         const now = this.now();
         const attemptedDeployments = decision.attempts.map(attempt => attempt.deployment);
+        // Fallback is a recovery operation, not a new global routing decision.
+        // It must never cross the provider boundary, even when the original Auto
+        // selection has global scope. This prevents equal model ids from silently
+        // switching credentials/endpoints (for example provider A/model X to
+        // provider B/model X).
         const eligible = candidates.filter(candidate => candidate.enabled
+            && candidate.deployment.providerId === currentProviderId
             && inScope(candidate.deployment, scope)
             && inSubset(candidate.deployment, subset)
             && !sameDeployment(candidate.deployment, current)

package/dist/core/conversationKernel.d.ts

@@ -194,6 +194,18 @@ export declare class ConversationKernel {
         steering: string[];
         followUp: string[];
     };
+    /**
+     * dev-0.5.6: 排队 followUp 消息 drain 时转成普通用户消息载荷。
+     *
+     * 入队时（enqueueSameSession）为去重/编辑保留了 clientMessageId，并把
+     * runId 固定为入队时运行的 runId；若原样传给 process，写入 chatMessages
+     * 的用户消息会携带旧 runId + clientMessageId，渲染端（PC renderTranscript /
+     * 移动端 projectRemoteConversationItems）会把「clientMessageId + runId 命中
+     * workRuns」的消息误判为 guide 消息而跳过气泡，导致排队自动发送的消息不
+     * 显示在用户输入时间线。清除这两个字段后 process 走普通用户消息分支
+     * （chatMessages.push，mode 取 visibleMode，runId 取当前 run）。
+     */
+    private drainQueuedFollowUpMessage;
     queueItems(target: ConversationTargetInput): ConversationQueueItemSnapshot[];
     enqueueNext(target: ConversationTargetInput, input: {
         id: string;

package/dist/core/conversationKernel.js

@@ -60,6 +60,33 @@ class ConversationKernel {
             followUp: queued?.followUp.slice() || [],
         };
     }
+    /**
+     * dev-0.5.6: 排队 followUp 消息 drain 时转成普通用户消息载荷。
+     *
+     * 入队时（enqueueSameSession）为去重/编辑保留了 clientMessageId，并把
+     * runId 固定为入队时运行的 runId；若原样传给 process，写入 chatMessages
+     * 的用户消息会携带旧 runId + clientMessageId，渲染端（PC renderTranscript /
+     * 移动端 projectRemoteConversationItems）会把「clientMessageId + runId 命中
+     * workRuns」的消息误判为 guide 消息而跳过气泡，导致排队自动发送的消息不
+     * 显示在用户输入时间线。清除这两个字段后 process 走普通用户消息分支
+     * （chatMessages.push，mode 取 visibleMode，runId 取当前 run）。
+     */
+    drainQueuedFollowUpMessage(message) {
+        if (typeof message === 'string')
+            return message;
+        const text = String(message.text || '');
+        const images = message.images;
+        const attachments = message.attachments;
+        const visible = message.visibleUserInput;
+        const visibleMode = message.visibleMode;
+        return {
+            text,
+            ...(images?.length ? { images } : {}),
+            ...(attachments?.length ? { attachments } : {}),
+            ...(visible ? { visibleUserInput: visible } : {}),
+            ...(visibleMode ? { visibleMode } : {}),
+        };
+    }
     queueItems(target) {
         const runtime = this.findRuntime(target);
         if (!runtime)
@@ -888,7 +915,7 @@ class ConversationKernel {
                     lastTokens = await this.runSingle(runtime, batchMessage, 'steer');
                 }
                 else {
-                    lastTokens = await this.runSingle(runtime, next.message, next.queueMode);
+                    lastTokens = await this.runSingle(runtime, this.drainQueuedFollowUpMessage(next.message), next.queueMode);
                 }
             }
             const rootMessage = runtime.runner.subagents.readRootInbox()[0];
@@ -1414,6 +1441,10 @@ class ConversationKernel {
             content: 'Conversation queue updated.',
             conversationId: runtime.id,
             queue: this.queued(runtime.target),
+            // Structured rows with stable kernel ids so every consumer (PC UI and
+            // the paired mobile client) can render/edit/delete the same items.
+            queueItems: this.queueItems(runtime.target),
+            queuePaused: runtime.queuePaused === true,
         });
     }
     clearQueued(runtime) {

package/dist/core/electronUtilityRuntimePool.js

@@ -601,8 +601,13 @@ class ElectronUtilityRuntimePool {
         return this.accessSequence;
     }
     maxResidentRuntimes() {
-        const configured = Number(this.options.maxResidentRuntimes ?? 2);
-        return Number.isFinite(configured) ? Math.max(1, Math.floor(configured)) : 2;
+        // The pool hosts one utility runtime per active conversation target.
+        // A small default (2) silently blocked users from running more than two
+        // conversations at once with "utility runtime pool capacity reached".
+        // Idle runtimes are still evicted on LRU after the idle TTL, so a higher
+        // default bounds memory by activity, not by an arbitrary conversation cap.
+        const configured = Number(this.options.maxResidentRuntimes ?? 8);
+        return Number.isFinite(configured) ? Math.max(1, Math.floor(configured)) : 8;
     }
     async serializeCapacity(operation) {
         const previous = this.capacityTail;

package/dist/core/emptyResponseRetry.d.ts

@@ -0,0 +1,16 @@
+export declare const EMPTY_RESPONSE_RETRY_DELAYS_MS: readonly [200, 800, 2000, 10000, 60000];
+/**
+ * A retry is scheduled only after an explicit provider empty-response
+ * failure. The initial failed request is not called a retry, so five retries
+ * means six consecutive explicit failures before termination.
+ */
+export declare const MAX_EMPTY_RESPONSE_RETRIES: 5;
+export declare const MAX_CONSECUTIVE_EMPTY_RESPONSES: number;
+export declare function emptyResponseRetryDelayMs(consecutiveEmptyResponses: number): number;
+export interface EmptyResponseRetryState {
+    consecutiveEmptyResponses: number;
+    retry: boolean;
+    terminate: boolean;
+}
+export declare function observeEmptyResponseOutcome(consecutiveEmptyResponses: number, emptyResponse: boolean): EmptyResponseRetryState;
+//# sourceMappingURL=emptyResponseRetry.d.ts.map

package/dist/core/emptyResponseRetry.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_CONSECUTIVE_EMPTY_RESPONSES = exports.MAX_EMPTY_RESPONSE_RETRIES = exports.EMPTY_RESPONSE_RETRY_DELAYS_MS = void 0;
+exports.emptyResponseRetryDelayMs = emptyResponseRetryDelayMs;
+exports.observeEmptyResponseOutcome = observeEmptyResponseOutcome;
+exports.EMPTY_RESPONSE_RETRY_DELAYS_MS = [200, 800, 2_000, 10_000, 60_000];
+/**
+ * A retry is scheduled only after an explicit provider empty-response
+ * failure. The initial failed request is not called a retry, so five retries
+ * means six consecutive explicit failures before termination.
+ */
+exports.MAX_EMPTY_RESPONSE_RETRIES = exports.EMPTY_RESPONSE_RETRY_DELAYS_MS.length;
+exports.MAX_CONSECUTIVE_EMPTY_RESPONSES = exports.MAX_EMPTY_RESPONSE_RETRIES + 1;
+function emptyResponseRetryDelayMs(consecutiveEmptyResponses) {
+    return exports.EMPTY_RESPONSE_RETRY_DELAYS_MS[Math.max(0, consecutiveEmptyResponses - 1)] ?? 0;
+}
+function observeEmptyResponseOutcome(consecutiveEmptyResponses, emptyResponse) {
+    const nextCount = emptyResponse ? consecutiveEmptyResponses + 1 : 0;
+    return {
+        consecutiveEmptyResponses: nextCount,
+        retry: emptyResponse && nextCount <= exports.MAX_EMPTY_RESPONSE_RETRIES,
+        terminate: emptyResponse && nextCount > exports.MAX_EMPTY_RESPONSE_RETRIES,
+    };
+}
+//# sourceMappingURL=emptyResponseRetry.js.map

package/dist/core/terminalOutputBuffer.d.ts

@@ -0,0 +1,24 @@
+export declare const TERMINAL_HISTORY_LIMIT: number;
+export interface TerminalOutputBufferOptions {
+    flushIntervalMs?: number;
+    historyLimit?: number;
+}
+export declare class TerminalOutputBuffer {
+    private readonly send;
+    private readonly sessions;
+    private timer;
+    private readonly flushIntervalMs;
+    private readonly historyLimit;
+    constructor(send: (sessionId: string, text: string) => void, options?: TerminalOutputBufferOptions);
+    push(sessionId: string, text: string): void;
+    flush(sessionId: string): void;
+    flushAll(): void;
+    close(sessionId: string): string;
+    history(sessionId: string): string;
+    pendingChunkCount(): number;
+    hasScheduledFlush(): boolean;
+    private bound;
+    private schedule;
+    private clearTimerWhenIdle;
+}
+//# sourceMappingURL=terminalOutputBuffer.d.ts.map

package/dist/core/terminalOutputBuffer.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TerminalOutputBuffer = exports.TERMINAL_HISTORY_LIMIT = void 0;
+exports.TERMINAL_HISTORY_LIMIT = 256 * 1024;
+class TerminalOutputBuffer {
+    send;
+    sessions = new Map();
+    timer = null;
+    flushIntervalMs;
+    historyLimit;
+    constructor(send, options = {}) {
+        this.send = send;
+        this.flushIntervalMs = Math.max(1, options.flushIntervalMs ?? 20);
+        this.historyLimit = Math.max(1, options.historyLimit ?? exports.TERMINAL_HISTORY_LIMIT);
+    }
+    push(sessionId, text) {
+        if (!text)
+            return;
+        let state = this.sessions.get(sessionId);
+        if (!state) {
+            state = { chunks: [], length: 0, history: '' };
+            this.sessions.set(sessionId, state);
+        }
+        state.chunks.push(text);
+        state.length += text.length;
+        this.schedule();
+    }
+    flush(sessionId) {
+        const state = this.sessions.get(sessionId);
+        if (!state?.length)
+            return;
+        const text = state.chunks.length === 1 ? state.chunks[0] : state.chunks.join('');
+        state.chunks = [];
+        state.length = 0;
+        state.history = this.bound(`${state.history}${text}`);
+        this.send(sessionId, text);
+        this.clearTimerWhenIdle();
+    }
+    flushAll() {
+        for (const sessionId of this.sessions.keys())
+            this.flush(sessionId);
+        this.clearTimerWhenIdle(true);
+    }
+    close(sessionId) {
+        this.flush(sessionId);
+        const history = this.sessions.get(sessionId)?.history ?? '';
+        this.sessions.delete(sessionId);
+        this.clearTimerWhenIdle();
+        return history;
+    }
+    history(sessionId) {
+        const state = this.sessions.get(sessionId);
+        if (!state)
+            return '';
+        if (!state.length)
+            return state.history;
+        const pending = state.chunks.length === 1 ? state.chunks[0] : state.chunks.join('');
+        return this.bound(`${state.history}${pending}`);
+    }
+    pendingChunkCount() {
+        let count = 0;
+        for (const state of this.sessions.values())
+            count += state.chunks.length;
+        return count;
+    }
+    hasScheduledFlush() {
+        return this.timer !== null;
+    }
+    bound(text) {
+        return text.length > this.historyLimit ? text.slice(-this.historyLimit) : text;
+    }
+    schedule() {
+        if (this.timer)
+            return;
+        this.timer = setTimeout(() => {
+            this.timer = null;
+            this.flushAll();
+        }, this.flushIntervalMs);
+        this.timer.unref?.();
+    }
+    clearTimerWhenIdle(force = false) {
+        if (!this.timer)
+            return;
+        const hasPending = !force && Array.from(this.sessions.values()).some(state => state.length > 0);
+        if (hasPending)
+            return;
+        clearTimeout(this.timer);
+        this.timer = null;
+    }
+}
+exports.TerminalOutputBuffer = TerminalOutputBuffer;
+//# sourceMappingURL=terminalOutputBuffer.js.map

package/dist/core/types.d.ts

@@ -112,6 +112,17 @@ export interface AgentWorkEvent {
         steering: string[];
         followUp: string[];
     };
+    /** Structured queue rows with stable kernel ids (mobile/PC queue unification export). */
+    queueItems?: Array<{
+        id: string;
+        text: string;
+        queueMode: string;
+        requestedMode?: string;
+        goalObjective?: string;
+        runId?: string;
+        createdAt: string;
+    }>;
+    queuePaused?: boolean;
     workspaceId?: string;
     workspaceKey?: string;
     runtimeKey?: string;
@@ -124,6 +135,16 @@ export interface AgentWorkEvent {
     status?: GuideReceiptStatus | ConversationWorkRunStatus | 'stopping' | 'force_restarting';
     guide?: GuideReceipt;
     displayImage?: DisplayImageAttachment;
+    /**
+     * 结构化模型回退信号：from 为回退前的模型名，to 为实际使用的模型名。
+     * 前端据此把输入框下方的模型选择区同步为实际生效的模型，而不是隐藏的
+     * 参数回退。
+     */
+    fallback?: {
+        from: string;
+        to: string;
+        providerId?: string;
+    };
 }
 export interface ConversationWorkRun {
     runId: string;

package/dist/core/wslAgentRuntimePool.js

@@ -569,8 +569,12 @@ class WslAgentRuntimePool {
         return this.accessSequence;
     }
     maxResidentRuntimes() {
-        const configured = Number(this.options.maxResidentRuntimes ?? 2);
-        return Number.isFinite(configured) ? Math.max(1, Math.floor(configured)) : 2;
+        // Same rationale as the Electron utility pool: one runtime per active
+        // conversation target. The previous default of 2 blocked parallel
+        // conversations with a capacity error; idle LRU eviction still bounds
+        // resident memory.
+        const configured = Number(this.options.maxResidentRuntimes ?? 8);
+        return Number.isFinite(configured) ? Math.max(1, Math.floor(configured)) : 8;
     }
     async serializeCapacity(operation) {
         const previous = this.capacityTail;

package/dist/llm/provider.d.ts

@@ -96,7 +96,7 @@ export declare class LLMProvider {
      * `provider_adapters_v2` context flag. Request serialization and SSE
      * normalization are delegated to the shared provider adapters while the
      * transport orchestration (loopback node-http, fetch -> node-http fallback,
-     * 120s/30s timeouts) and the 4xx Chat -> Responses downgrade stay here.
+     * cancellation-only streaming and the 4xx Chat -> Responses downgrade) stay here.
      * The emitted request body and StreamToken stream are byte-equivalent to
      * the legacy inlined path.
      */
@@ -106,9 +106,9 @@ export declare class LLMProvider {
     private shouldDowngradeToResponses;
     /**
      * Loopback-aware transport injected into adapter `execute`. Streaming
-     * requests retain the fetch-to-node fallback for transport failures, while
-     * a local deadline is returned directly so one request cannot become a
-     * second Windows fallback request.
+     * requests retain the fetch-to-node fallback for transport failures. They
+     * have no response deadline; only caller cancellation or a concrete
+     * transport/provider failure may end the request.
      */
     private buildProviderAdapterTransport;
     private toTransportResponse;