Fix syntax error in duckai.ts and consolidate all patches

src/duckai.ts

@@ -14,29 +14,14 @@ export class DuckAI {
         resources: "usable"
       });
 
-      const window = dom.window as any;
-
-      // ГЛУБОКАЯ ЭМУЛЯЦИЯ
-      Object.defineProperties(window.navigator, {
-        userAgent: { value: ua },
-        platform: { value: 'Win32' },
-        webdriver: { value: false },
-        languages: { value: ['en-US', 'en'] }
-      });
-
-      window.screen = { width: 1920, height: 1080, availWidth: 1920, availHeight: 1080 };
-      window.chrome = { runtime: {} };
-      
-      // Fix for 'Cannot read properties of null (reading 'contentDocument')'
-      // Immortal DOM + Environment Mocks
       const mockWindow = dom.window as any;
-      
+
       // Self-reference fixes
       mockWindow.self = mockWindow;
       mockWindow.parent = mockWindow;
       mockWindow.top = mockWindow;
-      
-      // Immortal DOM Strategy
+
+      // IMMORTAL DOM Strategy
       const originalGetElementById = mockWindow.document.getElementById;
       mockWindow.document.getElementById = function(id: string) {
           const el = originalGetElementById.call(this, id);
@@ -53,6 +38,17 @@ export class DuckAI {
           return mockWindow.document.createElement('div');
       };
 
+      // ГЛУБОКАЯ ЭМУЛЯЦИЯ
+      Object.defineProperties(mockWindow.navigator, {
+        userAgent: { value: ua },
+        platform: { value: 'Win32' },
+        webdriver: { value: false },
+        languages: { value: ['en-US', 'en'] }
+      });
+
+      mockWindow.screen = { width: 1920, height: 1080, availWidth: 1920, availHeight: 1080 };
+      mockWindow.chrome = { runtime: {} };
+      
       // Aggressive Patch for iframe contentDocument
       Object.defineProperty(mockWindow.HTMLIFrameElement.prototype, 'contentDocument', {
         get: function() { return mockWindow.document; },
@@ -64,34 +60,100 @@ export class DuckAI {
         configurable: true
       });
 
-      dom.window.top.__DDG_BE_VERSION__ = 1;
-      dom.window.top.__DDG_FE_CHAT_HASH__ = 1;
-      
-      const result = await dom.window.eval(jsScript) as any;
+      // Also keep the createElement hook just in case
+      const originalCreateElement = mockWindow.document.createElement;
+      mockWindow.document.createElement = function(tagName: string) {
+          const element = originalCreateElement.call(this, tagName);
+          if (tagName.toLowerCase() === 'iframe') {
+              try {
+                  Object.defineProperty(element, 'contentDocument', {
+                      get: () => mockWindow.document,
+                      configurable: true
+                  });
+                  Object.defineProperty(element, 'contentWindow', {
+                      get: () => mockWindow,
+                      configurable: true
+                  });
+              } catch (e) {}
+          }
+          return element;
+      };
       
-      if (!result || !result.client_hashes) {
-        throw new Error("Invalid Challenge Response");
-      }
+      // Robust Canvas Mock
+      const originalGetContext = mockWindow.HTMLCanvasElement.prototype.getContext;
+      mockWindow.HTMLCanvasElement.prototype.getContext = function (type: string, options?: any) {
+        try {
+           const ctx = originalGetContext.call(this, type, options);
+           if (ctx) return ctx;
+        } catch (e) {}
 
-      result.client_hashes[0] = ua;
-      result.client_hashes = result.client_hashes.map((t: string) => {
-        const hash = createHash('sha256');
-        hash.update(t);
-        return hash.digest('base64');
-      });
-      
-      return btoa(JSON.stringify(result));
-    } catch (e: any) {
-      console.error(`[DuckAI] Challenge Solver Failed: ${e.message}`);
-      // Fallback: Return the original hash (sometimes works if challenge is optional or server is lenient)
-      // or return a dummy base64 json.
-      console.log("[DuckAI] Attempting fallback with original VQD...");
-      return vqdHash; // Try returning the VQD itself as a fallback
-    }
-  }
-      dom.window.top.__DDG_FE_CHAT_HASH__ = 1;
+        return {
+          canvas: this,
+          fillRect: () => {},
+          clearRect: () => {},
+          getImageData: (x: number, y: number, w: number, h: number) => ({ 
+             data: new Uint8ClampedArray(w * h * 4), 
+             width: w, 
+             height: h 
+          }),
+          putImageData: () => {},
+          createImageData: () => ({ data: new Uint8ClampedArray(4) }),
+          setTransform: () => {},
+          drawImage: () => {},
+          save: () => {},
+          restore: () => {},
+          beginPath: () => {},
+          moveTo: () => {},
+          lineTo: () => {},
+          closePath: () => {},
+          stroke: () => {},
+          translate: () => {},
+          scale: () => {},
+          rotate: () => {},
+          arc: () => {},
+          fill: () => {},
+          measureText: () => ({ width: 0, actualBoundingBoxAscent: 0, actualBoundingBoxDescent: 0 }),
+          transform: () => {},
+          rect: () => {},
+          clip: () => {},
+          createLinearGradient: () => ({ addColorStop: () => {} }),
+          createRadialGradient: () => ({ addColorStop: () => {} }),
+          createPattern: () => ({}),
+          bezierCurveTo: () => {},
+          quadraticCurveTo: () => {},
+          fillText: () => {},
+          strokeText: () => {},
+          globalAlpha: 1,
+          globalCompositeOperation: 'source-over',
+          fillStyle: '#000000',
+          strokeStyle: '#000000',
+          lineWidth: 1,
+          lineCap: 'butt',
+          lineJoin: 'miter',
+          miterLimit: 10,
+          shadowOffsetX: 0,
+          shadowOffsetY: 0,
+          shadowBlur: 0,
+          shadowColor: 'rgba(0, 0, 0, 0)',
+          font: '10px sans-serif',
+          textAlign: 'start',
+          textBaseline: 'alphabetic'
+        };
+      } as any;
+
+      const originalToDataURL = mockWindow.HTMLCanvasElement.prototype.toDataURL;
+      mockWindow.HTMLCanvasElement.prototype.toDataURL = function(type?: string, quality?: any) {
+           try {
+               const result = originalToDataURL.call(this, type, quality);
+               if (result && result !== "data:,") return result;
+           } catch(e) {}
+           return "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==";
+      };
+
+      mockWindow.top.__DDG_BE_VERSION__ = 1;
+      mockWindow.top.__DDG_FE_CHAT_HASH__ = 1;
       
-      const result = await dom.window.eval(jsScript) as any;
+      const result = await mockWindow.eval(jsScript) as any;
       
       if (!result || !result.client_hashes) {
         throw new Error("Invalid Challenge Response");
@@ -106,16 +168,17 @@ export class DuckAI {
       
       return btoa(JSON.stringify(result));
     } catch (e: any) {
-      throw new Error(`Challenge Solver Error: ${e.message}`);
+      console.error(`[DuckAI] Challenge Solver Failed: ${e.message}`);
+      console.log("[DuckAI] Attempting fallback with original VQD...");
+      return vqdHash;
     }
   }
 
   getAvailableModels(): string[] {
     return [
       "gpt-4o-mini",
-      "claude-3-haiku-20240307",
-      "meta-llama/Llama-3.3-70B-Instruct-Turbo",
-      "mistralai/Mistral-Small-24B-Instruct-2501"
+      "gpt-5-mini",
+      "openai/gpt-oss-120b"
     ];
   }
 
@@ -142,7 +205,7 @@ export class DuckAI {
 
     console.log("[DuckAI] Solving challenge...");
     const solvedVqd = await this.solveChallenge(hashHeader, ua);
-    console.log("[DuckAI] Challenge solved.");
+    console.log("[DuckAI] Challenge solved (or fallback used).");
 
     const response = await fetch("https://duckduckgo.com/duckchat/v1/chat", {
       method: "POST",
@@ -159,7 +222,6 @@ export class DuckAI {
     }
 
     const text = await response.text();
-    // console.log(`[DuckAI] Raw response: ${text.substring(0, 200)}...`); // Uncomment for ultra verbose
     
     let llmResponse = "";
     const lines = text.split("\n");
@@ -181,4 +243,4 @@ export class DuckAI {
     
     return llmResponse.trim();
   }
-}
+}