newmark-agent 0.3.10 → 0.3.12

package/dist/llm/provider.js

@@ -43,6 +43,19 @@ 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.
+const DEFAULT_PROVIDER_REQUEST_TIMEOUT_MS = 90_000;
+const MIN_PROVIDER_REQUEST_TIMEOUT_MS = 50;
+function providerTimeoutError(timeoutMs) {
+    const error = new Error(`Provider request timed out after ${timeoutMs}ms`);
+    error.name = 'TimeoutError';
+    return error;
+}
+function isProviderTimeoutError(error) {
+    return error instanceof Error && error.name === 'TimeoutError';
+}
 function abortFailure(signal) {
     const reason = signal?.reason;
     const error = reason instanceof Error ? reason : new Error(reason ? String(reason) : 'LLM request aborted');
@@ -84,15 +97,37 @@ class LLMProvider {
     explicitProtocol;
     openAIMode;
     useProviderAdaptersV2;
+    requestTimeoutMs;
     static nodeHttpTransport = null;
     static powershellTransport = null;
-    constructor(name, baseUrl, apiKey, explicitProtocol, openAIMode = 'chat_stream', useProviderAdaptersV2 = false) {
+    constructor(name, baseUrl, apiKey, explicitProtocol, openAIMode = 'chat_stream', useProviderAdaptersV2 = false, requestTimeoutMs = DEFAULT_PROVIDER_REQUEST_TIMEOUT_MS) {
         this.name = name;
         this.baseUrl = baseUrl;
         this.apiKey = apiKey;
         this.explicitProtocol = explicitProtocol;
         this.openAIMode = openAIMode;
         this.useProviderAdaptersV2 = useProviderAdaptersV2;
+        this.requestTimeoutMs = requestTimeoutMs;
+    }
+    effectiveRequestTimeout(timeoutMs) {
+        const requested = Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs : DEFAULT_PROVIDER_REQUEST_TIMEOUT_MS;
+        const configured = Number.isFinite(this.requestTimeoutMs) && this.requestTimeoutMs > 0
+            ? this.requestTimeoutMs
+            : DEFAULT_PROVIDER_REQUEST_TIMEOUT_MS;
+        return Math.max(MIN_PROVIDER_REQUEST_TIMEOUT_MS, Math.min(requested, configured));
+    }
+    async withRequestTimeout(promise, timeoutMs, signal) {
+        let timer;
+        const timeoutPromise = new Promise((_, reject) => {
+            timer = setTimeout(() => reject(providerTimeoutError(timeoutMs)), timeoutMs);
+        });
+        try {
+            return await abortable(Promise.race([promise, timeoutPromise]), signal);
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+        }
     }
     intelligenceConfig(tier) {
         switch (tier) {
@@ -212,6 +247,7 @@ class LLMProvider {
         };
     }
     async postJsonWithFetchFallback(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.
         // Node's HTTP client owns the full body lifecycle and is deterministic for
@@ -224,7 +260,7 @@ class LLMProvider {
                 return '';
             } })();
             this.transportDiagnostic('loopback:start', pathname);
-            const local = await this.nodeHttpJson('POST', url, headers, JSON.stringify(body), signal);
+            const local = await this.nodeHttpJson('POST', url, headers, JSON.stringify(body), signal, effectiveTimeout);
             this.transportDiagnostic('loopback:complete', `status=${local.status} bytes=${Buffer.byteLength(local.body || '')}`);
             return {
                 ok: local.status >= 200 && local.status < 300,
@@ -240,7 +276,7 @@ class LLMProvider {
             forwardAbort();
         else
             signal?.addEventListener('abort', forwardAbort, { once: true });
-        const timer = setTimeout(() => abort.abort(), timeoutMs);
+        const timer = setTimeout(() => abort.abort(providerTimeoutError(effectiveTimeout)), effectiveTimeout);
         try {
             const response = await fetch(url, {
                 method: 'POST',
@@ -253,9 +289,11 @@ class LLMProvider {
         catch (e) {
             if (signal?.aborted)
                 throw abortFailure(signal);
+            if (abort.signal.aborted)
+                throw abortFailure(abort.signal);
             if (!this.shouldUseNodeHttpFallback(e))
                 throw e;
-            const fallback = await this.nodeHttpJson('POST', url, headers, JSON.stringify(body), signal);
+            const fallback = await this.nodeHttpJson('POST', url, headers, JSON.stringify(body), signal, effectiveTimeout);
             return {
                 ok: fallback.status >= 200 && fallback.status < 300,
                 status: fallback.status,
@@ -270,16 +308,19 @@ class LLMProvider {
         }
     }
     async getJsonWithFetchFallback(url, headers, timeoutMs = 30000) {
+        const effectiveTimeout = this.effectiveRequestTimeout(timeoutMs);
         const abort = new AbortController();
-        const timer = setTimeout(() => abort.abort(), timeoutMs);
+        const timer = setTimeout(() => abort.abort(providerTimeoutError(effectiveTimeout)), effectiveTimeout);
         try {
             const response = await fetch(url, { method: 'GET', headers, signal: abort.signal });
             return response;
         }
         catch (e) {
+            if (abort.signal.aborted)
+                throw abortFailure(abort.signal);
             if (!this.shouldUseNodeHttpFallback(e))
                 throw e;
-            const fallback = await this.nodeHttpJson('GET', url, headers);
+            const fallback = await this.nodeHttpJson('GET', url, headers, '', undefined, effectiveTimeout);
             return {
                 ok: fallback.status >= 200 && fallback.status < 300,
                 status: fallback.status,
@@ -293,16 +334,21 @@ class LLMProvider {
         }
     }
     shouldUseNodeHttpFallback(error) {
-        return ((error instanceof TypeError && /fetch failed/i.test(error.message)) ||
-            (error instanceof Error && /abort/i.test(error.name || error.message)));
+        // Abort is a completed control decision (user cancellation or our own
+        // deadline), not evidence that a second transport can succeed. Retrying it
+        // on Windows used to create a second 120s request after the first timeout.
+        return error instanceof TypeError && /fetch failed/i.test(error.message);
     }
-    nodeHttpJson(method, urlValue, headers, body = '', signal) {
+    nodeHttpJson(method, urlValue, headers, body = '', signal, timeoutMs = DEFAULT_PROVIDER_REQUEST_TIMEOUT_MS) {
+        const effectiveTimeout = this.effectiveRequestTimeout(timeoutMs);
         if (LLMProvider.nodeHttpTransport) {
-            return abortable(LLMProvider.nodeHttpTransport(method, urlValue, headers, body), signal).catch(error => {
+            return this.withRequestTimeout(LLMProvider.nodeHttpTransport(method, urlValue, headers, body), effectiveTimeout, signal).catch(error => {
                 if (signal?.aborted)
                     throw abortFailure(signal);
+                if (isProviderTimeoutError(error))
+                    throw error;
                 if (process.platform === 'win32') {
-                    return this.powershellJson(method, urlValue, headers, body, signal);
+                    return this.powershellJson(method, urlValue, headers, body, signal, effectiveTimeout);
                 }
                 throw error;
             });
@@ -350,8 +396,8 @@ class LLMProvider {
                         fail(new Error('Node HTTP response closed before completion'));
                 });
             });
-            req.setTimeout(120000, () => {
-                req.destroy(new Error('Node HTTP fallback timeout'));
+            req.setTimeout(effectiveTimeout, () => {
+                req.destroy(providerTimeoutError(effectiveTimeout));
             });
             req.on('error', reject);
             const onAbort = () => req.destroy(abortFailure(signal));
@@ -366,15 +412,18 @@ class LLMProvider {
         }).catch(error => {
             if (signal?.aborted)
                 throw abortFailure(signal);
+            if (isProviderTimeoutError(error))
+                throw error;
             if (process.platform === 'win32') {
-                return this.powershellJson(method, urlValue, headers, body, signal);
+                return this.powershellJson(method, urlValue, headers, body, signal, effectiveTimeout);
             }
             throw error;
         });
     }
-    powershellJson(method, urlValue, headers, body = '', signal) {
+    powershellJson(method, urlValue, headers, body = '', signal, timeoutMs = DEFAULT_PROVIDER_REQUEST_TIMEOUT_MS) {
+        const effectiveTimeout = this.effectiveRequestTimeout(timeoutMs);
         if (LLMProvider.powershellTransport) {
-            return LLMProvider.powershellTransport(method, urlValue, headers, body);
+            return this.withRequestTimeout(LLMProvider.powershellTransport(method, urlValue, headers, body), effectiveTimeout, signal);
         }
         return new Promise((resolve, reject) => {
             const headerJson = JSON.stringify(headers);
@@ -403,7 +452,7 @@ class LLMProvider {
                 '  $raw = $headerJson | ConvertFrom-Json',
                 '  foreach ($p in $raw.PSObject.Properties) { $headers[$p.Name] = [string]$p.Value }',
                 '}',
-                '$params = @{ Uri = $uri; Method = $method; Headers = $headers; UseBasicParsing = $true; TimeoutSec = 120 }',
+                `'$params = @{ Uri = $uri; Method = $method; Headers = $headers; UseBasicParsing = $true; TimeoutSec = ${Math.max(1, Math.ceil(effectiveTimeout / 1000))} }`,
                 'if ($method -eq "POST") { $params["Body"] = $bodyJson }',
                 'if ($method -eq "POST") { $params["ContentType"] = "application/json; charset=utf-8" }',
                 '$resp = Invoke-WebRequest @params',
@@ -437,8 +486,8 @@ class LLMProvider {
             const timer = setTimeout(() => {
                 child.kill();
                 cleanup();
-                reject(new Error('PowerShell HTTP fallback timeout'));
-            }, 130000);
+                reject(providerTimeoutError(effectiveTimeout));
+            }, effectiveTimeout + 5000);
             child.stdout.setEncoding('utf8');
             child.stderr.setEncoding('utf8');
             child.stdout.on('data', chunk => { stdout += chunk; });
@@ -926,10 +975,10 @@ class LLMProvider {
         return this.shouldUseResponsesFallback(Number(match[1]), errorText);
     }
     /**
-     * Loopback-aware transport injected into adapter `execute`. Mirrors the
-     * legacy orchestration exactly: streaming requests go through fetch with a
-     * 120s timeout and degrade to a non-streaming node-http request on fetch
-     * failure; non-streaming requests reuse postJsonWithFetchFallback.
+     * 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.
      */
     buildProviderAdapterTransport() {
         return async (request, signal) => {
@@ -940,7 +989,8 @@ class LLMProvider {
                     forwardAbort();
                 else
                     signal?.addEventListener('abort', forwardAbort, { once: true });
-                const timer = setTimeout(() => abort.abort(), 120000);
+                const effectiveTimeout = this.effectiveRequestTimeout(120000);
+                const timer = setTimeout(() => abort.abort(providerTimeoutError(effectiveTimeout)), effectiveTimeout);
                 try {
                     try {
                         return await fetch(request.url, {
@@ -953,11 +1003,13 @@ class LLMProvider {
                     catch (error) {
                         if (signal?.aborted)
                             throw abortFailure(signal);
+                        if (abort.signal.aborted)
+                            throw abortFailure(abort.signal);
                         if (!this.shouldUseNodeHttpFallback(error))
                             throw error;
                         const fallbackHeaders = { ...request.headers };
                         delete fallbackHeaders['Accept'];
-                        const fallback = await this.postJsonWithFetchFallback(request.url, fallbackHeaders, { ...request.body, stream: false }, 120000, signal);
+                        const fallback = await this.postJsonWithFetchFallback(request.url, fallbackHeaders, { ...request.body, stream: false }, effectiveTimeout, signal);
                         return this.toTransportResponse(fallback);
                     }
                 }
@@ -1071,7 +1123,8 @@ class LLMProvider {
             forwardAbort();
         else
             signal?.addEventListener('abort', forwardAbort, { once: true });
-        const timeout = setTimeout(() => abort.abort(), 120000);
+        const effectiveTimeout = this.effectiveRequestTimeout(120000);
+        const timeout = setTimeout(() => abort.abort(providerTimeoutError(effectiveTimeout)), effectiveTimeout);
         let reader = null;
         try {
             let response;
@@ -1084,11 +1137,13 @@ class LLMProvider {
                 });
             }
             catch (e) {
+                if (signal?.aborted)
+                    throw abortFailure(signal);
+                if (abort.signal.aborted)
+                    throw abortFailure(abort.signal);
                 if (!this.shouldUseNodeHttpFallback(e))
                     throw e;
                 clearTimeout(timeout);
-                if (signal?.aborted)
-                    throw abortFailure(signal);
                 yield* this.githubModelsChatNonStreaming(url, body, signal);
                 return;
             }
@@ -1108,12 +1163,9 @@ class LLMProvider {
             let currentReasoningContent = '';
             let contentPolicyBlocked = false;
             let emittedContent = false;
+            const streamSignal = signal || new AbortController().signal;
             while (true) {
-                if (signal?.aborted)
-                    throw abortFailure(signal);
-                const readPromise = reader.read();
-                const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error('Stream read timeout')), 30000));
-                const { done, value } = await Promise.race([readPromise, timeoutPromise]);
+                const { done, value } = await (0, providers_1.readProviderStreamChunk)(reader, streamSignal);
                 if (done)
                     break;
                 buffer += decoder.decode(value, { stream: true });