newmark-agent 0.4.8 → 0.5.0

package/dist/core/workEventCoalescer.js

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

package/dist/core/wslAgentClient.d.ts

@@ -1,5 +1,5 @@
 import { AgentMode, AgentWorkEvent, ConversationInputEnvelope, GuideReceipt } from './types';
-import { ConversationQueueAction } from './conversationKernel';
+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';
@@ -72,13 +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?: {
-        id?: string;
-        text?: string;
-        requestedMode?: string;
-        goalObjective?: string;
-        createdAt?: string;
-    }): Promise<Record<string, unknown>>;
+    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/wslAgentProtocol.d.ts

@@ -1,5 +1,5 @@
 import { AgentMode, AgentWorkEvent, ConversationInputEnvelope, GuideReceipt } from './types';
-import { AgentPromptMessage, ConversationContextCompressOptions, ConversationKernelRunOptions, ConversationKernelRunResult, ConversationQueueAction, 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';
@@ -117,13 +117,7 @@ export type WslAgentRequest = {
     params: {
         target: ConversationRuntimeTarget;
         action: ConversationQueueAction;
-        input?: {
-            id?: string;
-            text?: string;
-            requestedMode?: string;
-            goalObjective?: string;
-            createdAt?: string;
-        };
+        input?: ConversationQueueActionInput;
     };
 } | {
     id: string;

package/dist/core/wslAgentRuntimePool.d.ts

@@ -1,5 +1,5 @@
 import { AgentMode, AgentWorkEvent, ConversationInputEnvelope, GuideReceipt } from './types';
-import { ConversationQueueAction } from './conversationKernel';
+import { ConversationQueueAction, ConversationQueueActionInput } from './conversationKernel';
 import { ConversationRuntimeTarget, NormalizedConversationTarget } from './conversationTarget';
 import { WslHostToolHandler } from './wslAgentClient';
 import { WslAgentPromptRequest, WslAgentPromptResult, WslAutoRouteRatingResult, WslAgentStopResult, WslConversationRewindResult } from './wslAgentProtocol';
@@ -11,13 +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?: {
-        id?: string;
-        text?: string;
-        requestedMode?: string;
-        goalObjective?: string;
-        createdAt?: string;
-    }): Promise<Record<string, unknown>>;
+    queueAction?(target: ConversationRuntimeTarget, action: ConversationQueueAction, input?: ConversationQueueActionInput): Promise<Record<string, unknown>>;
     checkpoint(target: ConversationRuntimeTarget): Promise<Record<string, unknown>>;
     contextCompress?(target: ConversationRuntimeTarget, options?: {
         keepRecent?: number;
@@ -81,13 +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?: {
-        id?: string;
-        text?: string;
-        requestedMode?: string;
-        goalObjective?: string;
-        createdAt?: string;
-    }): Promise<Record<string, unknown>>;
+    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/llm/provider.d.ts

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

package/dist/llm/provider.js

@@ -101,6 +101,7 @@ class LLMProvider {
     thinkingTierMaps;
     static nodeHttpTransport = null;
     static powershellTransport = null;
+    temperatureUnsupported = new Set();
     constructor(name, baseUrl, apiKey, explicitProtocol, openAIMode = 'chat_stream', useProviderAdaptersV2 = false, requestTimeoutMs = DEFAULT_PROVIDER_REQUEST_TIMEOUT_MS, 
     /** dev-0.4.3 模型原生思考强度档位映射（模型名 → { 模型原生档位: Newmark 档位 }）。 */
     thinkingTierMaps) {
@@ -286,7 +287,52 @@ class LLMProvider {
             'X-GitHub-Api-Version': '2022-11-28',
         };
     }
+    temperatureCapabilityKey(url, body) {
+        return `${url}|${String(body.model || '')}`;
+    }
+    unsupportedTemperatureError(status, raw) {
+        if (status !== 400)
+            return false;
+        try {
+            const parsed = JSON.parse(String(raw || ''));
+            if (String(parsed?.error?.param || '').toLowerCase() === 'temperature')
+                return true;
+            return /unsupported parameter[^\n]*temperature|temperature[^\n]*not supported/i.test(String(parsed?.error?.message || ''));
+        }
+        catch {
+            return /unsupported parameter[^\n]*temperature|temperature[^\n]*not supported/i.test(String(raw || ''));
+        }
+    }
+    requestBodyForTemperatureCapability(url, body) {
+        const prepared = { ...body };
+        if (this.temperatureUnsupported.has(this.temperatureCapabilityKey(url, body)))
+            delete prepared.temperature;
+        return prepared;
+    }
     async postJsonWithFetchFallback(url, headers, body, timeoutMs = 120000, signal) {
+        const prepared = this.requestBodyForTemperatureCapability(url, body);
+        const response = await this.postJsonOnce(url, headers, prepared, timeoutMs, signal);
+        if (prepared.temperature === undefined || response.status !== 400)
+            return response;
+        const cloneable = typeof response.clone === 'function';
+        const errorText = await (cloneable ? response.clone() : response).text();
+        if (!this.unsupportedTemperatureError(response.status, errorText)) {
+            if (cloneable)
+                return response;
+            return {
+                ok: response.ok,
+                status: response.status,
+                headers: response.headers,
+                text: async () => errorText,
+                json: async () => JSON.parse(errorText || '{}'),
+            };
+        }
+        this.temperatureUnsupported.add(this.temperatureCapabilityKey(url, body));
+        const retryBody = { ...body };
+        delete retryBody.temperature;
+        return this.postJsonOnce(url, headers, retryBody, timeoutMs, signal);
+    }
+    async postJsonOnce(url, headers, body, timeoutMs = 120000, signal) {
         const effectiveTimeout = this.effectiveRequestTimeout(timeoutMs);
         // Electron utility processes can leave an undici response body pending when
         // several isolated workers concurrently call a plain-HTTP local provider.
@@ -1024,6 +1070,7 @@ class LLMProvider {
      */
     buildProviderAdapterTransport() {
         return async (request, signal) => {
+            request.body = this.requestBodyForTemperatureCapability(request.url, request.body);
             if (request.body?.stream === true) {
                 const abort = new AbortController();
                 const forwardAbort = () => abort.abort(signal?.reason);
@@ -1035,12 +1082,27 @@ class LLMProvider {
                 const timer = setTimeout(() => abort.abort(providerTimeoutError(effectiveTimeout)), effectiveTimeout);
                 try {
                     try {
-                        return await fetch(request.url, {
+                        let response = await fetch(request.url, {
                             method: 'POST',
                             headers: request.headers,
                             body: JSON.stringify(request.body),
                             signal: abort.signal,
                         });
+                        if (request.body.temperature !== undefined && response.status === 400) {
+                            const errorText = await response.clone().text();
+                            if (this.unsupportedTemperatureError(response.status, errorText)) {
+                                this.temperatureUnsupported.add(this.temperatureCapabilityKey(request.url, request.body));
+                                const retryBody = { ...request.body };
+                                delete retryBody.temperature;
+                                response = await fetch(request.url, {
+                                    method: 'POST',
+                                    headers: request.headers,
+                                    body: JSON.stringify(retryBody),
+                                    signal: abort.signal,
+                                });
+                            }
+                        }
+                        return response;
                     }
                     catch (error) {
                         if (signal?.aborted)