newmark-agent 0.5.3 → 0.5.7

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/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/main.js

@@ -3020,6 +3020,10 @@ else {
                     activePromptLeases.set(promptLeaseKey, (activePromptLeases.get(promptLeaseKey) || 0) + 1);
                     activePromptWorkspaces.set(promptLeaseWorkspaceKey, (activePromptWorkspaces.get(promptLeaseWorkspaceKey) || 0) + 1);
                     const targetConversation = target.conversationId;
+                    // 发送命令时锁定输入框选择的模型：接受命令后的整个运行过程都以该
+                    // 模型为准（唯一例外是显式的不可用回退，且回退会以结构化事件同步
+                    // 到前端输入框下方的选择区，而不是隐藏的参数回退）。
+                    const requestedModel = agent.model;
                     const options = {
                         mode: agent.mode,
                         model: agent.ensureUsableModelSelection(),
@@ -3027,6 +3031,21 @@ else {
                         inputMode: agent.inputMode,
                         engine: agent.engine,
                     };
+                    if (options.model && requestedModel && options.model !== requestedModel) {
+                        const usableConfig = agent.activeModelConfig();
+                        broadcastAgentWorkEvent({
+                            id: `model-fallback-${Date.now()}-${Math.random().toString(16).slice(2)}`,
+                            conversationId: target.conversationId,
+                            type: 'status',
+                            content: `[Model fallback] ${requestedModel} unavailable; switched to ${options.model}.`,
+                            mode: agent.modeName(),
+                            model: options.model,
+                            timestamp: new Date().toISOString(),
+                            workspaceId: target.workspaceId,
+                            workspaceKey: target.workspaceKey,
+                            fallback: { from: requestedModel, to: options.model, providerId: usableConfig?.provider_id || agent.activeDeployment()?.providerId },
+                        });
+                    }
                     const queueMode = agent.inputMode === 'guide' ? 'steer' : 'followUp';
                     let result;
                     if (wslBackendEnabled()) {
@@ -5206,6 +5225,21 @@ else {
                 // make an ordinary minimize click disappear from the taskbar.
                 win?.minimize();
             });
+            electron_1.ipcMain.handle('glass:captureBackdrop', async (event, requestedSize) => {
+                const image = await event.sender.capturePage();
+                const sourceSize = image.getSize();
+                const width = Math.max(1, Math.min(sourceSize.width, Math.round(Number(requestedSize?.width) || sourceSize.width)));
+                const height = Math.max(1, Math.min(sourceSize.height, Math.round(Number(requestedSize?.height) || sourceSize.height)));
+                const resized = sourceSize.width === width && sourceSize.height === height
+                    ? image
+                    : image.resize({ width, height, quality: 'good' });
+                return {
+                    bytes: resized.toJPEG(82),
+                    mimeType: 'image/jpeg',
+                    width,
+                    height,
+                };
+            });
             electron_1.ipcMain.handle('app:maximize', () => {
                 const win = electron_1.BrowserWindow.getFocusedWindow() || mainWindow;
                 if (win?.isMaximized())

package/dist/preload.js

@@ -6,6 +6,7 @@ contextBridge.exposeInMainWorld('api', {
     startupWaitForBackend: () => ipcRenderer.invoke('startup:waitForBackend'),
     startupUiReady: (payload) => ipcRenderer.invoke('startup:uiReady', payload),
     startupUiFailed: (payload) => ipcRenderer.invoke('startup:uiFailed', payload),
+    captureLiquidBackdrop: (size) => ipcRenderer.invoke('glass:captureBackdrop', size),
     onStartupStatus: (callback) => {
         ipcRenderer.on('startup:status', (_event, payload) => callback(payload));
     },

package/dist/providers/provider-events.d.ts

@@ -17,6 +17,12 @@ export declare function providerStreamTimeoutError(timeoutMs: number): Error;
  * Read one SSE chunk with both user cancellation and an inactivity deadline.
  * Cancelling the reader is important: rejecting the race alone leaves the
  * provider socket alive and lets later requests accumulate behind it.
+ *
+ * timeoutMs defaults to 0 (no stream idle deadline), matching the request-
+ * level DEFAULT_PROVIDER_REQUEST_TIMEOUT_MS = 0 and the Android client's
+ * readTimeout(0) / SSE_IDLE_TIMEOUT_MS = 0L. A caller that still wants an
+ * inactivity cap passes an explicit positive value (the recovery verify
+ * passes 50ms to prove reader cancellation).
  */
 export declare function readProviderStreamChunk(reader: ReadableStreamDefaultReader<Uint8Array>, signal: AbortSignal, timeoutMs?: number): Promise<ReadableStreamReadResult<Uint8Array>>;
 export declare function parseProviderSse(raw: string): Array<{

package/dist/providers/provider-events.js

@@ -46,8 +46,14 @@ function providerStreamTimeoutError(timeoutMs) {
  * Read one SSE chunk with both user cancellation and an inactivity deadline.
  * Cancelling the reader is important: rejecting the race alone leaves the
  * provider socket alive and lets later requests accumulate behind it.
+ *
+ * timeoutMs defaults to 0 (no stream idle deadline), matching the request-
+ * level DEFAULT_PROVIDER_REQUEST_TIMEOUT_MS = 0 and the Android client's
+ * readTimeout(0) / SSE_IDLE_TIMEOUT_MS = 0L. A caller that still wants an
+ * inactivity cap passes an explicit positive value (the recovery verify
+ * passes 50ms to prove reader cancellation).
  */
-async function readProviderStreamChunk(reader, signal, timeoutMs = 30_000) {
+async function readProviderStreamChunk(reader, signal, timeoutMs = 0) {
     if (signal.aborted)
         throw providerAbortError(signal);
     let timer;
@@ -56,9 +62,14 @@ async function readProviderStreamChunk(reader, signal, timeoutMs = 30_000) {
         onAbort = () => reject(providerAbortError(signal));
         signal.addEventListener('abort', onAbort, { once: true });
     });
-    const timeoutPromise = new Promise((_, reject) => {
-        timer = setTimeout(() => reject(providerStreamTimeoutError(timeoutMs)), timeoutMs);
-    });
+    // timeoutMs <= 0 means no inactivity deadline (unlimited). setTimeout with
+    // 0 would fire on the next tick, so we only arm the timer for positive
+    // values and race a never-settling promise otherwise.
+    const timeoutPromise = timeoutMs > 0
+        ? new Promise((_, reject) => {
+            timer = setTimeout(() => reject(providerStreamTimeoutError(timeoutMs)), timeoutMs);
+        })
+        : new Promise(() => undefined);
     try {
         return await Promise.race([reader.read(), abortPromise, timeoutPromise]);
     }

package/dist/server.js

@@ -1298,6 +1298,27 @@ async function handleApi(req, res, body) {
                 mobileJson(res, await hostedConversationUiAction({ workspaceId, conversationId }, action, String(params.value || ''), params));
                 return;
             }
+            case '/api/queue-action': {
+                // Desktop-renderer queue mutations. The mobile endpoint requires a
+                // pairing token; the renderer shares the same process and is trusted,
+                // so it gets a dedicated unauthenticated route that reuses the same
+                // GUI runtime-pool queueAction path (update/delete/reorder/guide).
+                const params = JSON.parse(body || '{}');
+                const workspaceId = String(params.workspaceId || '');
+                const conversationId = String(params.conversationId || '');
+                const action = String(params.action || '');
+                const allowed = new Set(['queue_enqueue', 'queue_update', 'queue_delete', 'queue_reorder', 'queue_toggle_pause', 'queue_guide']);
+                if (!workspaceId || !conversationId || !allowed.has(action)) {
+                    jsonResponse(res, { error: 'workspaceId, conversationId, and a valid queue action are required' }, 400);
+                    return;
+                }
+                if (!hostedConversationUiAction) {
+                    jsonResponse(res, { error: 'This action requires the GUI-hosted runtime pool' }, 409);
+                    return;
+                }
+                jsonResponse(res, await hostedConversationUiAction({ workspaceId, conversationId }, action, String(params.value || ''), params));
+                return;
+            }
             case '/api/mobile/conversation-rename': {
                 const params = JSON.parse(body || '{}');
                 const workspaceId = String(params.workspaceId || '');

package/dist/tools/index.d.ts

@@ -2,6 +2,7 @@ import { ConfigManager } from '../core/config';
 import { NewmarkToolDefinition, NewmarkToolResult } from '../core/compat';
 import { SshManager } from '../core/ssh';
 import { WorkspaceManager } from '../core/workspace';
+import { LocalOcrResult } from '../core/localOcr';
 export interface ToolExecutionContext {
     mode?: string;
     workspacePath?: string;
@@ -30,6 +31,8 @@ export declare class ToolExecutor {
     private hostProfile;
     constructor(root: string, config: ConfigManager, ssh?: SshManager | undefined, workspace?: WorkspaceManager | undefined);
     webSearch(query: string): Promise<string>;
+    /** OCR entry point for the runtime's final visual fallback. */
+    finalVisualFallbackOcr(dataUrl: string, signal?: AbortSignal): Promise<LocalOcrResult>;
     setHostProfile(profile: ToolHostProfile): void;
     definitions(mode?: string): unknown[];
     canonicalDefinitions(mode?: string): NewmarkToolDefinition[];

package/dist/tools/index.js

@@ -234,6 +234,10 @@ class ToolExecutor {
     async webSearch(query) {
         return this.wsearch(query);
     }
+    /** OCR entry point for the runtime's final visual fallback. */
+    async finalVisualFallbackOcr(dataUrl, signal) {
+        return await this.localOcr.recognizeDataUrl(dataUrl, signal, 'sparse-ui');
+    }
     setHostProfile(profile) {
         this.hostProfile = { ...profile };
     }