newmark-agent 0.4.7 → 0.4.9

package/dist/core/conversationKernel.js

@@ -60,6 +60,216 @@ class ConversationKernel {
             followUp: queued?.followUp.slice() || [],
         };
     }
+    queueItems(target) {
+        const runtime = this.findRuntime(target);
+        if (!runtime)
+            return [];
+        return runtime.pendingNextTurn.flatMap(item => {
+            if (item.queueMode !== 'followUp')
+                return [];
+            if (typeof item.message === 'string')
+                return [];
+            const id = String(item.message.clientMessageId || '');
+            if (!id)
+                return [];
+            return [{
+                    id,
+                    text: String(item.message.visibleUserInput || item.message.text || '').replace(/^\[Next queued while current turn is running\]\n/, ''),
+                    queueMode: item.queueMode,
+                    requestedMode: item.message.visibleMode,
+                    goalObjective: item.message.goalObjective,
+                    runId: item.message.runId,
+                    createdAt: String(item.message.createdAt || ''),
+                }];
+        });
+    }
+    enqueueNext(target, input) {
+        const runtime = this.findRuntime(target);
+        if (!runtime?.activePromise || !runtime.runId)
+            throw new Error('Target conversation is not running');
+        const id = String(input.id || '').trim().slice(0, 200);
+        const text = String(input.text || '').trim();
+        if (!id || !text)
+            throw new Error('Queue item id and text are required');
+        const existing = this.queueItems(runtime.target).find(item => item.id === id);
+        if (existing)
+            return existing;
+        const prompt = `[Next queued while current turn is running]\n${text}`;
+        const createdAt = String(input.createdAt || new Date().toISOString());
+        runtime.pendingNextTurn.push({
+            message: {
+                text: prompt,
+                visibleUserInput: text,
+                visibleMode: String(input.requestedMode || 'build'),
+                goalObjective: String(input.goalObjective || '') || undefined,
+                clientMessageId: id,
+                runId: runtime.runId,
+                createdAt,
+            },
+            queueMode: 'followUp',
+        });
+        runtime.runner.retainConversationContinuations([{
+                content: prompt,
+                queueMode: 'followUp',
+                clientMessageId: id,
+                runId: runtime.runId,
+                createdAt,
+            }]);
+        this.trackQueuedMessage(runtime, prompt, 'followUp');
+        this.emitQueueUpdate(runtime);
+        return this.queueItems(runtime.target).find(item => item.id === id);
+    }
+    updateQueueItem(target, idInput, textInput) {
+        const runtime = this.findRuntime(target);
+        if (!runtime)
+            throw new Error('Target conversation runtime is unavailable');
+        const id = String(idInput || '').trim();
+        const text = String(textInput || '').trim();
+        if (!id || !text)
+            throw new Error('Queue item id and text are required');
+        const pending = runtime.pendingNextTurn.find(item => typeof item.message !== 'string' && item.message.clientMessageId === id);
+        if (!pending || typeof pending.message === 'string')
+            throw new Error('Queue item is no longer editable');
+        const oldPrompt = pending.message.text;
+        pending.message.text = `[Next queued while current turn is running]\n${text}`;
+        pending.message.visibleUserInput = text;
+        runtime.runner.consumeConversationContinuation({ content: oldPrompt, queueMode: pending.queueMode, clientMessageId: id });
+        runtime.runner.retainConversationContinuations([{
+                content: pending.message.text,
+                queueMode: pending.queueMode,
+                clientMessageId: id,
+                runId: pending.message.runId,
+            }]);
+        this.replaceTrackedQueuedMessage(runtime, oldPrompt, pending.message.text, pending.queueMode);
+        this.emitQueueUpdate(runtime);
+        return this.queueItems(runtime.target).find(item => item.id === id);
+    }
+    deleteQueueItem(target, idInput) {
+        const runtime = this.findRuntime(target);
+        if (!runtime)
+            return false;
+        const id = String(idInput || '').trim();
+        const index = runtime.pendingNextTurn.findIndex(item => typeof item.message !== 'string' && item.message.clientMessageId === id);
+        if (index < 0)
+            return false;
+        const [removed] = runtime.pendingNextTurn.splice(index, 1);
+        if (typeof removed.message !== 'string') {
+            runtime.runner.consumeConversationContinuation({ content: removed.message.text, queueMode: removed.queueMode, clientMessageId: id });
+            this.consumeQueuedMessage(runtime, removed.message.text);
+        }
+        this.emitQueueUpdate(runtime);
+        return true;
+    }
+    reorderQueueItems(target, orderedIdsInput) {
+        const runtime = this.findRuntime(target);
+        if (!runtime)
+            throw new Error('Target conversation runtime is unavailable');
+        const currentItems = this.queueItems(runtime.target);
+        const orderedIds = Array.isArray(orderedIdsInput)
+            ? orderedIdsInput.map(id => String(id || '').trim())
+            : [];
+        const currentIds = currentItems.map(item => item.id);
+        const completeOrder = orderedIds.length === currentIds.length
+            && new Set(orderedIds).size === orderedIds.length
+            && orderedIds.every(id => currentIds.includes(id));
+        if (!completeOrder)
+            throw new Error('A complete queue order with unique current item ids is required');
+        const persistedIds = runtime.runner.conversationContinuations()
+            .filter(item => item.queueMode === 'followUp' && !!item.clientMessageId)
+            .map(item => String(item.clientMessageId));
+        if (persistedIds.length !== currentIds.length
+            || new Set(persistedIds).size !== persistedIds.length
+            || persistedIds.some(id => !currentIds.includes(id))) {
+            throw new Error('Persisted queue does not match the complete queue order');
+        }
+        const pendingById = new Map(runtime.pendingNextTurn.flatMap(item => {
+            if (item.queueMode !== 'followUp' || typeof item.message === 'string' || !item.message.clientMessageId)
+                return [];
+            return [[String(item.message.clientMessageId), item]];
+        }));
+        const reorderedPending = orderedIds.map(id => pendingById.get(id));
+        let nextIndex = 0;
+        runtime.pendingNextTurn = runtime.pendingNextTurn.map(item => {
+            if (item.queueMode !== 'followUp' || typeof item.message === 'string' || !item.message.clientMessageId)
+                return item;
+            return reorderedPending[nextIndex++];
+        });
+        runtime.runner.reorderConversationContinuations(orderedIds);
+        runtime.queued.followUp = orderedIds.map(id => pendingById.get(id))
+            .map(item => typeof item.message === 'string' ? item.message : item.message.text);
+        this.emitQueueUpdate(runtime);
+        return this.queueItems(runtime.target);
+    }
+    setQueuePaused(target, paused) {
+        const runtime = this.findRuntime(target);
+        if (!runtime)
+            throw new Error('Target conversation runtime is unavailable');
+        runtime.queuePaused = paused;
+        this.emitQueueUpdate(runtime);
+        if (!paused && !runtime.activePromise && runtime.pendingNextTurn.length) {
+            this.schedulePendingRuntimeContinuation(runtime, runtime.runId);
+        }
+        return runtime.queuePaused;
+    }
+    queueAction(target, action, input = {}) {
+        const runtime = this.findRuntime(target);
+        if (!runtime)
+            throw new Error('Target conversation runtime is unavailable');
+        let receipt;
+        if (action === 'enqueue') {
+            this.enqueueNext(runtime.target, {
+                id: String(input.id || ''),
+                text: String(input.text || ''),
+                requestedMode: input.requestedMode,
+                goalObjective: input.goalObjective,
+                createdAt: input.createdAt,
+            });
+        }
+        else if (action === 'update') {
+            this.updateQueueItem(runtime.target, String(input.id || ''), String(input.text || ''));
+        }
+        else if (action === 'delete') {
+            if (!this.deleteQueueItem(runtime.target, String(input.id || '')))
+                throw new Error('Queue item was not found');
+        }
+        else if (action === 'reorder') {
+            this.reorderQueueItems(runtime.target, input.orderedIds || []);
+        }
+        else if (action === 'toggle_pause') {
+            this.setQueuePaused(runtime.target, !runtime.queuePaused);
+        }
+        else if (action === 'guide') {
+            const item = this.queueItems(runtime.target).find(entry => entry.id === String(input.id || ''));
+            if (!item)
+                throw new Error('Queue item was not found');
+            receipt = this.enqueueGuide({
+                clientMessageId: item.id,
+                guideId: (0, crypto_1.randomUUID)(),
+                target: runtime.target,
+                runId: runtime.runId,
+                deliveryMode: 'steer',
+                text: item.goalObjective ? `Goal for the current Build:\n${item.goalObjective}` : item.text,
+                goalObjective: item.goalObjective,
+                createdAt: item.createdAt || new Date().toISOString(),
+            });
+            if (receipt.status === 'rejected')
+                return {
+                    ok: false,
+                    queueItems: this.queueItems(runtime.target),
+                    queuePaused: runtime.queuePaused,
+                    queued: this.queued(runtime.target),
+                    receipt,
+                };
+            this.deleteQueueItem(runtime.target, item.id);
+        }
+        return {
+            ok: true,
+            queueItems: this.queueItems(runtime.target),
+            queuePaused: runtime.queuePaused,
+            queued: this.queued(runtime.target),
+            receipt,
+        };
+    }
     events(target) {
         return this.findRuntime(target)?.events.slice() || [];
     }
@@ -89,6 +299,8 @@ class ConversationKernel {
             workRuns: this.bindWorkRunsToRuntimeTarget(conversationSnapshot.workRuns, normalized),
             target: normalized,
             queued: this.queued(normalized),
+            queueItems: this.queueItems(normalized),
+            queuePaused: runtime?.queuePaused === true,
             workEvents: this.events(normalized),
             runtime: this.runtimeState(normalized),
             mode: runner.mode,
@@ -562,7 +774,7 @@ class ConversationKernel {
                         stopped = true;
                         this.settleCooperativeStop(runtime, runId);
                     }
-                    else if (runtime.pendingNextTurn.length > 0) {
+                    else if (!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.
@@ -605,7 +817,7 @@ class ConversationKernel {
             return this.result(runtime, lastTokens);
         }
         for (;;) {
-            while (runtime.pendingNextTurn.length > 0) {
+            while (!runtime.queuePaused && runtime.pendingNextTurn.length > 0) {
                 if (runtime.stopRequestedRunId === runtime.runId)
                     return this.result(runtime, lastTokens);
                 const next = runtime.pendingNextTurn.shift();
@@ -652,7 +864,8 @@ class ConversationKernel {
                     this.mirrorHostIfTargetActive(runtime);
                     return this.result(runtime, lastTokens);
                 }
-                this.clearQueued(runtime);
+                if (!runtime.pendingNextTurn.length)
+                    this.clearQueued(runtime);
                 const completedRunId = runtime.runId;
                 runtime.runner.finishConversationWorkRun(completedRunId, 'completed');
                 // A Guide can be submitted synchronously by a consumer of the public
@@ -662,6 +875,7 @@ class ConversationKernel {
                 await new Promise(resolve => setImmediate(resolve));
                 if (runtime.runId === completedRunId
                     && runtime.stopRequestedRunId !== completedRunId
+                    && !runtime.queuePaused
                     && runtime.pendingNextTurn.length > 0) {
                     runtime.guideAcceptanceClosedRunId = '';
                     if (!runtime.runner.resumeConversationWorkRun(completedRunId)) {
@@ -757,6 +971,7 @@ class ConversationKernel {
             events: [],
             pendingNextTurn: [],
             queued: { steering: [], followUp: [] },
+            queuePaused: false,
             runId: '',
             generation: this.generations.get(target.runtimeKey) || 0,
             stopRequestedRunId: '',
@@ -874,7 +1089,7 @@ class ConversationKernel {
         }
         setImmediate(() => {
             runtime.pendingContinuationRunId = undefined;
-            if (runtime.runId !== runId || runtime.activePromise || runtime.stopRequestedRunId === runId)
+            if (runtime.runId !== runId || runtime.activePromise || runtime.stopRequestedRunId === runId || runtime.queuePaused)
                 return;
             const next = runtime.pendingNextTurn.shift();
             if (!next)
@@ -1040,8 +1255,39 @@ class ConversationKernel {
         const isSteer = queueMode === 'steer';
         const text = typeof message === 'string' ? message : message.text;
         const prompt = isSteer ? text : `[Next queued while current turn is running]\n${text}`;
-        if (!isSteer)
-            this.trackQueuedMessage(runtime, prompt, queueMode);
+        if (!isSteer) {
+            const structured = typeof message === 'string' ? null : message;
+            const clientMessageId = String(structured?.clientMessageId || (0, crypto_1.randomUUID)());
+            const queuedMessage = {
+                ...(structured || {}),
+                text: prompt,
+                visibleUserInput: structured?.visibleUserInput || text,
+                visibleMode: structured?.visibleMode || runtime.options.mode,
+                clientMessageId,
+                runId: structured?.runId || runtime.runId,
+                createdAt: String(structured?.createdAt || new Date().toISOString()),
+            };
+            if (!runtime.pendingNextTurn.some(item => typeof item.message !== 'string' && item.message.clientMessageId === clientMessageId)) {
+                runtime.pendingNextTurn.push({ message: queuedMessage, queueMode: 'followUp' });
+            }
+            runtime.runner.retainConversationContinuations([{
+                    content: prompt,
+                    queueMode: 'followUp',
+                    clientMessageId,
+                    runId: queuedMessage.runId,
+                    images: queuedMessage.images?.map(image => ({ ...image })),
+                    attachments: queuedMessage.attachments?.map(attachment => ({ ...attachment })),
+                    createdAt: queuedMessage.createdAt,
+                }]);
+            this.trackQueuedMessage(runtime, prompt, 'followUp');
+            runtime.runner.recordWorkStatus(runtime.stopRequestedRunId === runtime.runId
+                ? 'Next message retained while stopping.'
+                : 'Next message queued.');
+            if (runtime.stopRequestedRunId === runtime.runId)
+                runtime.forceStopArmedRunId = '';
+            this.emitQueueUpdate(runtime);
+            return;
+        }
         if (runtime.stopRequestedRunId === runtime.runId) {
             runtime.forceStopArmedRunId = '';
             const structured = typeof message === 'string' ? undefined : message;
@@ -1096,6 +1342,13 @@ class ConversationKernel {
         if (changed)
             this.emitQueueUpdate(runtime);
     }
+    replaceTrackedQueuedMessage(runtime, oldMessage, nextMessage, queueMode) {
+        this.queueState(runtime);
+        const list = queueMode === 'steer' ? runtime.queued.steering : runtime.queued.followUp;
+        const index = list.indexOf(oldMessage);
+        if (index >= 0)
+            list[index] = nextMessage;
+    }
     emitQueueUpdate(runtime) {
         this.queueState(runtime);
         runtime.runner.emitWorkEvent({
@@ -1236,10 +1489,11 @@ class ConversationKernel {
         await Promise.resolve();
         if (runtime.runId !== runId || runtime.stopRequestedRunId === runId)
             return true;
-        if (runtime.pendingNextTurn.length > 0 || runtime.runner.subagents.readRootInbox().length > 0)
+        const hasSteering = runtime.pendingNextTurn.some(item => item.queueMode === 'steer');
+        if (hasSteering || runtime.runner.subagents.readRootInbox().length > 0)
             return false;
         runtime.guideAcceptanceClosedRunId = runId;
-        if (runtime.pendingNextTurn.length > 0 || runtime.runner.subagents.readRootInbox().length > 0) {
+        if (runtime.pendingNextTurn.some(item => item.queueMode === 'steer') || runtime.runner.subagents.readRootInbox().length > 0) {
             runtime.guideAcceptanceClosedRunId = '';
             return false;
         }

package/dist/core/electronUtilityAgentClient.d.ts

@@ -1,6 +1,7 @@
 import { spawn } from 'child_process';
 import { NormalizedConversationTarget } from './conversationTarget';
 import { AgentMode, AgentWorkEvent, ConversationInputEnvelope, GuideReceipt } from './types';
+import { ConversationQueueAction, ConversationQueueActionInput } from './conversationKernel';
 import { UtilityAgentPromptResult, UtilityAutoRouteRatingResult, UtilityAgentSnapshotResult, UtilityAgentStopResult, UtilityConversationRewindResult, UtilityHostToolRequest, UtilityPromptRequest } from './utilityAgentProtocol';
 type WindowsProcessTreeHelperRuntime = {
     kind: 'precompiled' | 'runtime_compile';
@@ -94,6 +95,7 @@ export declare class ElectronUtilityAgentClient {
     rewind(messageIndex: number): Promise<UtilityConversationRewindResult>;
     requestStop(runId?: string): Promise<UtilityAgentStopResult>;
     enqueueGuide(envelope: ConversationInputEnvelope): Promise<GuideReceipt>;
+    queueAction(action: ConversationQueueAction, input?: ConversationQueueActionInput): Promise<Record<string, unknown>>;
     checkpoint(): Promise<Record<string, unknown>>;
     contextCompress(options?: {
         keepRecent?: number;

package/dist/core/electronUtilityAgentClient.js

@@ -1023,6 +1023,10 @@ class ElectronUtilityAgentClient {
         await this.start();
         return await this.request('guide', { target: this.target, envelope }, 5_000);
     }
+    async queueAction(action, input = {}) {
+        await this.start();
+        return await this.request('queue_action', { target: this.target, action, input }, 5_000);
+    }
     async checkpoint() {
         await this.start();
         return await this.request('checkpoint', { target: this.target }, 5_000);
@@ -1334,7 +1338,7 @@ class ElectronUtilityAgentClient {
         let result;
         const controller = new AbortController();
         this.hostToolRuns.set(request.requestId, { generation, controller });
-        const allowed = new Set(['browser_control', 'browser_use', 'computer_use', 'automation', 'terminal_takeover']);
+        const allowed = new Set(['browser_control', 'browser_use', 'screen_capture', 'computer_use', 'automation', 'terminal_takeover']);
         if (!allowed.has(request.tool)) {
             result = { requestId: request.requestId, ok: false, error: `Electron host tool is not allowed: ${String(request.tool)}` };
         }

package/dist/core/electronUtilityRuntimePool.d.ts

@@ -1,4 +1,5 @@
 import { AgentMode, AgentWorkEvent, ConversationInputEnvelope, GuideReceipt } from './types';
+import { ConversationQueueAction, ConversationQueueActionInput } from './conversationKernel';
 import { ConversationRuntimeTarget, NormalizedConversationTarget } from './conversationTarget';
 import { UtilityHostToolHandler } from './electronUtilityAgentClient';
 import { UtilityAgentPromptResult, UtilityAutoRouteRatingResult, UtilityConversationRewindResult, UtilityAgentSnapshotResult, UtilityAgentStopResult, UtilityPromptRequest } from './utilityAgentProtocol';
@@ -10,6 +11,7 @@ export interface ElectronTargetRuntimeClient {
     rewind(messageIndex: number): Promise<UtilityConversationRewindResult>;
     requestStop(runId?: string): Promise<UtilityAgentStopResult>;
     enqueueGuide(envelope: ConversationInputEnvelope): Promise<GuideReceipt>;
+    queueAction?(action: ConversationQueueAction, input?: ConversationQueueActionInput): Promise<Record<string, unknown>>;
     checkpoint(): Promise<Record<string, unknown>>;
     contextCompress?(options?: {
         keepRecent?: number;
@@ -71,6 +73,7 @@ export declare class ElectronUtilityRuntimePool {
     rewind(target: ConversationRuntimeTarget, messageIndex: number): Promise<UtilityConversationRewindResult>;
     requestStop(target: ConversationRuntimeTarget, runId?: string): Promise<ElectronPoolStopResult>;
     enqueueGuide(envelope: ConversationInputEnvelope): Promise<GuideReceipt>;
+    queueAction(target: ConversationRuntimeTarget, action: ConversationQueueAction, input?: ConversationQueueActionInput): Promise<Record<string, unknown>>;
     checkpoint(target: ConversationRuntimeTarget): Promise<Record<string, unknown>>;
     contextCompress(target: ConversationRuntimeTarget, options?: {
         keepRecent?: number;

package/dist/core/electronUtilityRuntimePool.js

@@ -184,6 +184,17 @@ class ElectronUtilityRuntimePool {
             this.release(entry, true);
         }
     }
+    async queueAction(target, action, input = {}) {
+        const entry = await this.acquireExisting(target);
+        if (!entry || !entry.client.queueAction)
+            throw new Error('Target conversation is not running');
+        try {
+            return await entry.client.queueAction(action, input);
+        }
+        finally {
+            this.release(entry, true);
+        }
+    }
     async checkpoint(target) {
         const normalized = (0, conversationTarget_1.normalizeConversationTarget)(target);
         const entry = await this.acquireExisting(normalized);

package/dist/core/toolPolicy.js

@@ -10,6 +10,7 @@ exports.planModePolicyPrompt = planModePolicyPrompt;
 exports.evaluateDeletionGuard = evaluateDeletionGuard;
 const REQUIRED_TOOLS = new Set(['pwd', 'read', 'glob', 'grep']);
 const MODE_SCOPED_TOOLS = new Set([
+    'screen_capture',
     'image_inspect',
     'image_display',
     'ocr_read',
@@ -42,6 +43,7 @@ const MODE_SCOPED_TOOLS = new Set([
     'branch_create',
 ]);
 const PLAN_READ_ONLY_TOOLS = new Set([
+    'screen_capture',
     'task_read',
     'pwd',
     'read',
@@ -103,6 +105,7 @@ const CONCURRENCY_SAFE_TOOLS = new Set([
     'git_status',
     'file_audit',
     'repo_security_audit',
+    'screen_capture',
     'SubAgent',
 ]);
 /** 判断一个工具是否可参与并行调度。缺省 false（独占）。

package/dist/core/utilityAgentProtocol.d.ts

@@ -1,6 +1,6 @@
 import { BrowserControlRequest, BrowserControlResult } from './browserControl';
 import { BrowserUseRequest } from './browserUse';
-import { AgentPromptMessage, ConversationContextCompressOptions, ConversationKernelRunOptions, ConversationKernelRunResult, ConversationQueueMode, ConversationRuntimeState, ConversationStopResult } from './conversationKernel';
+import { AgentPromptMessage, ConversationContextCompressOptions, ConversationKernelRunOptions, ConversationKernelRunResult, ConversationQueueAction, ConversationQueueActionInput, ConversationQueueMode, ConversationRuntimeState, ConversationStopResult } from './conversationKernel';
 import { ConversationRuntimeTarget, NormalizedConversationTarget } from './conversationTarget';
 import { AgentMode, AgentWorkEvent, ConversationInputEnvelope, GuideReceipt } from './types';
 import type { AutoRouteRatingResult, ConversationSnapshot } from './agent';
@@ -40,6 +40,10 @@ export type UtilityHostToolRequest = (UtilityHostToolRequestBase & {
     tool: 'browser_use';
     args: BrowserUseRequest;
     context: UtilityHostToolContext;
+}) | (UtilityHostToolRequestBase & {
+    tool: 'screen_capture';
+    args: Record<string, unknown>;
+    context: UtilityHostToolContext;
 }) | (UtilityHostToolRequestBase & {
     tool: 'computer_use';
     args: Record<string, unknown>;
@@ -96,6 +100,14 @@ export type UtilityAgentRequest = {
         target: ConversationRuntimeTarget;
         envelope: ConversationInputEnvelope;
     };
+} | {
+    id: string;
+    method: 'queue_action';
+    params: {
+        target: ConversationRuntimeTarget;
+        action: ConversationQueueAction;
+        input?: ConversationQueueActionInput;
+    };
 } | {
     id: string;
     method: 'checkpoint';
@@ -210,6 +222,16 @@ export interface UtilityAgentSnapshotResult {
         steering: string[];
         followUp: string[];
     };
+    queueItems?: Array<{
+        id: string;
+        text: string;
+        queueMode: 'steer' | 'followUp';
+        requestedMode?: string;
+        goalObjective?: string;
+        runId?: string;
+        createdAt: string;
+    }>;
+    queuePaused?: boolean;
     workEvents: AgentWorkEvent[];
     [key: string]: unknown;
 }

package/dist/core/utilityHostToolRouter.js

@@ -126,6 +126,24 @@ function createUtilityHostToolHandler(options) {
             throwIfAborted(signal);
             return result;
         }
+        if (request.tool === 'screen_capture') {
+            const args = request.args || {};
+            const target = String(args.target || '').toLowerCase() === 'application' ? 'application' : 'desktop';
+            const result = await (options.runComputer || computerUse_1.runComputerUse)({
+                action: target === 'application' ? 'app_observe' : 'observe',
+                appTarget: String(args.app_target || args.appTarget || ''),
+                windowHandle: target === 'application' ? String(args.app_target || args.appTarget || '') : '',
+                maxChars: Number(args.max_chars || args.maxChars || 30_000),
+                captureMaxWidth: Number(args.capture_max_width || args.captureMaxWidth),
+                captureMaxHeight: Number(args.capture_max_height || args.captureMaxHeight),
+                allowEphemeralVisionImage: request.context.allowEphemeralVisionImage === true,
+                workspacePath: request.target.workspacePath,
+                invocation: 'agent',
+                ownerId: `screen-capture:${request.target.runtimeKey}:${String(request.context.actorId || ROOT_AGENT_ACTOR_ID)}`,
+            });
+            throwIfAborted(signal);
+            return result;
+        }
         const args = request.args || {};
         const action = String(args.action || '').trim().toLowerCase();
         const trustedComputerUseContext = request.context;

package/dist/core/wslAgentClient.d.ts

@@ -1,4 +1,5 @@
 import { AgentMode, AgentWorkEvent, ConversationInputEnvelope, GuideReceipt } from './types';
+import { ConversationQueueAction, ConversationQueueActionInput } from './conversationKernel';
 import { TerminalTakeoverEvent, TerminalTakeoverOwnerFilter, TerminalTakeoverState } from '../tools/terminalTakeover';
 import { WslAgentPromptRequest, WslAgentPromptResult, WslAutoRouteRatingResult, WslAgentWorkspace, WslAgentStopResult, WslConversationRewindResult, WslHostToolRequest } from './wslAgentProtocol';
 import { ConversationRuntimeTarget, NormalizedConversationTarget } from './conversationTarget';
@@ -71,6 +72,7 @@ export declare class WslAgentClient {
     snapshotTarget(target: ConversationRuntimeTarget): Promise<Record<string, unknown>>;
     rewind(target: ConversationRuntimeTarget, messageIndex: number): Promise<WslConversationRewindResult>;
     enqueueGuide(target: ConversationRuntimeTarget, envelope: ConversationInputEnvelope): Promise<GuideReceipt>;
+    queueAction(target: ConversationRuntimeTarget, action: ConversationQueueAction, input?: ConversationQueueActionInput): Promise<Record<string, unknown>>;
     checkpoint(target: ConversationRuntimeTarget): Promise<Record<string, unknown>>;
     contextCompress(target: ConversationRuntimeTarget, options?: {
         keepRecent?: number;

package/dist/core/wslAgentClient.js

@@ -313,6 +313,10 @@ class WslAgentClient {
         await this.start();
         return await this.request('guide', { target: await this.mapTarget(target), envelope }, 5_000);
     }
+    async queueAction(target, action, input = {}) {
+        await this.start();
+        return await this.request('queue_action', { target: await this.mapTarget(target), action, input }, 5_000);
+    }
     async checkpoint(target) {
         await this.start();
         return await this.request('checkpoint', { target: await this.mapTarget(target) }, 5_000);
@@ -536,7 +540,7 @@ class WslAgentClient {
         else if (!this.hostToolHandler) {
             result = { requestId: request.requestId, ok: false, error: 'No Windows host tool handler is registered' };
         }
-        else if (!['browser_control', 'computer_use', 'browser_use', 'automation', 'terminal_takeover'].includes(request.tool)) {
+        else if (!['browser_control', 'screen_capture', 'computer_use', 'browser_use', 'automation', 'terminal_takeover'].includes(request.tool)) {
             result = { requestId: request.requestId, ok: false, error: `WSL host tool is not allowed: ${String(request.tool)}` };
         }
         else {

package/dist/core/wslAgentProtocol.d.ts

@@ -1,5 +1,5 @@
 import { AgentMode, AgentWorkEvent, ConversationInputEnvelope, GuideReceipt } from './types';
-import { AgentPromptMessage, ConversationContextCompressOptions, ConversationKernelRunOptions, ConversationKernelRunResult, ConversationQueueMode, ConversationStopResult } from './conversationKernel';
+import { AgentPromptMessage, ConversationContextCompressOptions, ConversationKernelRunOptions, ConversationKernelRunResult, ConversationQueueAction, ConversationQueueActionInput, ConversationQueueMode, ConversationStopResult } from './conversationKernel';
 import { ConversationRuntimeTarget } from './conversationTarget';
 import { TerminalTakeoverEvent, TerminalTakeoverOwnerFilter, TerminalTakeoverState } from '../tools/terminalTakeover';
 import { BrowserUseRequest } from './browserUse';
@@ -42,6 +42,9 @@ interface WslHostToolRequestBase {
 export type WslHostToolRequest = (WslHostToolRequestBase & {
     tool: 'browser_control';
     args: BrowserControlRequest;
+}) | (WslHostToolRequestBase & {
+    tool: 'screen_capture';
+    args: Record<string, unknown>;
 }) | (WslHostToolRequestBase & {
     tool: 'computer_use';
     args: Record<string, unknown>;
@@ -108,6 +111,14 @@ export type WslAgentRequest = {
         target: ConversationRuntimeTarget;
         envelope: ConversationInputEnvelope;
     };
+} | {
+    id: string;
+    method: 'queue_action';
+    params: {
+        target: ConversationRuntimeTarget;
+        action: ConversationQueueAction;
+        input?: ConversationQueueActionInput;
+    };
 } | {
     id: string;
     method: 'checkpoint';

package/dist/core/wslAgentRuntimePool.d.ts

@@ -1,4 +1,5 @@
 import { AgentMode, AgentWorkEvent, ConversationInputEnvelope, GuideReceipt } from './types';
+import { ConversationQueueAction, ConversationQueueActionInput } from './conversationKernel';
 import { ConversationRuntimeTarget, NormalizedConversationTarget } from './conversationTarget';
 import { WslHostToolHandler } from './wslAgentClient';
 import { WslAgentPromptRequest, WslAgentPromptResult, WslAutoRouteRatingResult, WslAgentStopResult, WslConversationRewindResult } from './wslAgentProtocol';
@@ -10,6 +11,7 @@ export interface WslTargetRuntimeClient {
     rewind(target: ConversationRuntimeTarget, messageIndex: number): Promise<WslConversationRewindResult>;
     requestStop(target: ConversationRuntimeTarget, runId?: string): Promise<WslAgentStopResult>;
     enqueueGuide(target: ConversationRuntimeTarget, envelope: ConversationInputEnvelope): Promise<GuideReceipt>;
+    queueAction?(target: ConversationRuntimeTarget, action: ConversationQueueAction, input?: ConversationQueueActionInput): Promise<Record<string, unknown>>;
     checkpoint(target: ConversationRuntimeTarget): Promise<Record<string, unknown>>;
     contextCompress?(target: ConversationRuntimeTarget, options?: {
         keepRecent?: number;
@@ -73,6 +75,7 @@ export declare class WslAgentRuntimePool {
     rewind(target: ConversationRuntimeTarget, messageIndex: number): Promise<WslConversationRewindResult>;
     requestStop(target: ConversationRuntimeTarget, runId?: string): Promise<WslPoolStopResult>;
     enqueueGuide(envelope: ConversationInputEnvelope): Promise<GuideReceipt>;
+    queueAction(target: ConversationRuntimeTarget, action: ConversationQueueAction, input?: ConversationQueueActionInput): Promise<Record<string, unknown>>;
     checkpoint(target: ConversationRuntimeTarget): Promise<Record<string, unknown>>;
     contextCompress(target: ConversationRuntimeTarget, options?: {
         keepRecent?: number;

package/dist/core/wslAgentRuntimePool.js

@@ -195,6 +195,17 @@ class WslAgentRuntimePool {
             this.release(entry, true);
         }
     }
+    async queueAction(target, action, input = {}) {
+        const entry = await this.acquireExisting(target);
+        if (!entry || !entry.client.queueAction)
+            throw new Error('Target conversation is not running');
+        try {
+            return await entry.client.queueAction(entry.target, action, input);
+        }
+        finally {
+            this.release(entry, true);
+        }
+    }
     async checkpoint(target) {
         const normalized = (0, conversationTarget_1.normalizeConversationTarget)(target);
         const entry = await this.acquireExisting(normalized);