From 16b16c0654de8ff61c384d3d3dea4d8656135695 Mon Sep 17 00:00:00 2001
From: Duc-python <Duc-python@users.noreply.github.com>
Date: Sun, 11 Oct 2026 14:00:04 +0700
Subject: [PATCH 1/2] Add per-block proxy bypass and proxy variables to Http
 Request block

Http Request blocks now expose a `useProxy` parameter (default `true`). When
disabled, that single request is sent directly even if the job has proxies
enabled, which was previously only possible by toggling the proxy at job level
and restarting it.

The check lives in a new `HttpRequestHandler.ResolveProxy` helper so all three
HTTP libraries (RuriLibHttp, SystemNet, CurlImpersonate) honour it through a
single choke point. When a block bypasses its proxy, a `[NO PROXY]` line is
logged so the reason is visible in the bot log.

ScriptGlobals now also exposes the bot proxy as `input.proxy.*` (ip, host, port,
username, password, type, country, ping, inUse) so configs can read proxy fields
without falling back to `data.Proxy`. Every field is always present, defaulting
to empty, so configs do not need null checks. `inUse` reflects whether requests
actually go through the proxy, which distinguishes "the bot has a proxy" from
"this block is using it".

Both additions are backwards compatible: `useProxy` defaults to the previous
behaviour and is omitted from LoliCode when unchanged, and a wordlist slice
literally named `proxy` keeps precedence over the new object.

Also assigns `decodeHtmlSetting` in the native HttpRequestBlockSettingsViewer,
which was declared in XAML but never bound, leaving the setting inert there.
---
 .../HttpRequestBlockSettingsViewer.xaml       |  1 +
 .../HttpRequestBlockSettingsViewer.xaml.cs    |  2 +
 OpenBullet2.Native/Utils/Suggestions.cs       |  3 +
 .../Custom/HttpRequestBlockInstanceTests.cs   | 37 +++++++
 .../Models/Bots/ScriptGlobalsTests.cs         | 98 ++++++++++++++++++-
 .../Http/HttpClientRequestHandler.cs          |  8 +-
 RuriLib/Functions/Http/HttpRequestHandler.cs  | 21 ++++
 .../Http/Options/HttpRequestOptions.cs        |  6 ++
 .../Http/RLHttpClientRequestHandler.cs        |  8 +-
 .../Custom/HttpRequestBlockDescriptor.cs      |  4 +
 .../Blocks/Custom/HttpRequestBlockInstance.cs |  3 +-
 RuriLib/Models/Bots/ScriptGlobals.cs          | 37 +++++++
 .../config-stacker.component.ts               |  3 +
 .../http-request-block.component.html         | 11 +++
 14 files changed, 231 insertions(+), 11 deletions(-)

diff --git a/OpenBullet2.Native/Controls/HttpRequestBlockSettingsViewer.xaml b/OpenBullet2.Native/Controls/HttpRequestBlockSettingsViewer.xaml
index fd025edd2..6839d53b7 100644
--- a/OpenBullet2.Native/Controls/HttpRequestBlockSettingsViewer.xaml
+++ b/OpenBullet2.Native/Controls/HttpRequestBlockSettingsViewer.xaml
@@ -191,6 +191,7 @@
         <local:BoolSettingViewer x:Name="readResponseContentSetting" />
         <local:BoolSettingViewer x:Name="decodeHtmlSetting" />
         <local:StringSettingViewer x:Name="codePagesEncodingSetting" />
+        <local:BoolSettingViewer x:Name="useProxySetting" />
 
         <Label 
             Content="Advanced settings:"
diff --git a/OpenBullet2.Native/Controls/HttpRequestBlockSettingsViewer.xaml.cs b/OpenBullet2.Native/Controls/HttpRequestBlockSettingsViewer.xaml.cs
index 08cebac13..e50df46c3 100644
--- a/OpenBullet2.Native/Controls/HttpRequestBlockSettingsViewer.xaml.cs
+++ b/OpenBullet2.Native/Controls/HttpRequestBlockSettingsViewer.xaml.cs
@@ -84,7 +84,9 @@ private void BindSettings()
         maxNumberOfRedirectsSetting.Setting = vm.HttpRequestBlock.Settings["maxNumberOfRedirects"];
         absoluteUriInFirstLineSetting.Setting = vm.HttpRequestBlock.Settings["absoluteUriInFirstLine"];
         readResponseContentSetting.Setting = vm.HttpRequestBlock.Settings["readResponseContent"];
+        decodeHtmlSetting.Setting = vm.HttpRequestBlock.Settings["decodeHtml"];
         codePagesEncodingSetting.Setting = vm.HttpRequestBlock.Settings["codePagesEncoding"];
+        useProxySetting.Setting = vm.HttpRequestBlock.Settings["useProxy"];
         httpLibrarySetting.Setting = vm.HttpRequestBlock.Settings["httpLibrary"];
         curlImpersonateBrowserProfileSetting.Setting = vm.HttpRequestBlock.Settings["curlImpersonateBrowserProfile"];
         curlUseBrowserHeadersSetting.Setting = vm.HttpRequestBlock.Settings["curlUseBrowserHeaders"];
diff --git a/OpenBullet2.Native/Utils/Suggestions.cs b/OpenBullet2.Native/Utils/Suggestions.cs
index 6cf1a81cf..6cc999c24 100644
--- a/OpenBullet2.Native/Utils/Suggestions.cs
+++ b/OpenBullet2.Native/Utils/Suggestions.cs
@@ -35,6 +35,9 @@ public static IEnumerable<string> GetInputVariableSuggestions(BlockSetting setti
         }
 
         var suggestions = new List<string> {
+        "input.proxy.ip", "input.proxy.host", "input.proxy.port",
+        "input.proxy.username", "input.proxy.password", "input.proxy.type",
+        "input.proxy.country", "input.proxy.ping", "input.proxy.inUse",
         "data.SOURCE", "data.ERROR", "data.ADDRESS",
         "data.HEADERS[\"name\"]", "data.COOKIES[\"name\"]",
         "data.STATUS", "data.RESPONSECODE", "data.RAWSOURCE", "data.Line.Data" };
diff --git a/RuriLib.Tests/Models/Blocks/Custom/HttpRequestBlockInstanceTests.cs b/RuriLib.Tests/Models/Blocks/Custom/HttpRequestBlockInstanceTests.cs
index 36ac67da9..4cef1f8d7 100644
--- a/RuriLib.Tests/Models/Blocks/Custom/HttpRequestBlockInstanceTests.cs
+++ b/RuriLib.Tests/Models/Blocks/Custom/HttpRequestBlockInstanceTests.cs
@@ -196,6 +196,43 @@ public void MultipartSettingsGroups_DefaultContentTypes_ArePreserved()
         Assert.IsType<ByteArraySetting>(rawContent.Data.FixedSetting);
     }
 
+    [Fact]
+    public void ToSyntax_UseProxy_IsEmittedAndDefaultsToTrue()
+    {
+        var block = CreateStandardRequestBlock();
+
+        Assert.True(Assert.IsType<BoolSetting>(block.Settings["useProxy"].FixedSetting).Value);
+        Assert.Contains("UseProxy = true", RenderSyntax(block));
+
+        (block.Settings["useProxy"].FixedSetting as BoolSetting)!.Value = false;
+
+        Assert.Contains("UseProxy = false", RenderSyntax(block));
+    }
+
+    [Fact]
+    public void ToLC_UseProxy_IsOmittedWhenDefaultAndWrittenWhenChanged()
+    {
+        var block = BlockFactory.GetBlock<HttpRequestBlockInstance>("HttpRequest");
+
+        Assert.DoesNotContain("useProxy =", block.ToLC());
+
+        (block.Settings["useProxy"].FixedSetting as BoolSetting)!.Value = false;
+
+        Assert.Contains($"  useProxy = False{_nl}", block.ToLC());
+    }
+
+    [Fact]
+    public void FromLC_UseProxy_RoundTrips()
+    {
+        var block = BlockFactory.GetBlock<HttpRequestBlockInstance>("HttpRequest");
+        var script = $"  useProxy = false{_nl}";
+        var lineNumber = 0;
+
+        block.FromLC(ref script, ref lineNumber);
+
+        Assert.False(Assert.IsType<BoolSetting>(block.Settings["useProxy"].FixedSetting).Value);
+    }
+
     private static HttpRequestBlockInstance CreateStandardRequestBlock(bool safe = false)
     {
         var block = CreateBaseBlock(safe);
diff --git a/RuriLib.Tests/Models/Bots/ScriptGlobalsTests.cs b/RuriLib.Tests/Models/Bots/ScriptGlobalsTests.cs
index 3170ec218..2c00b8743 100644
--- a/RuriLib.Tests/Models/Bots/ScriptGlobalsTests.cs
+++ b/RuriLib.Tests/Models/Bots/ScriptGlobalsTests.cs
@@ -5,6 +5,7 @@
 using RuriLib.Models.Configs;
 using RuriLib.Models.Data;
 using RuriLib.Models.Environment;
+using RuriLib.Models.Proxies;
 using RuriLib.Tests.Utils.Mockup;
 using Xunit;
 
@@ -57,7 +58,98 @@ public void Constructor_UrlEncodesSlices_WhenConfigured()
         Assert.Equal("hello%20world", input["value"]);
     }
 
-    private static BotData NewBotData(DataLine line)
+    [Fact]
+    public void Constructor_PopulatesProxyVariables()
+    {
+        dynamic globals = new ExpandoObject();
+        var proxy = new Proxy("1.2.3.4", 8080, ProxyType.Socks5, "user", "pass")
+        {
+            Country = "Italy",
+            Ping = 120
+        };
+        var botData = NewBotData(NewLine(), proxy, useProxy: true);
+
+        var proxyFields = GetProxyFields(new ScriptGlobals(botData, globals));
+
+        Assert.Equal("1.2.3.4", proxyFields["ip"]);
+        Assert.Equal("1.2.3.4", proxyFields["host"]);
+        Assert.Equal(8080, proxyFields["port"]);
+        Assert.Equal("user", proxyFields["username"]);
+        Assert.Equal("pass", proxyFields["password"]);
+        Assert.Equal("socks5", proxyFields["type"]);
+        Assert.Equal("Italy", proxyFields["country"]);
+        Assert.Equal(120, proxyFields["ping"]);
+        Assert.Equal(true, proxyFields["inUse"]);
+    }
+
+    [Fact]
+    public void Constructor_ProxyVariables_AreEmpty_WhenNoProxyAssigned()
+    {
+        dynamic globals = new ExpandoObject();
+
+        var proxyFields = GetProxyFields(new ScriptGlobals(NewBotData(NewLine()), globals));
+
+        Assert.Equal(string.Empty, proxyFields["ip"]);
+        Assert.Equal(string.Empty, proxyFields["host"]);
+        Assert.Equal(0, proxyFields["port"]);
+        Assert.Equal(string.Empty, proxyFields["username"]);
+        Assert.Equal(string.Empty, proxyFields["password"]);
+        Assert.Equal(string.Empty, proxyFields["type"]);
+        Assert.Equal(string.Empty, proxyFields["country"]);
+        Assert.Equal(0, proxyFields["ping"]);
+        Assert.Equal(false, proxyFields["inUse"]);
+    }
+
+    [Fact]
+    public void Constructor_ProxyVariables_AreExposedButNotInUse_WhenJobHasProxiesDisabled()
+    {
+        dynamic globals = new ExpandoObject();
+        var proxy = new Proxy("1.2.3.4", 8080);
+        var botData = NewBotData(NewLine(), proxy, useProxy: false);
+
+        var proxyFields = GetProxyFields(new ScriptGlobals(botData, globals));
+
+        // The fields stay readable so configs can log them, but the request goes out directly
+        Assert.Equal("1.2.3.4", proxyFields["ip"]);
+        Assert.Equal(false, proxyFields["inUse"]);
+    }
+
+    [Fact]
+    public void Constructor_SliceNamedProxy_TakesPrecedence()
+    {
+        dynamic globals = new ExpandoObject();
+        var botData = NewBotData(
+            new DataLine("fromWordlist", new WordlistType
+            {
+                Separator = string.Empty,
+                Slices = ["proxy"]
+            }),
+            new Proxy("1.2.3.4", 8080),
+            useProxy: true);
+
+        var input = (IDictionary<string, object?>)new ScriptGlobals(botData, globals).input;
+
+        // Existing configs slicing into "proxy" must keep working unchanged
+        Assert.IsType<string>(input["proxy"]);
+        Assert.Equal("fromWordlist", input["proxy"]);
+    }
+
+    private static DataLine NewLine()
+        => new("hello:world", new WordlistType
+        {
+            Separator = ":",
+            Slices = ["left", "right"]
+        });
+
+    private static IDictionary<string, object?> GetProxyFields(ScriptGlobals scriptGlobals)
+    {
+        var input = (IDictionary<string, object?>)scriptGlobals.input;
+        Assert.True(input.ContainsKey("proxy"));
+
+        return Assert.IsAssignableFrom<IDictionary<string, object?>>(input["proxy"]);
+    }
+
+    private static BotData NewBotData(DataLine line, Proxy? proxy = null, bool useProxy = false)
         => new(
             new global::RuriLib.Models.Bots.Providers(null!)
             {
@@ -66,5 +158,7 @@ private static BotData NewBotData(DataLine line)
             },
             new ConfigSettings(),
             new BotLogger(),
-            line);
+            line,
+            proxy,
+            useProxy);
 }
diff --git a/RuriLib/Functions/Http/HttpClientRequestHandler.cs b/RuriLib/Functions/Http/HttpClientRequestHandler.cs
index a9f861b1b..afbb52917 100644
--- a/RuriLib/Functions/Http/HttpClientRequestHandler.cs
+++ b/RuriLib/Functions/Http/HttpClientRequestHandler.cs
@@ -54,7 +54,7 @@ public override async Task HttpRequestStandard(BotData data, StandardHttpRequest
             data,
             options,
             capturedRequestHeaders is null ? null : capturedRequestHeaders.Add);
-        using var client = clientFactory(data.UseProxy ? data.Proxy : null, clientOptions, cookieContainer);
+        using var client = clientFactory(ResolveProxy(data, options), clientOptions, cookieContainer);
 
         var requestVersion = Version.Parse(options.HttpVersion);
         using var request = new HttpRequestMessage
@@ -125,7 +125,7 @@ public override async Task HttpRequestRaw(BotData data, RawHttpRequestOptions op
             data,
             options,
             capturedRequestHeaders is null ? null : capturedRequestHeaders.Add);
-        using var client = clientFactory(data.UseProxy ? data.Proxy : null, clientOptions, cookieContainer);
+        using var client = clientFactory(ResolveProxy(data, options), clientOptions, cookieContainer);
 
         var requestVersion = Version.Parse(options.HttpVersion);
         using var request = new HttpRequestMessage
@@ -183,7 +183,7 @@ public override async Task HttpRequestBasicAuth(BotData data, BasicAuthHttpReque
             data,
             options,
             capturedRequestHeaders is null ? null : capturedRequestHeaders.Add);
-        using var client = clientFactory(data.UseProxy ? data.Proxy : null, clientOptions, cookieContainer);
+        using var client = clientFactory(ResolveProxy(data, options), clientOptions, cookieContainer);
 
         var requestVersion = Version.Parse(options.HttpVersion);
         using var request = new HttpRequestMessage
@@ -241,7 +241,7 @@ public override async Task HttpRequestMultipart(BotData data, MultipartHttpReque
             data,
             options,
             capturedRequestHeaders is null ? null : capturedRequestHeaders.Add);
-        using var client = clientFactory(data.UseProxy ? data.Proxy : null, clientOptions, cookieContainer);
+        using var client = clientFactory(ResolveProxy(data, options), clientOptions, cookieContainer);
 
         if (string.IsNullOrWhiteSpace(options.Boundary))
         {
diff --git a/RuriLib/Functions/Http/HttpRequestHandler.cs b/RuriLib/Functions/Http/HttpRequestHandler.cs
index f5ee11d6b..ebf7f02c7 100644
--- a/RuriLib/Functions/Http/HttpRequestHandler.cs
+++ b/RuriLib/Functions/Http/HttpRequestHandler.cs
@@ -1,6 +1,7 @@
 using RuriLib.Functions.Http.Options;
 using RuriLib.Models.Blocks.Custom.HttpRequest.Multipart;
 using RuriLib.Models.Bots;
+using RuriLib.Models.Proxies;
 using System;
 using System.Collections.Generic;
 using System.IO;
@@ -186,6 +187,26 @@ protected static HttpOptions GetClientOptions(BotData data, Options.HttpRequestO
             CurlRequestHeadersCallback = curlRequestHeadersCallback
         };
 
+    /// <summary>
+    /// Resolves the proxy to use for a single request.
+    /// The bot's proxy is only used when the job has proxies enabled
+    /// (<see cref="BotData.UseProxy"/>) and the block didn't opt out through
+    /// <see cref="Options.HttpRequestOptions.UseProxy"/>.
+    /// </summary>
+    /// <param name="data">The bot data holding the proxy assigned to this bot.</param>
+    /// <param name="options">The options of the block performing the request.</param>
+    /// <returns>The proxy to route through, or null to send the request directly.</returns>
+    protected static Proxy? ResolveProxy(BotData data, Options.HttpRequestOptions options)
+    {
+        if (data.Proxy is not null && !options.UseProxy)
+        {
+            data.Logger.Log("[NO PROXY] This block is configured to bypass the bot proxy", LogColors.DarkOrange);
+            return null;
+        }
+
+        return data.UseProxy ? data.Proxy : null;
+    }
+
     protected static void LogNegotiatedHttpVersion(BotData data, Version requestedVersion, Version responseVersion)
     {
         var requested = FormatHttpVersion(requestedVersion);
diff --git a/RuriLib/Functions/Http/Options/HttpRequestOptions.cs b/RuriLib/Functions/Http/Options/HttpRequestOptions.cs
index c8c347418..b46b8bca8 100644
--- a/RuriLib/Functions/Http/Options/HttpRequestOptions.cs
+++ b/RuriLib/Functions/Http/Options/HttpRequestOptions.cs
@@ -110,6 +110,12 @@ public class HttpRequestOptions
     /// headers when <see cref="HttpLibrary"/> is <see cref="HttpLibrary.CurlImpersonate"/>.
     /// </summary>
     public bool CurlUseBrowserHeaders { get; set; } = true;
+
+    /// <summary>
+    /// Gets or sets whether the proxy assigned to the bot is used for this request.
+    /// When false, the request is always sent directly, even if the job has proxies enabled.
+    /// </summary>
+    public bool UseProxy { get; set; } = true;
 }
 
 /// <summary>
diff --git a/RuriLib/Functions/Http/RLHttpClientRequestHandler.cs b/RuriLib/Functions/Http/RLHttpClientRequestHandler.cs
index a5344e1a3..6520301b2 100644
--- a/RuriLib/Functions/Http/RLHttpClientRequestHandler.cs
+++ b/RuriLib/Functions/Http/RLHttpClientRequestHandler.cs
@@ -26,7 +26,7 @@ internal class RLHttpClientRequestHandler : HttpRequestHandler
     public override async Task HttpRequestStandard(BotData data, StandardHttpRequestOptions options)
     {
         var clientOptions = GetClientOptions(data, options);
-        using var client = HttpFactory.GetRLHttpClient(data.UseProxy ? data.Proxy : null, clientOptions);
+        using var client = HttpFactory.GetRLHttpClient(ResolveProxy(data, options), clientOptions);
 
         foreach (var cookie in options.CustomCookies)
         {
@@ -80,7 +80,7 @@ public override async Task HttpRequestStandard(BotData data, StandardHttpRequest
     public override async Task HttpRequestRaw(BotData data, RawHttpRequestOptions options)
     {
         var clientOptions = GetClientOptions(data, options);
-        using var client = HttpFactory.GetRLHttpClient(data.UseProxy ? data.Proxy : null, clientOptions);
+        using var client = HttpFactory.GetRLHttpClient(ResolveProxy(data, options), clientOptions);
 
         foreach (var cookie in options.CustomCookies)
         {
@@ -122,7 +122,7 @@ public override async Task HttpRequestRaw(BotData data, RawHttpRequestOptions op
     public override async Task HttpRequestBasicAuth(BotData data, BasicAuthHttpRequestOptions options)
     {
         var clientOptions = GetClientOptions(data, options);
-        using var client = HttpFactory.GetRLHttpClient(data.UseProxy ? data.Proxy : null, clientOptions);
+        using var client = HttpFactory.GetRLHttpClient(ResolveProxy(data, options), clientOptions);
 
         foreach (var cookie in options.CustomCookies)
         {
@@ -165,7 +165,7 @@ public override async Task HttpRequestBasicAuth(BotData data, BasicAuthHttpReque
     public override async Task HttpRequestMultipart(BotData data, MultipartHttpRequestOptions options)
     {
         var clientOptions = GetClientOptions(data, options);
-        using var client = HttpFactory.GetRLHttpClient(data.UseProxy ? data.Proxy : null, clientOptions);
+        using var client = HttpFactory.GetRLHttpClient(ResolveProxy(data, options), clientOptions);
 
         foreach (var cookie in options.CustomCookies)
         {
diff --git a/RuriLib/Models/Blocks/Custom/HttpRequestBlockDescriptor.cs b/RuriLib/Models/Blocks/Custom/HttpRequestBlockDescriptor.cs
index f80887c11..f802a7edb 100644
--- a/RuriLib/Models/Blocks/Custom/HttpRequestBlockDescriptor.cs
+++ b/RuriLib/Models/Blocks/Custom/HttpRequestBlockDescriptor.cs
@@ -120,6 +120,10 @@ public HttpRequestBlockDescriptor()
             ["httpVersion"] = new StringParameter("httpVersion", "1.1")
             {
                 Description = "HTTP version string such as 1.1, 2.0, or 3.0, depending on the selected HTTP library and platform support."
+            },
+            ["useProxy"] = new BoolParameter("useProxy", true)
+            {
+                Description = "If true, the request goes through the proxy assigned to the bot (when the job has proxies enabled). If false, this request is always sent directly, bypassing the proxy."
             }
         };
     }
diff --git a/RuriLib/Models/Blocks/Custom/HttpRequestBlockInstance.cs b/RuriLib/Models/Blocks/Custom/HttpRequestBlockInstance.cs
index 1790d64fc..45f63e61f 100644
--- a/RuriLib/Models/Blocks/Custom/HttpRequestBlockInstance.cs
+++ b/RuriLib/Models/Blocks/Custom/HttpRequestBlockInstance.cs
@@ -439,7 +439,8 @@ private ExpressionSyntax BuildHttpRequestInvocationExpression()
             Prop("AlwaysSendContent", CSharpWriter.FromSettingSyntax(Settings["alwaysSendContent"])),
             Prop("DecodeHtml", CSharpWriter.FromSettingSyntax(Settings["decodeHtml"])),
             Prop("UseCustomCipherSuites", CSharpWriter.FromSettingSyntax(Settings["useCustomCipherSuites"])),
-            Prop("CustomCipherSuites", CSharpWriter.FromSettingSyntax(Settings["customCipherSuites"]))
+            Prop("CustomCipherSuites", CSharpWriter.FromSettingSyntax(Settings["customCipherSuites"])),
+            Prop("UseProxy", CSharpWriter.FromSettingSyntax(Settings["useProxy"]))
         ]);
 
         var optionsObject = New(optionsTypeName).InitObject(requestAssignments.ToArray());
diff --git a/RuriLib/Models/Bots/ScriptGlobals.cs b/RuriLib/Models/Bots/ScriptGlobals.cs
index f9315f514..3a85e02a9 100644
--- a/RuriLib/Models/Bots/ScriptGlobals.cs
+++ b/RuriLib/Models/Bots/ScriptGlobals.cs
@@ -44,5 +44,42 @@ public ScriptGlobals(BotData data, dynamic globals)
                     ? Uri.EscapeDataString(variable.AsString())
                     : variable.AsString());
         }
+
+        var inputFields = (IDictionary<string, object?>)input;
+
+        // Expose the proxy assigned to this bot as input.proxy.* so that configs can
+        // read its fields without having to fall back to data.Proxy. A wordlist slice
+        // named "proxy" takes precedence so existing configs keep working.
+        if (!inputFields.ContainsKey("proxy"))
+        {
+            inputFields.Add("proxy", CreateProxyVariables(data));
+        }
+    }
+
+    /// <summary>
+    /// Builds the <c>input.proxy</c> object. Every field is always present, defaulting
+    /// to an empty value when the bot has no proxy assigned, so that configs never have
+    /// to null-check before interpolating them.
+    /// </summary>
+    /// <param name="data">The bot data holding the proxy assigned to this bot.</param>
+    /// <returns>An expando object with the fields of the proxy.</returns>
+    private static ExpandoObject CreateProxyVariables(BotData data)
+    {
+        var proxy = data.Proxy;
+
+        var variables = new ExpandoObject();
+        var fields = (IDictionary<string, object?>)variables;
+
+        fields["ip"] = proxy?.Host ?? string.Empty;
+        fields["host"] = proxy?.Host ?? string.Empty;
+        fields["port"] = proxy?.Port ?? 0;
+        fields["username"] = proxy?.Username ?? string.Empty;
+        fields["password"] = proxy?.Password ?? string.Empty;
+        fields["type"] = proxy?.Type.ToString().ToLowerInvariant() ?? string.Empty;
+        fields["country"] = proxy?.Country ?? string.Empty;
+        fields["ping"] = proxy?.Ping ?? 0;
+        fields["inUse"] = data.UseProxy && proxy is not null;
+
+        return variables;
     }
 }
diff --git a/openbullet2-web-client/src/app/main/components/config/config-stacker/config-stacker.component.ts b/openbullet2-web-client/src/app/main/components/config/config-stacker/config-stacker.component.ts
index 2295cd99c..b7f8e6b7d 100644
--- a/openbullet2-web-client/src/app/main/components/config/config-stacker/config-stacker.component.ts
+++ b/openbullet2-web-client/src/app/main/components/config/config-stacker/config-stacker.component.ts
@@ -401,6 +401,9 @@ export class ConfigStackerComponent implements OnInit {
 
   public getSuggestions(): string[] {
     const suggestions = [
+      'input.proxy.ip', 'input.proxy.host', 'input.proxy.port',
+      'input.proxy.username', 'input.proxy.password', 'input.proxy.type',
+      'input.proxy.country', 'input.proxy.ping', 'input.proxy.inUse',
       'data.SOURCE', 'data.ERROR', 'data.ADDRESS',
       'data.HEADERS["name"]', 'data.COOKIES["name"]',
       'data.STATUS', 'data.RESPONSECODE', 'data.RAWSOURCE', 'data.Line.Data'
diff --git a/openbullet2-web-client/src/app/main/components/config/config-stacker/http-request-block/http-request-block.component.html b/openbullet2-web-client/src/app/main/components/config/config-stacker/http-request-block/http-request-block.component.html
index b9b58e9b5..49c53fab4 100644
--- a/openbullet2-web-client/src/app/main/components/config/config-stacker/http-request-block/http-request-block.component.html
+++ b/openbullet2-web-client/src/app/main/components/config/config-stacker/http-request-block/http-request-block.component.html
@@ -441,6 +441,17 @@
         </div>
     </div>
 </div>
+<div class="row mt-2">
+    <div class="col-12 px-0">
+        <div class="mb-1">
+            <app-bool-setting
+                [parameter]="descriptor.parameters['useProxy']"
+                [setting]="block.settings['useProxy']"
+                [stacker]="stacker"
+                (onChange)="valueChanged()" />
+        </div>
+    </div>
+</div>
 <div class="row mt-3">
     <div class="color-accent-light text-small">
         ADVANCED SETTINGS

From e0967fa4ea470994ff355794f2e99ae3a5773a5e Mon Sep 17 00:00:00 2001
From: Duc-python <Duc-python@users.noreply.github.com>
Date: Sun, 11 Oct 2026 14:24:24 +0700
Subject: [PATCH 2/2] Make the proxy bypass notice fire only when a proxy was
 actually in use

The notice condition checked whether a proxy was assigned to the bot rather
than whether the job was actually using it, so a job with proxies disabled
that still had a proxy object attached would log a misleading bypass notice
on every block with `useProxy` off. The debugger and the `SET PROXY` LoliCode
statement can both produce that state.

ResolveProxy now returns early unless the job is both proxied and has a proxy
assigned, and only logs on the branch that actually drops a proxy in use.

ResolveProxy is also internal rather than protected so the full decision table
is directly testable; RuriLib already grants InternalsVisibleTo to the test
assembly.
---
 .../Http/HttpClientRequestHandlerTests.cs     | 36 +++++++++++++++++--
 RuriLib.Tests/Functions/Http/HttpTests.cs     | 33 +++++++++++++++++
 RuriLib/Functions/Http/HttpRequestHandler.cs  | 14 +++++---
 3 files changed, 77 insertions(+), 6 deletions(-)

diff --git a/RuriLib.Tests/Functions/Http/HttpClientRequestHandlerTests.cs b/RuriLib.Tests/Functions/Http/HttpClientRequestHandlerTests.cs
index 5fffe3dfd..5fa578bda 100644
--- a/RuriLib.Tests/Functions/Http/HttpClientRequestHandlerTests.cs
+++ b/RuriLib.Tests/Functions/Http/HttpClientRequestHandlerTests.cs
@@ -5,8 +5,10 @@
 using RuriLib.Models.Configs;
 using RuriLib.Models.Data;
 using RuriLib.Models.Environment;
+using RuriLib.Models.Proxies;
 using RuriLib.Tests.Utils.Mockup;
 using System;
+using System.Linq;
 using System.Net.Http;
 using Xunit;
 
@@ -57,7 +59,35 @@ public void TryParseCookie_AttributesWithoutCookiePair_ReturnsFalse()
         Assert.Null(cookieValue);
     }
 
-    private static BotData NewBotData() => new(
+    [Theory]
+    // No proxy assigned at all: the block setting must be irrelevant, never an error
+    [InlineData(false, true, false)]
+    [InlineData(false, false, false)]
+    // Proxy assigned and the job uses it: only useProxy=false bypasses
+    [InlineData(true, true, true)]
+    [InlineData(true, false, false)]
+    public void ResolveProxy_BypassesOnlyWhenRequested(
+        bool botUsesProxy, bool blockUseProxy, bool expectProxyUsed)
+    {
+        var proxy = new Proxy("1.2.3.4", 8080);
+        var data = NewBotData(proxy, botUsesProxy);
+
+        var resolved = HttpRequestHandler.ResolveProxy(data, new StandardHttpRequestOptions
+        {
+            UseProxy = blockUseProxy
+        });
+
+        Assert.Equal(expectProxyUsed, resolved is not null);
+        Assert.Equal(expectProxyUsed ? proxy : null, resolved);
+
+        // The notice fires only when a proxy was actually in use and the block opted out.
+        // A job that simply has proxies disabled is not "bypassing" anything, so it stays quiet.
+        var expectNotice = botUsesProxy && !blockUseProxy;
+        Assert.Equal(expectNotice ? 1 : 0,
+            data.Logger.Entries.Count(e => e.Message.Contains("[NO PROXY]", StringComparison.Ordinal)));
+    }
+
+    private static BotData NewBotData(Proxy? proxy = null, bool useProxy = false) => new(
         new(null!)
         {
             ProxySettings = new MockedProxySettingsProvider(),
@@ -65,5 +95,7 @@ public void TryParseCookie_AttributesWithoutCookiePair_ReturnsFalse()
         },
         new ConfigSettings(),
         new BotLogger(),
-        new DataLine("", new WordlistType()));
+        new DataLine("", new WordlistType()),
+        proxy,
+        useProxy);
 }
diff --git a/RuriLib.Tests/Functions/Http/HttpTests.cs b/RuriLib.Tests/Functions/Http/HttpTests.cs
index 59ca1cdb8..57d7ab810 100644
--- a/RuriLib.Tests/Functions/Http/HttpTests.cs
+++ b/RuriLib.Tests/Functions/Http/HttpTests.cs
@@ -35,6 +35,39 @@ public class HttpTests
         null,
         false);
 
+    [Theory]
+    [InlineData(HttpLibrary.RuriLibHttp, true)]
+    [InlineData(HttpLibrary.RuriLibHttp, false)]
+    [InlineData(HttpLibrary.SystemNet, true)]
+    [InlineData(HttpLibrary.SystemNet, false)]
+    [InlineData(HttpLibrary.CurlImpersonate, true)]
+    [InlineData(HttpLibrary.CurlImpersonate, false)]
+    public async Task HttpRequestStandard_Get_WithoutAnyProxy_Succeeds(HttpLibrary library, bool blockUseProxy)
+    {
+        var httpBin = await TestHttpBin.BuildUrl("anything");
+
+        // A config that does not use proxies at all: no proxy assigned, bot-level UseProxy off
+        var data = NewBotData();
+
+        var options = new StandardHttpRequestOptions
+        {
+            Url = httpBin,
+            Method = HttpMethod.GET,
+            HttpLibrary = library,
+            UseProxy = blockUseProxy
+        };
+
+        await Methods.HttpRequestStandard(data, options);
+
+        var response = DeserializeHttpBinResponse(data.SOURCE);
+        Assert.Equal("GET", response.Method);
+        Assert.Equal(200, (int)data.RESPONSECODE);
+
+        // With no proxy assigned there is nothing to bypass, so the notice must stay silent
+        Assert.DoesNotContain(data.Logger.Entries,
+            entry => entry.Message.Contains("[NO PROXY]", StringComparison.Ordinal));
+    }
+
     [Theory]
     [InlineData(HttpLibrary.RuriLibHttp)]
     [InlineData(HttpLibrary.SystemNet)]
diff --git a/RuriLib/Functions/Http/HttpRequestHandler.cs b/RuriLib/Functions/Http/HttpRequestHandler.cs
index ebf7f02c7..83b357dcb 100644
--- a/RuriLib/Functions/Http/HttpRequestHandler.cs
+++ b/RuriLib/Functions/Http/HttpRequestHandler.cs
@@ -196,15 +196,21 @@ protected static HttpOptions GetClientOptions(BotData data, Options.HttpRequestO
     /// <param name="data">The bot data holding the proxy assigned to this bot.</param>
     /// <param name="options">The options of the block performing the request.</param>
     /// <returns>The proxy to route through, or null to send the request directly.</returns>
-    protected static Proxy? ResolveProxy(BotData data, Options.HttpRequestOptions options)
+    internal static Proxy? ResolveProxy(BotData data, Options.HttpRequestOptions options)
     {
-        if (data.Proxy is not null && !options.UseProxy)
+        // The job is only proxied when it both wants to be and has something assigned
+        if (!data.UseProxy || data.Proxy is null)
         {
-            data.Logger.Log("[NO PROXY] This block is configured to bypass the bot proxy", LogColors.DarkOrange);
             return null;
         }
 
-        return data.UseProxy ? data.Proxy : null;
+        if (options.UseProxy)
+        {
+            return data.Proxy;
+        }
+
+        data.Logger.Log("[NO PROXY] This block is configured to bypass the bot proxy", LogColors.DarkOrange);
+        return null;
     }
 
     protected static void LogNegotiatedHttpVersion(BotData data, Version requestedVersion, Version responseVersion)