How to ignore vscode's proxy configuration when I make a request to my own backend service?

[Anthonywck]

I am developing a plug-in that has network interaction with the backend service, but when I interact with the backend, my request is affected by vscode's proxy configuration, which prevents the request from being successful.

I tried using axios and http.request, as well as EventSource, to establish a long conversation connection for stream chat. After finding the problem, I also tried to disable the agent in the Options Settings of the request, and customized the agent of the request, but it did not take effect.

How can I ignore the proxy?Thank you for your attentio！

And here is my Code snippet：

axios demo

async function chatToServerWithStream(data: any) {
    const {
      baseUrl,
      msg,
      user,
      mac,
      ip,
      version,
      language,
      recordings,
      model,
      uuid,
      terminal,
      editTime,
    } = data;
    let message = '';
    const postData = {
      message: msg,
      stream: true,
      language: language,
      recordings: recordings,
      model: model,
      first_edit_time_diff: editTime,
    };
  
    // 使用自定义 Agent 禁用代理
    const httpAgent = new http.Agent({ keepAlive: true });
    const httpsAgent = new https.Agent({ keepAlive: true });
  
    // 配置 axios 请求
    const options = {
      url: `${baseUrl}/uis/light-code/web/chat/completions/stream`,
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        user: user,
        mac: mac,
        terminal: terminal,
        ip: ip,
        version: version,
        source: 'conversation',
        convId: uuid,
      },
      data: postData,
      responseType: 'stream', // 设置响应类型为流
      httpAgent, // 强制使用自定义 agent
      httpsAgent,
      proxy: false, // 禁止代理
    };
  
    const chatProvider = GlobalStore.getStore().getStaticValue('chatProvider');
    try {
      const response = await axios(options);
  
      let buffer = '';
      response.data.on('data', (chunk: any) => {
        buffer += chunk.toString();
  
        let dataBlocks = buffer.split('\ndata:');
        buffer = dataBlocks.pop() || ''; // 保留未完成的数据块
  
        dataBlocks.forEach((dataBlock) => {
          dataBlock = dataBlock.trim();
          if (dataBlock.startsWith('data:')) {
            dataBlock = dataBlock.slice(5).trim();
          }
  
          if (!dataBlock) return;
  
          try {
            const parsed = JSON.parse(dataBlock);
            const delta = parsed.choices[0]?.delta?.content || '';
            if (delta) {
              message += delta;
  
              const messg = {
                answer: message,
                uuid: uuid,
              };
              chatProvider.postMessage(OP.LIGHT_SEND_MESSAGE, messg);
            }
          } catch (err) {
            console.error('解析流数据出错:', err);
          }
        });
      });
  
      response.data.on('end', () => {
        if (buffer.trim()) {
          try {
            const parsed = JSON.parse(buffer);
            const delta = parsed.choices[0]?.delta?.content || '';
            if (delta) {
              message += delta;
  
              const messg = {
                answer: message,
                uuid: uuid,
              };
              chatProvider.postMessage(OP.LIGHT_SEND_MESSAGE, messg);
            }
          } catch (err) {
            console.error('解析剩余数据出错:', err);
          }
        }
  
        const messg = {
          answer: DONE_FLAG,
          uuid: uuid,
        };
        chatProvider.postMessage(OP.LIGHT_SEND_MESSAGE, messg);
        console.log('流式响应已完成');
      });
    } catch (error) {
      console.error('请求出错:', error);
      const messg = {
        answer: DONE_FLAG,
        uuid: uuid,
      };
      chatProvider.postMessage(OP.LIGHT_SEND_MESSAGE, messg);
    }
  }

http.request

async function chatToServerWithStreamHttp(data: any) {
    const {
      baseUrl,
      msg,
      user,
      mac,
      ip,
      version,
      language,
      recordings,
      model,
      uuid,
      terminal,
      editTime,
    } = data;
    // let currMessage = this.chatList.find((item) => item.uuid === uuid);
    // if (currMessage) {
    //   msg.type ? (currMessage.prompt_type = msg.type) : '';
    // }

    let message = '';
    // const _this = this;

    const postData = JSON.stringify({
      message: msg,
      stream: true,
      language: language,
      recordings: recordings,
      model: model,
      first_edit_time_diff: editTime,
    });

    const options = {
      hostname: new URL(baseUrl).hostname,
      port: 80, // 使用 HTTPS 时替换为 443
      path: '/uis/light-code/web/chat/completions/stream',
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'Content-Length': Buffer.byteLength(postData),
        user: user,
        mac: mac,
        terminal: terminal,
        ip: ip,
        version: version,
        source: 'conversation',
        convId: uuid,
      },
      anget: false, // 忽略代理
    };
    const chatProvider = GlobalStore.getStore().getStaticValue('chatProvider');
    const req = http.request(options, (res: any) => {
      let buffer = '';

      if (res.statusCode < 200 || res.statusCode >= 300) {
        console.error(`请求失败，状态码: ${res.statusCode}`);
        return;
      }

      res.on('data', (chunk: any) => {
        // 收到流式数据时追加到缓冲区
        buffer += chunk.toString();

        // 按 SSE 格式分割数据块，并实时处理每个块
        let dataBlocks = buffer.split('\ndata:');
        buffer = dataBlocks.pop() || ''; // 保留不完整的部分

        // 逐个处理每个 data: 块
        dataBlocks.forEach((dataBlock) => {
          dataBlock = dataBlock.trim();

          if (dataBlock.startsWith('data:')) {
            dataBlock = dataBlock.slice(5).trim(); // 去掉前面的 "data:" 前缀
          }

          if (!dataBlock) return;

          try {
            const parsed = JSON.parse(dataBlock);
            const delta = parsed.choices[0]?.delta?.content || '';

            if (delta) {
              message += delta;

              const messg = {
                answer: message,
                uuid: uuid,
              };
              chatProvider.postMessage(OP.LIGHT_SEND_MESSAGE, messg); // 发送给webview
            }
          } catch (err) {
            console.error('解析流数据出错:', err);
          }
        });
      });

      res.on('end', () => {
        // 响应结束时处理未解析的剩余数据
        if (buffer.trim()) {
          try {
            const parsed = JSON.parse(buffer);
            const delta = parsed.choices[0]?.delta?.content || '';
            if (delta) {
              message += delta;

              const messg = {
                answer: message,
                uuid: uuid,
              };
              chatProvider.postMessage(OP.LIGHT_SEND_MESSAGE, messg); // 发送给webview
            }
          } catch (err) {
            console.error('解析剩余数据出错:', err);
          }
        }

        // 通知流已完成
        const messg = {
          answer: DONE_FLAG,
          uuid: uuid,
        };
        chatProvider.postMessage(OP.LIGHT_SEND_MESSAGE, messg); // 发送给webview
        console.log('流式响应已完成');
      });
    });

    req.on('error', (error: any) => {
      console.error('请求出错:', error);
      const messg = {
        answer: DONE_FLAG,
        uuid: uuid,
      };
      chatProvider.postMessage(OP.LIGHT_SEND_MESSAGE, messg); // 发送给webview
    });

    req.write(postData);
    req.end();
  }

eventsource demo

async chatToServerWithStream(data) {
     const {
       baseUrl,
       msg,
       user,
       mac,
       ip,
       version,
       language,
       recordings,
       model,
       uuid,
       terminal,
       editTime,
     } = data;
     // 判断当前回答是否结束，如果当前回答正在进行而且本次触发不是当前回答的触发，就驳回请求
     if (this.answerStatus && this.currChat.uuid !== uuid) {
       return;
     }
     let currMessage = this.chatList.find((item) => item.uuid === uuid);
     if (currMessage) {
       // console.log('msg.type', msg.type);
       msg.type ? (currMessage.prompt_type = msg.type) : '';
     }
     let message = '';
     let eventSource;
     try {
       const _this = this;
       eventSource = await fetchEventSource(
         `${baseUrl}uis/light-code/web/chat/completions/stream`,
         {
           method: 'POST',
           headers: {
             'Content-Type': 'application/json',
             user: user,
             mac: mac,
             terminal: terminal,
             ip: ip,
             version: version,
             source: 'conversation',
             convId: uuid,
           },
           body: JSON.stringify({
             message: msg,
             stream: true,
             language: language,
             recordings: recordings,
             model: model, // 对话所选模型
             first_edit_time_diff: editTime,
           }),
           openWhenHidden: true, // 切换页签的时候本次请求不中断，并且再次切入页面的时候，不会发第二次请求
           async onopen(response) {
             if (response.ok) {
               console.log('连接成功');
             } else if (
               response.status >= 400 &&
               response.status < 500 &&
               response.status !== 429
             ) {
               const text = await response.text();
               let messg = {
                 answer: text,
                 uuid: uuid,
               };
               _this.parserReceiveMessage(messg);
               // messg = {
               //     answer: DONE_FLAG,
               //     uuid: uuid,
               // };
               // _this.parserReceiveMessage(messg);
               throw new Error('返回异常: ' + response.status);
             } else {
               const text = await response.text();
               console.log('error message', text);
               let messg = {
                 answer: text,
                 uuid: uuid,
               };
               _this.parserReceiveMessage(messg);
               throw new Error('返回异常:' + response.status);
             }
           },
           async onmessage(e) {
             const res1 = JSON.parse(e.data);
             if (res1 === DONE_FLAG || res1.choices[0].finish_reasion === 'stop') {
               message = DONE_FLAG;
             } else if (res1 === '[DISPLAY]') {
               const message1 = message;
               console.log('message:', message1);
               message = '';
             } else {
               let res2;
               try {
                 res2 = JSON.parse(e.data);
               } catch (error) {
                 res2 = '';
                 throw new Error(error);
               }
               const choices = res2?.choices ?? '';
               let msg;
               if (choices) {
                 msg = choices.reduce((acc, cur) => {
                   acc += cur.delta.content ?? '';
                   return acc;
                 }, '');
                 message += msg;
               }
             }
             const messg = {
               answer: message,
               uuid: uuid,
             };
             _this.parserReceiveMessage(messg);
           },
           onclose() {
             const messg = {
               answer: DONE_FLAG,
               uuid: uuid,
             };
             _this.parserReceiveMessage(messg);
           },
           onerror(error) {
             console.log('error', error);
             let messg = {
               answer: DONE_FLAG,
               uuid: uuid,
             };
             _this.parserReceiveMessage(messg);
             eventSource?.close();
             throw new Error('返回异常。');
             // eventSource?.close();
           },
         }
       );
     } catch (e) {
       let messg = {
         answer: '流式对话输出报错：' + e,
         uuid: uuid,
       };
       this.parserReceiveMessage(messg);
       messg = {
         answer: DONE_FLAG,
         uuid: uuid,
       };
       this.parserReceiveMessage(messg);
       console.error('流式对话输出报错：', e);
       eventSource?.close();
     } finally {
       eventSource?.close();
     }
   },