@openclaw-china/qqbot 2026.3.21 → 2026.3.29

package/dist/index.js

@@ -4238,6 +4238,7 @@ var QQBotAccountSchema = external_exports.object({
   enabled: external_exports.boolean().optional(),
   appId: optionalCoercedString,
   clientSecret: optionalCoercedString,
+  streaming: external_exports.boolean().optional().default(false),
   displayAliases: displayAliasesSchema,
   asr: external_exports.object({
     enabled: external_exports.boolean().optional().default(false),
@@ -4318,6 +4319,9 @@ function resolveQQBotTypingHeartbeatIntervalMs(config) {
 function resolveQQBotTypingInputSeconds(config) {
   return config?.typingInputSeconds ?? DEFAULT_QQBOT_TYPING_INPUT_SECONDS;
 }
+function resolveQQBotStreaming(config) {
+  return config?.streaming === true;
+}
 function resolveInboundMediaTempDir() {
   return DEFAULT_INBOUND_MEDIA_TEMP_DIR;
 }
@@ -7502,6 +7506,9 @@ function nextMsgSeq(sequenceKey) {
   }
   return MSG_SEQ_BASE + next;
 }
+function allocateMsgSeq(sequenceKey) {
+  return nextMsgSeq(sequenceKey);
+}
 function resolveMsgSeqKey(messageId, eventId) {
   if (messageId) return `msg:${messageId}`;
   if (eventId) return `event:${eventId}`;
@@ -7609,6 +7616,16 @@ async function getGatewayUrl(accessToken) {
   const data = await apiGet(accessToken, "/gateway", { timeout: 15e3 });
   return data.url;
 }
+var QQBotStreamInputMode = {
+  REPLACE: "replace"
+};
+var QQBotStreamInputState = {
+  GENERATING: 1,
+  DONE: 10
+};
+var QQBotStreamContentType = {
+  MARKDOWN: "markdown"
+};
 function buildMessageBody(params) {
   const body = buildTextMessageBody({
     content: params.content,
@@ -7766,6 +7783,24 @@ async function sendC2CMediaMessage(params) {
     })
   });
 }
+async function sendC2CStreamMessage(params) {
+  const body = {
+    input_mode: params.request.input_mode,
+    input_state: params.request.input_state,
+    content_type: params.request.content_type,
+    content_raw: params.request.content_raw,
+    event_id: params.request.event_id,
+    msg_id: params.request.msg_id,
+    msg_seq: params.request.msg_seq,
+    index: params.request.index
+  };
+  if (params.request.stream_msg_id) {
+    body.stream_msg_id = params.request.stream_msg_id;
+  }
+  return apiPost(params.accessToken, `/v2/users/${params.openid}/stream_messages`, body, {
+    timeout: 15e3
+  });
+}
 async function sendGroupMediaMessage(params) {
   return postPassiveMessage({
     accessToken: params.accessToken,
@@ -9282,6 +9317,263 @@ function getQQBotRuntime() {
   }
   return runtime;
 }
+
+// src/streaming.ts
+var DEFAULT_THROTTLE_MS = 500;
+var DEFAULT_MIN_THROTTLE_MS = 300;
+var QQBotStreamingController = class {
+  params;
+  throttleMs;
+  chain = Promise.resolve();
+  flushTimer = null;
+  startPromise = null;
+  latestText = "";
+  lastSentText = "";
+  streamMsgId;
+  msgSeq;
+  index = 0;
+  lastPartialLength = 0;
+  lastSendAt = 0;
+  sessionSentChunkCount = 0;
+  sessionShouldFallbackToStatic = false;
+  firstChunkNotified = false;
+  replyOrdinal = 0;
+  disposed = false;
+  constructor(params) {
+    this.params = params;
+    const throttle = params.throttleMs ?? DEFAULT_THROTTLE_MS;
+    const minThrottle = params.minThrottleMs ?? DEFAULT_MIN_THROTTLE_MS;
+    this.throttleMs = Math.max(throttle, minThrottle);
+  }
+  get hasSuccessfulChunk() {
+    return this.sessionSentChunkCount > 0;
+  }
+  get shouldFallbackToStatic() {
+    return this.sessionShouldFallbackToStatic && this.sessionSentChunkCount === 0;
+  }
+  get hasObservedPartial() {
+    return this.lastPartialLength > 0;
+  }
+  async onPartialReply(text) {
+    await this.enqueue(async () => {
+      if (this.disposed) return;
+      if (this.lastPartialLength > 0 && text.length < this.lastPartialLength) {
+        this.logInfo(
+          `reply boundary detected (${text.length} < ${this.lastPartialLength}), starting new stream session`
+        );
+        await this.finalizeCurrentReply();
+        this.resetReplyState();
+      }
+      this.lastPartialLength = text.length;
+      this.latestText = text;
+      if (!text.trim() || this.sessionShouldFallbackToStatic) {
+        return;
+      }
+      if (!this.streamMsgId) {
+        await this.ensureStreamingStarted();
+        return;
+      }
+      this.scheduleFlush();
+    });
+  }
+  async finalize() {
+    await this.enqueue(async () => {
+      await this.finalizeCurrentReply();
+    });
+  }
+  dispose() {
+    this.disposed = true;
+    this.clearFlushTimer();
+  }
+  enqueue(task) {
+    this.chain = this.chain.then(task, async (err) => {
+      this.logError(`stream queue recovered after error: ${String(err)}`);
+      await task();
+    });
+    return this.chain;
+  }
+  async ensureStreamingStarted() {
+    if (this.disposed || this.streamMsgId || this.sessionShouldFallbackToStatic) {
+      return;
+    }
+    if (this.startPromise) {
+      await this.startPromise;
+      return;
+    }
+    this.startPromise = this.startStreaming();
+    try {
+      await this.startPromise;
+    } finally {
+      this.startPromise = null;
+    }
+  }
+  async startStreaming() {
+    if (!this.latestText.trim()) {
+      return;
+    }
+    try {
+      this.msgSeq ??= allocateMsgSeq(`stream:${this.params.messageId}:${this.replyOrdinal}`);
+      const response = await this.sendChunk({
+        content: this.latestText,
+        inputState: QQBotStreamInputState.GENERATING
+      });
+      if (!response.id) {
+        throw new Error("QQ stream response missing stream message id");
+      }
+      this.streamMsgId = response.id;
+      this.lastSentText = this.latestText;
+      this.lastSendAt = Date.now();
+      this.sessionSentChunkCount += 1;
+      this.index += 1;
+      await this.notifyFirstChunk();
+      if (this.latestText !== this.lastSentText) {
+        this.scheduleFlush();
+      }
+    } catch (err) {
+      this.sessionShouldFallbackToStatic = true;
+      this.logWarn(`failed to start stream session, falling back to static: ${String(err)}`);
+    }
+  }
+  async flushNow() {
+    if (this.disposed || !this.streamMsgId || this.sessionShouldFallbackToStatic || !this.latestText.trim() || this.latestText === this.lastSentText) {
+      return;
+    }
+    try {
+      await this.sendChunk({
+        content: this.latestText,
+        inputState: QQBotStreamInputState.GENERATING
+      });
+      this.lastSentText = this.latestText;
+      this.lastSendAt = Date.now();
+      this.sessionSentChunkCount += 1;
+      this.index += 1;
+      await this.notifyFirstChunk();
+    } catch (err) {
+      this.logWarn(`failed to flush stream chunk: ${String(err)}`);
+    }
+  }
+  scheduleFlush() {
+    if (this.disposed || this.flushTimer || !this.streamMsgId || this.sessionShouldFallbackToStatic) {
+      return;
+    }
+    const elapsed = Date.now() - this.lastSendAt;
+    if (elapsed >= this.throttleMs) {
+      void this.enqueue(async () => {
+        await this.flushNow();
+      });
+      return;
+    }
+    const waitMs = this.throttleMs - elapsed;
+    this.flushTimer = setTimeout(() => {
+      this.flushTimer = null;
+      void this.enqueue(async () => {
+        await this.flushNow();
+      });
+    }, waitMs);
+    this.flushTimer.unref?.();
+  }
+  async finalizeCurrentReply() {
+    this.clearFlushTimer();
+    if (this.startPromise) {
+      await this.startPromise;
+    }
+    if (!this.streamMsgId) {
+      return;
+    }
+    const finalText = (this.latestText || this.lastSentText).trim() ? this.latestText || this.lastSentText : this.lastSentText;
+    if (!finalText) {
+      this.resetStreamSession();
+      return;
+    }
+    try {
+      await this.sendChunk({
+        content: finalText,
+        inputState: QQBotStreamInputState.DONE
+      });
+      this.lastSentText = finalText;
+      this.lastSendAt = Date.now();
+      this.sessionSentChunkCount += 1;
+      this.index += 1;
+    } catch (err) {
+      this.logWarn(`failed to finalize stream session: ${String(err)}`);
+    } finally {
+      this.resetStreamSession();
+    }
+  }
+  async sendChunk(params) {
+    const msgSeq = this.msgSeq ?? allocateMsgSeq(`stream:${this.params.messageId}:${this.replyOrdinal}`);
+    this.msgSeq = msgSeq;
+    const accessToken = await getAccessToken(this.params.appId, this.params.clientSecret);
+    const response = await sendC2CStreamMessage({
+      accessToken,
+      openid: this.params.openid,
+      request: {
+        input_mode: QQBotStreamInputMode.REPLACE,
+        input_state: params.inputState,
+        content_type: QQBotStreamContentType.MARKDOWN,
+        content_raw: params.content,
+        event_id: this.params.eventId,
+        msg_id: this.params.messageId,
+        msg_seq: msgSeq,
+        index: this.index,
+        ...this.streamMsgId ? { stream_msg_id: this.streamMsgId } : {}
+      }
+    });
+    if (response.code && response.code > 0) {
+      throw new Error(`QQ stream API error ${response.code}: ${response.message ?? "unknown error"}`);
+    }
+    return {
+      id: typeof response.id === "string" ? response.id : void 0
+    };
+  }
+  async notifyFirstChunk() {
+    if (this.firstChunkNotified) {
+      return;
+    }
+    this.firstChunkNotified = true;
+    try {
+      await this.params.onFirstChunk?.();
+    } catch (err) {
+      this.logWarn(`onFirstChunk hook failed: ${String(err)}`);
+    }
+  }
+  clearFlushTimer() {
+    if (!this.flushTimer) {
+      return;
+    }
+    clearTimeout(this.flushTimer);
+    this.flushTimer = null;
+  }
+  resetReplyState() {
+    this.replyOrdinal += 1;
+    this.lastPartialLength = 0;
+    this.latestText = "";
+    this.lastSentText = "";
+    this.sessionSentChunkCount = 0;
+    this.sessionShouldFallbackToStatic = false;
+    this.firstChunkNotified = false;
+    this.resetStreamSession();
+  }
+  resetStreamSession() {
+    this.streamMsgId = void 0;
+    this.msgSeq = void 0;
+    this.index = 0;
+    this.lastSendAt = 0;
+    this.clearFlushTimer();
+  }
+  logInfo(message) {
+    const next = `${this.params.logPrefix ?? "[qqbot:streaming]"} ${message}`;
+    this.params.logger?.info?.(next);
+  }
+  logWarn(message) {
+    const next = `${this.params.logPrefix ?? "[qqbot:streaming]"} ${message}`;
+    (this.params.logger?.warn ?? this.params.logger?.info)?.(next);
+  }
+  logError(message) {
+    const next = `${this.params.logPrefix ?? "[qqbot:streaming]"} ${message}`;
+    this.params.logger?.error?.(next);
+  }
+};
 var sessionDispatchQueue = /* @__PURE__ */ new Map();
 var QQBOT_ABORT_TRIGGERS = /* @__PURE__ */ new Set([
   "stop",
@@ -11408,6 +11700,14 @@ function looksLikeStructuredMarkdown(text) {
   }
   return normalized.includes("\n\n") || lines.some((line) => MARKDOWN_ATX_HEADING_RE.test(line)) || lines.some((line) => MARKDOWN_BLOCKQUOTE_RE.test(line)) || lines.some((line) => MARKDOWN_FENCE_RE.test(line)) || lines.some((line) => MARKDOWN_THEMATIC_BREAK_RE.test(line)) || lines.some((line) => MARKDOWN_LIST_ITEM_RE.test(line)) || MARKDOWN_INLINE_STRUCTURE_RE.test(normalized);
 }
+function looksLikeQQBotStreamingIneligibleMarkdown(text) {
+  const normalized = normalizeQQBotMarkdownSegment(text);
+  if (!normalized) {
+    return false;
+  }
+  const lines = normalized.split("\n");
+  return hasQQBotMarkdownTable(normalized) || lines.some((line) => MARKDOWN_ATX_HEADING_RE.test(line)) || lines.some((line) => MARKDOWN_BLOCKQUOTE_RE.test(line)) || lines.some((line) => MARKDOWN_FENCE_RE.test(line)) || lines.some((line) => MARKDOWN_THEMATIC_BREAK_RE.test(line)) || lines.some((line) => MARKDOWN_LIST_ITEM_RE.test(line));
+}
 function chunkC2CMarkdownText(params) {
   const normalized = params.text.trim();
   if (!normalized) {
@@ -11798,10 +12098,26 @@ async function dispatchToAgent(params) {
     const c2cMarkdownChunkStrategy = qqCfg.c2cMarkdownChunkStrategy ?? "markdown-block";
     const c2cMarkdownSafeChunkByteLimit = resolveQQBotC2CMarkdownSafeChunkByteLimit(qqCfg);
     const isC2CTarget = isQQBotC2CTarget(target.to);
+    const streamingEnabled = isC2CTarget && !replyFinalOnly && resolveQQBotStreaming(qqCfg);
     const useC2CMarkdownTransport = markdownSupport && isC2CTarget;
     let bufferedC2CMarkdownTexts = [];
     let bufferedC2CMarkdownMediaUrls = [];
     const bufferedC2CMarkdownMediaSeen = /* @__PURE__ */ new Set();
+    const streamingCredentials = streamingEnabled ? resolveQQBotCredentials(qqCfg) : void 0;
+    const streamingController = streamingEnabled && inbound.c2cOpenid && streamingCredentials ? new QQBotStreamingController({
+      appId: streamingCredentials.appId,
+      clientSecret: streamingCredentials.clientSecret,
+      openid: inbound.c2cOpenid,
+      messageId: inbound.messageId,
+      eventId: inbound.eventId ?? inbound.messageId,
+      logger,
+      logPrefix: `[qqbot:${outboundAccountId}:streaming]`,
+      onFirstChunk: async () => {
+        markVisibleOutboundStarted();
+        markReplyDelivered();
+        typingHeartbeat?.stop();
+      }
+    }) : null;
     const hasBufferedC2CMarkdownReply = () => bufferedC2CMarkdownTexts.length > 0 || bufferedC2CMarkdownMediaUrls.length > 0;
     const bufferC2CMarkdownMedia = (url) => {
       const next = url?.trim();
@@ -11809,6 +12125,28 @@ async function dispatchToAgent(params) {
       bufferedC2CMarkdownMediaSeen.add(next);
       bufferedC2CMarkdownMediaUrls.push(next);
     };
+    const handleStreamingPartialReply = async (payload) => {
+      if (!streamingController || shouldSuppressVisibleReplies()) {
+        return;
+      }
+      const rawText = payload.text ?? "";
+      if (!rawText.trim()) {
+        return;
+      }
+      const extractedTextMedia = extractQQBotReplyMedia({
+        text: rawText,
+        logger,
+        autoSendLocalPathMedia: resolveQQBotAutoSendLocalPathMedia(qqCfg)
+      });
+      const cleanedText = sanitizeQQBotOutboundText(extractedTextMedia.text);
+      if (!cleanedText) {
+        return;
+      }
+      if (!streamingController.hasSuccessfulChunk && (extractedTextMedia.mediaUrls.length > 0 || looksLikeQQBotStreamingIneligibleMarkdown(cleanedText))) {
+        return;
+      }
+      await streamingController.onPartialReply(cleanedText);
+    };
     const sendC2CMarkdownTransportPayload = async (params2) => {
       if (shouldSuppressVisibleReplies()) {
         return;
@@ -11946,8 +12284,14 @@ async function dispatchToAgent(params) {
       });
       if (deliveryDecision.skipDelivery) return;
       const suppressEchoText = mediaQueue.length > 0 && shouldSuppressQQBotTextWhenMediaPresent(extractedTextMedia.text, cleanedText);
-      const suppressText = deliveryDecision.suppressText || suppressEchoText;
+      const streamingOwnsAssistantText = info?.kind !== "tool" && Boolean(
+        streamingController && streamingController.hasSuccessfulChunk && !streamingController.shouldFallbackToStatic
+      );
+      const suppressText = deliveryDecision.suppressText || suppressEchoText || streamingOwnsAssistantText;
       const textToSend = suppressText ? "" : cleanedText;
+      if (streamingOwnsAssistantText && mediaQueue.length === 0 && !textToSend) {
+        return;
+      }
       if (useC2CMarkdownTransport) {
         const shouldBufferFinalOnlyPayload = replyFinalOnly && (!info?.kind || info.kind === "final");
         const shouldBufferStructuredMarkdownPayload = !replyFinalOnly && c2cMarkdownChunkStrategy === "markdown-block" && info?.kind !== "tool" && (hasBufferedC2CMarkdownReply() || looksLikeStructuredMarkdown(textToSend));
@@ -12032,82 +12376,92 @@ async function dispatchToAgent(params) {
     const dispatchDirect = replyApi.dispatchReplyWithDispatcher;
     const dispatchBuffered = replyApi.dispatchReplyWithBufferedBlockDispatcher;
     const streamingReplyOptions = isC2CTarget && !replyFinalOnly ? {
-      disableBlockStreaming: false
+      disableBlockStreaming: false,
+      ...streamingController ? {
+        onPartialReply: handleStreamingPartialReply
+      } : {}
     } : void 0;
-    if (isC2CTarget && !replyFinalOnly && dispatchDirect) {
-      logger.debug(`[dispatch] mode=direct session=${routeSessionKey} to=${target.to}`);
-      await dispatchDirect({
-        ctx: finalCtx,
-        cfg,
-        dispatcherOptions: {
-          deliver,
-          humanDelay,
-          onError: (err, info) => {
-            logger.error(`${info.kind} reply failed: ${String(err)}`);
-          },
-          onSkip: (_payload, info) => {
-            if (info.reason !== "silent") {
-              logger.info(`reply skipped: ${info.reason}`);
+    try {
+      if (isC2CTarget && !replyFinalOnly && dispatchDirect) {
+        logger.debug(`[dispatch] mode=direct session=${routeSessionKey} to=${target.to}`);
+        await dispatchDirect({
+          ctx: finalCtx,
+          cfg,
+          dispatcherOptions: {
+            deliver,
+            humanDelay,
+            onError: (err, info) => {
+              logger.error(`${info.kind} reply failed: ${String(err)}`);
+            },
+            onSkip: (_payload, info) => {
+              if (info.reason !== "silent") {
+                logger.info(`reply skipped: ${info.reason}`);
+              }
             }
-          }
-        },
-        replyOptions: streamingReplyOptions
-      });
-      await flushBufferedC2CMarkdownReply();
-    } else if (dispatchBuffered) {
-      logger.debug(`[dispatch] mode=buffered session=${routeSessionKey} to=${target.to}`);
-      await dispatchBuffered({
-        ctx: finalCtx,
-        cfg,
-        dispatcherOptions: {
-          deliver,
-          humanDelay,
-          onError: (err, info) => {
-            logger.error(`${info.kind} reply failed: ${String(err)}`);
           },
-          onSkip: (_payload, info) => {
-            if (info.reason !== "silent") {
-              logger.info(`reply skipped: ${info.reason}`);
+          replyOptions: streamingReplyOptions
+        });
+        await flushBufferedC2CMarkdownReply();
+      } else if (dispatchBuffered) {
+        logger.debug(`[dispatch] mode=buffered session=${routeSessionKey} to=${target.to}`);
+        await dispatchBuffered({
+          ctx: finalCtx,
+          cfg,
+          dispatcherOptions: {
+            deliver,
+            humanDelay,
+            onError: (err, info) => {
+              logger.error(`${info.kind} reply failed: ${String(err)}`);
+            },
+            onSkip: (_payload, info) => {
+              if (info.reason !== "silent") {
+                logger.info(`reply skipped: ${info.reason}`);
+              }
             }
-          }
-        },
-        replyOptions: streamingReplyOptions
-      });
-      await flushBufferedC2CMarkdownReply();
-    } else {
-      logger.debug(`[dispatch] mode=legacy session=${routeSessionKey} to=${target.to}`);
-      const dispatcherResult = replyApi.createReplyDispatcherWithTyping ? replyApi.createReplyDispatcherWithTyping({
-        deliver,
-        humanDelay,
-        onError: (err, info) => {
-          logger.error(`${info.kind} reply failed: ${String(err)}`);
-        }
-      }) : {
-        dispatcher: replyApi.createReplyDispatcher?.({
+          },
+          replyOptions: streamingReplyOptions
+        });
+        await flushBufferedC2CMarkdownReply();
+      } else {
+        logger.debug(`[dispatch] mode=legacy session=${routeSessionKey} to=${target.to}`);
+        const dispatcherResult = replyApi.createReplyDispatcherWithTyping ? replyApi.createReplyDispatcherWithTyping({
           deliver,
           humanDelay,
           onError: (err, info) => {
             logger.error(`${info.kind} reply failed: ${String(err)}`);
           }
-        }),
-        replyOptions: {},
-        markDispatchIdle: () => void 0
-      };
-      if (!dispatcherResult.dispatcher || !replyApi.dispatchReplyFromConfig) {
-        logger.warn("dispatcher not available, skipping reply");
-        return;
-      }
-      await replyApi.dispatchReplyFromConfig({
-        ctx: finalCtx,
-        cfg,
-        dispatcher: dispatcherResult.dispatcher,
-        replyOptions: {
-          ...typeof dispatcherResult.replyOptions === "object" && dispatcherResult.replyOptions ? dispatcherResult.replyOptions : {},
-          ...streamingReplyOptions ?? {}
+        }) : {
+          dispatcher: replyApi.createReplyDispatcher?.({
+            deliver,
+            humanDelay,
+            onError: (err, info) => {
+              logger.error(`${info.kind} reply failed: ${String(err)}`);
+            }
+          }),
+          replyOptions: {},
+          markDispatchIdle: () => void 0
+        };
+        if (!dispatcherResult.dispatcher || !replyApi.dispatchReplyFromConfig) {
+          logger.warn("dispatcher not available, skipping reply");
+          return;
         }
-      });
-      dispatcherResult.markDispatchIdle?.();
-      await flushBufferedC2CMarkdownReply();
+        await replyApi.dispatchReplyFromConfig({
+          ctx: finalCtx,
+          cfg,
+          dispatcher: dispatcherResult.dispatcher,
+          replyOptions: {
+            ...typeof dispatcherResult.replyOptions === "object" && dispatcherResult.replyOptions ? dispatcherResult.replyOptions : {},
+            ...streamingReplyOptions ?? {}
+          }
+        });
+        dispatcherResult.markDispatchIdle?.();
+        await flushBufferedC2CMarkdownReply();
+      }
+    } finally {
+      if (streamingController) {
+        await streamingController.finalize();
+        streamingController.dispose();
+      }
     }
     const noReplyFallback = resolveQQBotNoReplyFallback({
       inbound,
@@ -12632,6 +12986,7 @@ function resolveQQBotAccount(params) {
     enabled,
     configured,
     appId: credentials?.appId,
+    streaming: merged.streaming === true,
     markdownSupport: merged.markdownSupport ?? true,
     c2cMarkdownDeliveryMode: merged.c2cMarkdownDeliveryMode ?? "proactive-table-only",
     c2cMarkdownChunkStrategy: merged.c2cMarkdownChunkStrategy ?? "markdown-block"
@@ -12712,6 +13067,7 @@ var qqbotPlugin = {
         defaultAccount: { type: "string" },
         appId: { type: ["string", "number"] },
         clientSecret: { type: "string" },
+        streaming: { type: "boolean" },
         displayAliases: {
           type: "object",
           additionalProperties: { type: "string" }
@@ -12766,6 +13122,7 @@ var qqbotPlugin = {
               enabled: { type: "boolean" },
               appId: { type: ["string", "number"] },
               clientSecret: { type: "string" },
+              streaming: { type: "boolean" },
               displayAliases: {
                 type: "object",
                 additionalProperties: { type: "string" }
@@ -12979,6 +13336,7 @@ var plugin = {
       defaultAccount: { type: "string" },
       appId: { type: ["string", "number"] },
       clientSecret: { type: "string" },
+      streaming: { type: "boolean" },
       displayAliases: {
         type: "object",
         additionalProperties: { type: "string" }
@@ -13033,6 +13391,7 @@ var plugin = {
             enabled: { type: "boolean" },
             appId: { type: ["string", "number"] },
             clientSecret: { type: "string" },
+            streaming: { type: "boolean" },
             displayAliases: {
               type: "object",
               additionalProperties: { type: "string" }