feat: can set request optiosn

Author: KeJunMao

src/ChatBot.ts

@@ -16,25 +16,25 @@ export class ChatBot {
 
     let conversation = await createConversation(cookie);
     this.chatHub = new ChatHub(conversation);
-    return this
+    return this;
   }
 
   async askAsync(
     prompt: string,
     handler: (response: Record<string, any>) => void = () => {}
   ) {
     this.chatHub?.once("final", handler);
-    return await this.chatHub?.askAsync(prompt);
+    return await this.chatHub?.askAsync(prompt, this.config.requestOptions);
   }
-  
+
   async ask(prompt: string, handler: (msg: string) => void = () => {}) {
     return new Promise(async (resolve) => {
       this.chatHub?.on("message", handler);
       this.chatHub?.once("final", (res) => {
         this.chatHub?.off("message", handler);
         resolve(res);
       });
-      await this.chatHub?.ask(prompt);
+      await this.chatHub?.ask(prompt, this.config.requestOptions);
     });
   }
 

src/ChatHub.ts

@@ -2,7 +2,7 @@ import EventEmitter from "events";
 import { WebSocket } from "ws";
 import { DELIMITER } from "./constant";
 import { createRequest } from "./request";
-import { Conversation, EdgeGPTResponse } from "./types";
+import { Conversation, EdgeGPTResponse, RequestOptions } from "./types";
 import { appendIdentifier, createHeaders } from "./utils";
 import TypedEmitter from "typed-emitter";
 
@@ -17,28 +17,28 @@ type ChatHubEvents = {
 
 export class ChatHub extends (EventEmitter as new () => TypedEmitter<ChatHubEvents>) {
   protected ws!: WebSocket;
-  protected request: (prompt: string) => any;
+  protected request: (prompt: string, options?: RequestOptions) => any;
 
   constructor(protected conversation: Conversation) {
     super();
     this.request = createRequest(conversation);
   }
 
-  async ask(prompt: string) {
+  async ask(prompt: string, options?: RequestOptions) {
     if (!this.ws || this.ws.readyState === WebSocket.CLOSED) {
       await this.createWs();
     }
-    this.send(this.request(prompt));
+    this.send(this.request(prompt, options));
   }
 
-  askAsync(prompt: string) {
+  askAsync(prompt: string, options?: RequestOptions) {
     return new Promise<string>((resolve) => {
       this.once("final", (response) => {
         resolve(
           response["item"]["messages"][1]["adaptiveCards"][0]["body"][0]["text"]
         );
       });
-      this.ask(prompt);
+      this.ask(prompt, options);
     });
   }
 

src/cli.ts

@@ -3,6 +3,7 @@ import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
 import { version } from "../package.json";
 import { run } from "./commands/run";
+import { defaultRequestOptions } from "./request";
 import { logger } from "./utils";
 
 (async () => {
@@ -21,6 +22,11 @@ import { logger } from "./utils";
     .boolean("stream")
     .describe("stream", "Used stream mode")
     .default("stream", undefined, "true")
+    .option("options", {
+      type: "array",
+    })
+    .default("options", undefined, defaultRequestOptions.join(","))
+    .describe("options", "Conversation request options")
     .alias("h", "help")
     .version("version", version)
     .alias("v", "version")
@@ -32,5 +38,6 @@ import { logger } from "./utils";
   run({
     cookies: args["cookieFile"],
     stream: args["stream"],
+    requestOptions: args["options"],
   }).catch(logger.error);
 })();

src/commands/run.ts

@@ -13,10 +13,10 @@ export const run = async (options: Partial<EdgeGPTConfig>) => {
   const config = await loadEdgeGPTConfig({
     cookies: options.cookies,
     stream: options.stream,
+    requestOptions: options.requestOptions,
   });
 
   const chatBot = new ChatBot(config);
-  await chatBot.create();
   let choices: Choice[] = [];
   marked.setOptions({
     renderer: new TerminalRenderer(),
@@ -49,8 +49,16 @@ export const run = async (options: Partial<EdgeGPTConfig>) => {
     } else if (cmd.prompt === "!reset") {
       await chatBot.reset();
       continue;
+    } else if (cmd.prompt.startsWith("!options")) {
+      const [_c, optstr] = cmd.prompt.split(" ");
+      config.requestOptions = optstr.split(",").map((v: string) => v.trim());
+      console.log(`Update conversation request options to: ${config.requestOptions}`);
+      continue;
     }
     if (cmd.prompt) {
+      if (!chatBot.chatHub) {
+        await chatBot.reset();
+      }
       let response: any;
       const spinnerPrefix = "Bing is typing...";
       const spinner = ora(spinnerPrefix);

src/config.ts

@@ -1,19 +1,21 @@
 import { loadConfig } from "c12";
 import { readFileSync } from "fs";
 import { resolve } from "path";
+import { defaultRequestOptions } from "./request";
 import { EdgeGPTConfig, ResolvedEdgeGPTConfig } from "./types";
 import { logger } from "./utils";
 
 const configDefaults: EdgeGPTConfig = {
   cookies: "cookie.json",
   stream: true,
+  requestOptions: defaultRequestOptions,
 };
 
 export const loadEdgeGPTConfig = async (
   overrides?: Partial<EdgeGPTConfig>,
   cwd = process.cwd()
 ) => {
-  const { config, layers, configFile } = await loadConfig<EdgeGPTConfig>({
+  const { config } = await loadConfig<EdgeGPTConfig>({
     name: "edgegpt",
     defaults: configDefaults,
     globalRc: true,
@@ -36,5 +38,6 @@ export const loadEdgeGPTConfig = async (
     });
     return JSON.parse(f);
   });
+  config.requestOptions = config.requestOptions.filter((v) => v);
   return config as unknown as ResolvedEdgeGPTConfig;
 };

src/request.ts

@@ -1,16 +1,15 @@
-import { Conversation } from "./types";
+import { Conversation, RequestOptions } from "./types";
+
+export const defaultRequestOptions: RequestOptions = [
+  "deepleo",
+  "enable_debug_commands",
+  "disable_emoji_spoken_text",
+  "enablemm",
+];
 
 export const createRequest = (con: Conversation) => {
   let invocationId = 0;
-  return (
-    prompt: string,
-    options: string[] = [
-      "deepleo",
-      "enable_debug_commands",
-      "disable_emoji_spoken_text",
-      "enablemm",
-    ]
-  ) => {
+  return (prompt: string, options: RequestOptions = defaultRequestOptions) => {
     const request = {
       arguments: [
         {

src/types.ts

@@ -6,14 +6,33 @@ export interface CookieItem {
 
 export type Cookie = CookieItem[];
 
+export interface IRequestOptions {
+  nlu_direct_response_filter: boolean;
+  deepleo: boolean;
+  disable_emoji_spoken_text: boolean;
+  enable_debug_commands: boolean;
+  responsible_ai_policy_235: boolean;
+  enablemm: boolean;
+  // style start
+  h3imaginative: boolean;
+  h3precise: boolean;
+  harmonyv3: boolean;
+  // style end
+  dv3sugg: boolean;
+}
+
+export type RequestOptions = (keyof IRequestOptions)[];
+
 export interface EdgeGPTConfig {
   cookies: Path | Path[];
   stream: boolean;
+  requestOptions: RequestOptions;
 }
 
 export interface ResolvedEdgeGPTConfig {
   cookies: Cookie[];
   stream: boolean;
+  requestOptions: RequestOptions;
 }
 
 export interface Conversation {