newmark-agent 0.5.4 → 0.5.8

package/dist/llm/provider.js

@@ -43,9 +43,6 @@ const child_process_1 = require("child_process");
 const agentKernelDiagnostics_1 = require("../core/agentKernelDiagnostics");
 const chat_messages_1 = require("../providers/chat-messages");
 const providers_1 = require("../providers");
-// Keep provider requests below the release-harness/user-visible command
-// deadline. A provider that does not answer must produce one bounded error;
-// it must not restart the same request through every Windows transport.
 // Provider responses are intentionally unbounded. User cancellation, transport
 // errors, and tool-specific limits remain the only automatic stop conditions.
 const DEFAULT_PROVIDER_REQUEST_TIMEOUT_MS = 0;
@@ -939,7 +936,7 @@ 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.
      */
@@ -1082,9 +1079,9 @@ class LLMProvider {
     }
     /**
      * 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.
      */
     buildProviderAdapterTransport() {
         return async (request, signal) => {
@@ -1096,7 +1093,9 @@ class LLMProvider {
                     forwardAbort();
                 else
                     signal?.addEventListener('abort', forwardAbort, { once: true });
-                const effectiveTimeout = this.effectiveRequestTimeout(120000);
+                // Streaming provider responses are intentionally unbounded. Only
+                // caller cancellation or an explicit provider failure may end them.
+                const effectiveTimeout = 0;
                 const timer = effectiveTimeout > 0
                     ? setTimeout(() => abort.abort(providerTimeoutError(effectiveTimeout)), effectiveTimeout)
                     : undefined;
@@ -1247,7 +1246,9 @@ class LLMProvider {
             forwardAbort();
         else
             signal?.addEventListener('abort', forwardAbort, { once: true });
-        const effectiveTimeout = this.effectiveRequestTimeout(120000);
+        // Streaming provider responses are intentionally unbounded. Do not turn
+        // silence into an empty-response failure.
+        const effectiveTimeout = 0;
         const timeout = effectiveTimeout > 0
             ? setTimeout(() => abort.abort(providerTimeoutError(effectiveTimeout)), effectiveTimeout)
             : undefined;
@@ -1285,10 +1286,14 @@ class LLMProvider {
             }
             const decoder = new TextDecoder();
             let buffer = '';
-            let currentToolCall = null;
+            const toolCalls = new Map();
+            const toolCallOrder = [];
+            let syntheticToolIndex = 0;
+            let lastToolIndex = 0;
             let currentReasoningContent = '';
             let contentPolicyBlocked = false;
             let emittedContent = false;
+            let explicitCompletion = false;
             const streamSignal = signal || new AbortController().signal;
             while (true) {
                 const { done, value } = await (0, providers_1.readProviderStreamChunk)(reader, streamSignal);
@@ -1302,8 +1307,10 @@ class LLMProvider {
                     if (!trimmed.startsWith('data: '))
                         continue;
                     const data = trimmed.slice(6);
-                    if (data === '[DONE]')
+                    if (data === '[DONE]') {
+                        explicitCompletion = true;
                         continue;
+                    }
                     try {
                         const json = JSON.parse(data);
                         if (json.usage)
@@ -1324,27 +1331,54 @@ class LLMProvider {
                         }
                         if (delta.tool_calls) {
                             for (const tc of delta.tool_calls) {
-                                if (tc.id) {
-                                    if (currentToolCall) {
-                                        yield { type: 'tool_call', text: '', toolCall: currentToolCall, reasoningContent: currentReasoningContent || undefined };
-                                    }
-                                    currentToolCall = { id: tc.id, name: tc.function?.name || '', arguments: tc.function?.arguments || '' };
-                                }
-                                else if (tc.function?.arguments && currentToolCall) {
-                                    currentToolCall.arguments += tc.function.arguments;
+                                const rawIndex = Number(tc.index);
+                                const index = Number.isInteger(rawIndex) && rawIndex >= 0
+                                    ? rawIndex
+                                    : (tc.id ? syntheticToolIndex++ : lastToolIndex);
+                                lastToolIndex = index;
+                                let call = toolCalls.get(index);
+                                if (!call && (tc.id || tc.function?.name)) {
+                                    call = { id: tc.id || '', name: tc.function?.name || '', argumentParts: [] };
+                                    toolCalls.set(index, call);
+                                    toolCallOrder.push(index);
                                 }
+                                if (!call)
+                                    continue;
+                                if (tc.id && !call.id)
+                                    call.id = tc.id;
+                                if (tc.function?.name && !call.name)
+                                    call.name = tc.function.name;
+                                if (tc.function?.arguments)
+                                    call.argumentParts.push(tc.function.arguments);
                             }
                         }
                     }
                     catch { /* skip malformed JSON */ }
                 }
             }
-            if (currentToolCall && currentToolCall.arguments) {
-                yield { type: 'tool_call', text: '', toolCall: currentToolCall, reasoningContent: currentReasoningContent || undefined };
+            if (toolCallOrder.length) {
+                for (const index of toolCallOrder) {
+                    const call = toolCalls.get(index);
+                    if (!call)
+                        continue;
+                    yield {
+                        type: 'tool_call',
+                        text: '',
+                        toolCall: {
+                            id: call.id,
+                            name: call.name,
+                            arguments: (0, providers_1.assembleCompatibleToolArguments)(call.argumentParts),
+                        },
+                        reasoningContent: currentReasoningContent || undefined,
+                    };
+                }
             }
             else if (!emittedContent && contentPolicyBlocked) {
                 yield { type: 'text', text: '[Error] Content policy refusal (content_filter).' };
             }
+            else if (!explicitCompletion && !emittedContent && !currentReasoningContent) {
+                yield { type: 'text', text: '[LLM Error] GitHub Models stream ended before an explicit completion.' };
+            }
         }
         finally {
             reader?.releaseLock();

package/dist/main.js

@@ -77,6 +77,7 @@ 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 terminalOutputBuffer_1 = require("./core/terminalOutputBuffer");
 const cli_help_1 = require("./cli-help");
 const APP_NAME = 'Newmark Agent';
 const APP_ID = 'ai.newmark.agent';
@@ -3020,6 +3021,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 +3032,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()) {
@@ -4432,10 +4452,16 @@ else {
                 }
             });
             const ptySessions = new Map();
-            const sendTerminalData = (sessionId, session, text) => {
-                session.buffer = `${session.buffer}${text}`.slice(-256 * 1024);
+            const terminalOutput = new terminalOutputBuffer_1.TerminalOutputBuffer((sessionId, text) => {
+                const session = ptySessions.get(sessionId);
+                if (session)
+                    session.buffer = terminalOutput.history(sessionId);
                 if (mainWindow && !mainWindow.isDestroyed())
                     mainWindow.webContents.send('pty:data', sessionId, text);
+            });
+            const sendTerminalData = (sessionId, session, text) => {
+                terminalOutput.push(sessionId, text);
+                session.buffer = terminalOutput.history(sessionId);
             };
             electron_1.ipcMain.handle('pty:spawn', async (_event, shellId) => {
                 const sessionId = (0, crypto_1.randomUUID)().slice(0, 8);
@@ -4457,7 +4483,9 @@ else {
                 ptySessions.set(sessionId, session);
                 proc.onData(text => sendTerminalData(sessionId, session, text));
                 proc.onExit(event => {
+                    terminalOutput.flush(sessionId);
                     ptySessions.delete(sessionId);
+                    terminalOutput.close(sessionId);
                     if (mainWindow && !mainWindow.isDestroyed()) {
                         mainWindow.webContents.send('pty:exit', sessionId, event.exitCode);
                     }
@@ -4515,7 +4543,7 @@ else {
                 const session = ptySessions.get(sessionId);
                 if (!session)
                     return { buffer: '' };
-                return { buffer: session.buffer };
+                return { buffer: terminalOutput.history(sessionId) || session.buffer };
             });
             const terminalOwnerFor = (conversationId, actorId) => (0, terminalTakeover_1.normalizeTerminalTakeoverOwner)({
                 backend: wslBackendEnabled() ? 'wsl' : (process.platform === 'win32' ? 'windows' : process.platform),
@@ -5206,6 +5234,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/chat-completions.adapter.js

@@ -105,6 +105,8 @@ class ChatCompletionsAdapter {
         let contentPolicyBlocked = false;
         let emittedContent = false;
         let emittedTool = false;
+        let emittedReasoning = false;
+        let explicitCompletion = false;
         try {
             while (true) {
                 const { done, value } = await (0, provider_events_1.readProviderStreamChunk)(reader, signal);
@@ -118,8 +120,10 @@ class ChatCompletionsAdapter {
                     if (!trimmed.startsWith('data: '))
                         continue;
                     const data = trimmed.slice(6);
-                    if (data === '[DONE]')
+                    if (data === '[DONE]') {
+                        explicitCompletion = true;
                         continue;
+                    }
                     let json;
                     try {
                         json = JSON.parse(data);
@@ -135,13 +139,18 @@ class ChatCompletionsAdapter {
                     if ((0, provider_events_1.isContentPolicyBlocked)(json))
                         contentPolicyBlocked = true;
                     const choices = Array.isArray(json.choices) ? json.choices : [];
-                    const delta = choices[0]?.delta;
+                    const choice = choices[0];
+                    if (choice?.finish_reason !== undefined && choice.finish_reason !== null)
+                        explicitCompletion = true;
+                    const delta = choice?.delta;
                     if (!delta)
                         continue;
                     if (delta.reasoning_content) {
                         const reasoning = this.extractText(delta.reasoning_content);
-                        if (reasoning)
+                        if (reasoning) {
+                            emittedReasoning = true;
                             yield { type: 'reasoning.summary.delta', delta: reasoning };
+                        }
                     }
                     const textDelta = this.extractText(delta.content);
                     if (textDelta) {
@@ -190,7 +199,7 @@ class ChatCompletionsAdapter {
                         type: 'tool_call.completed',
                         id: currentToolCall.id,
                         name: currentToolCall.name,
-                        arguments: currentToolCall.argumentParts.join(''),
+                        arguments: (0, provider_events_1.assembleCompatibleToolArguments)(currentToolCall.argumentParts),
                     };
                 }
             }
@@ -198,6 +207,10 @@ class ChatCompletionsAdapter {
                 yield { type: 'response.failed', error: '[Error] Content policy refusal (content_filter).' };
                 return;
             }
+            if (!explicitCompletion && !emittedContent && !emittedTool && !emittedReasoning) {
+                yield { type: 'response.failed', error: '[LLM Error] Chat stream ended before an explicit completion.' };
+                return;
+            }
             yield { type: 'response.completed' };
         }
         finally {

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

@@ -17,12 +17,25 @@ 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<{
     event?: string;
     data: string;
 }>;
+/**
+ * Compatible gateways may stream function arguments as JSON deltas or repeat
+ * a cumulative snapshot on every SSE frame. Keep the normal incremental form
+ * when it parses, then fall back to snapshot folding. Returning malformed
+ * concatenated snapshots would erase the model's correction at tool parsing.
+ */
+export declare function assembleCompatibleToolArguments(parts: string[]): string;
 /**
  * Detect content-policy refusals across the provider failure shapes.
  * Mirrors `LLMProvider.contentPolicyBlocked` semantics exactly so the

package/dist/providers/provider-events.js

@@ -5,6 +5,7 @@ exports.providerAbortError = providerAbortError;
 exports.providerStreamTimeoutError = providerStreamTimeoutError;
 exports.readProviderStreamChunk = readProviderStreamChunk;
 exports.parseProviderSse = parseProviderSse;
+exports.assembleCompatibleToolArguments = assembleCompatibleToolArguments;
 exports.isContentPolicyBlocked = isContentPolicyBlocked;
 exports.normalizeProviderUsage = normalizeProviderUsage;
 exports.estimateRequestTokens = estimateRequestTokens;
@@ -46,8 +47,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 +63,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]);
     }
@@ -94,6 +106,45 @@ function parseProviderSse(raw) {
     }
     return events;
 }
+/**
+ * Compatible gateways may stream function arguments as JSON deltas or repeat
+ * a cumulative snapshot on every SSE frame. Keep the normal incremental form
+ * when it parses, then fall back to snapshot folding. Returning malformed
+ * concatenated snapshots would erase the model's correction at tool parsing.
+ */
+function assembleCompatibleToolArguments(parts) {
+    const nonEmpty = (parts || []).map(String).filter(part => part && part !== 'null');
+    if (!nonEmpty.length)
+        return '{}';
+    const isJsonObject = (value) => {
+        try {
+            const parsed = JSON.parse(value);
+            return !!parsed && typeof parsed === 'object' && !Array.isArray(parsed);
+        }
+        catch {
+            return false;
+        }
+    };
+    const incremental = nonEmpty.join('');
+    if (isJsonObject(incremental))
+        return incremental;
+    let compatible = '';
+    for (const incoming of nonEmpty) {
+        if (!compatible)
+            compatible = incoming;
+        else if (incoming === compatible)
+            continue;
+        else if (incoming.startsWith(compatible))
+            compatible = incoming;
+        else if (compatible.startsWith(incoming))
+            continue;
+        else
+            compatible += incoming;
+    }
+    if (isJsonObject(compatible))
+        return compatible;
+    return [...nonEmpty].reverse().find(isJsonObject) || compatible;
+}
 /**
  * Detect content-policy refusals across the provider failure shapes.
  * Mirrors `LLMProvider.contentPolicyBlocked` semantics exactly so the

package/dist/providers/responses.adapter.js

@@ -155,6 +155,7 @@ class ResponsesAdapter {
                             const key = `${String(payload.item_id || '')}:${String(payload.summary_index || 0)}`;
                             const delta = this.extractText(payload.delta);
                             if (delta) {
+                                emittedContent = true;
                                 reasoningSummaries.set(key, (reasoningSummaries.get(key) || '') + delta);
                                 yield { type: 'reasoning.summary.delta', delta };
                             }
@@ -185,7 +186,7 @@ class ResponsesAdapter {
                                 calls.set(key, {
                                     id: String(item.call_id || item.id || key),
                                     name: String(item.name || ''),
-                                    arguments: String(item.arguments || ''),
+                                    argumentParts: item.arguments ? [String(item.arguments)] : [],
                                     emitted: false,
                                 });
                             }
@@ -193,9 +194,10 @@ class ResponsesAdapter {
                         }
                         if (eventType === 'response.function_call_arguments.delta') {
                             const key = String(payload.item_id || payload.call_id || payload.output_index || '');
-                            const call = calls.get(key) || { id: String(payload.call_id || key), name: String(payload.name || ''), arguments: '', emitted: false };
+                            const call = calls.get(key) || { id: String(payload.call_id || key), name: String(payload.name || ''), argumentParts: [], emitted: false };
                             const delta = String(payload.delta || '');
-                            call.arguments += delta;
+                            if (delta)
+                                call.argumentParts.push(delta);
                             calls.set(key, call);
                             yield { type: 'tool_call.arguments.delta', id: call.id, delta };
                             continue;
@@ -207,19 +209,21 @@ class ResponsesAdapter {
                                 const call = calls.get(key) || {
                                     id: String(item.call_id || item.id || key),
                                     name: String(item.name || ''),
-                                    arguments: String(item.arguments || ''),
+                                    argumentParts: item.arguments ? [String(item.arguments)] : [],
                                     emitted: false,
                                 };
                                 call.id = String(item.call_id || call.id);
                                 call.name = String(item.name || call.name);
-                                call.arguments = typeof item.arguments === 'string' ? item.arguments : call.arguments;
+                                if (typeof item.arguments === 'string' && item.arguments)
+                                    call.argumentParts.push(item.arguments);
                                 if (!call.emitted) {
                                     call.emitted = true;
+                                    const argumentsJson = (0, provider_events_1.assembleCompatibleToolArguments)(call.argumentParts);
                                     yield { type: 'tool_call.started', id: call.id, name: call.name };
-                                    if (call.arguments && call.arguments !== '{}') {
-                                        yield { type: 'tool_call.arguments.delta', id: call.id, delta: call.arguments };
+                                    if (argumentsJson !== '{}') {
+                                        yield { type: 'tool_call.arguments.delta', id: call.id, delta: argumentsJson };
                                     }
-                                    yield { type: 'tool_call.completed', id: call.id, name: call.name, arguments: call.arguments };
+                                    yield { type: 'tool_call.completed', id: call.id, name: call.name, arguments: argumentsJson };
                                 }
                                 calls.set(key, call);
                             }
@@ -252,9 +256,19 @@ class ResponsesAdapter {
                 yield { type: 'response.failed', error: '[LLM Error] Responses stream ended before response.completed.' };
             }
             else if (!emittedContent && calls.size === 0) {
-                yield { type: 'response.failed', error: '[Error] Empty Responses stream.' };
+                yield { type: 'response.failed', error: '[Error] Provider returned an empty response.' };
             }
             else {
+                // Some compatible Responses providers omit output_item.done but still
+                // complete the response. Preserve that valid tool activity and fold
+                // cumulative argument snapshots before handing it to the kernel.
+                for (const call of calls.values()) {
+                    if (call.emitted)
+                        continue;
+                    const argumentsJson = (0, provider_events_1.assembleCompatibleToolArguments)(call.argumentParts);
+                    yield { type: 'tool_call.started', id: call.id, name: call.name };
+                    yield { type: 'tool_call.completed', id: call.id, name: call.name, arguments: argumentsJson };
+                }
                 yield { type: 'response.completed' };
             }
         }

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 || '');