@baishuyun/coze-provider 0.0.17 → 0.1.0

package/src/coze-language-model.ts

@@ -14,6 +14,7 @@ import { CozeChatConfig, IGenerateResult } from './types';
 import { ServerSentEventTransformStream } from 'parse-sse';
 import { TextDecoderStream } from 'stream/web';
 import { convertPromptToMessages } from './utils/prompt-to-model-msg';
+import { accumulateSSEResponse } from './utils/accumulate-sse-response';
 import { createErrorStream } from './utils/create-error-stream';
 import { LLMChunkInjectorTransformStream } from './stream-trasnformer/llm-chunk-injector-transform-stream';
 import MCPChunkFilterTransformStream from './stream-trasnformer/mcp-chunk-filter-transform-stream';
@@ -39,26 +40,74 @@ export class CozeLanguageModel implements LanguageModelV2 {
     this.config = config;
   }
 
-  // @not-support
-  // coze 目前不支持非流式接口，为了兼容接口规范，仍然实现了 doGenerate 方法
   async doGenerate(options: LanguageModelV2CallOptions): Promise<IGenerateResult> {
-    return BuildWarningGenerateResult(
-      'Coze provider does not support non-streaming calls, please use streaming interface'
-    );
+    const messages = convertPromptToMessages(options.prompt);
+    const warnings: LanguageModelV2CallWarning[] = [];
+
+    const url = this.config.url({ path: '/chat' });
+
+    const user_id = options.headers ? options.headers['x-user-id'] : '';
+    const user_var = options.headers ? options.headers['x-user-var'] : '';
+
+    let customVar;
+    if (user_var) {
+      try {
+        customVar = JSON.parse(user_var);
+      } catch (e) {
+        console.warn('x-user-var parse error', e);
+      }
+    }
 
-    const botIdFromProvider = options.providerOptions?.bot?.botId;
-    if (!botIdFromProvider) {
-      return BuildWarningGenerateResult('bot id missing in provider options');
+    const body = {
+      bot_id: this.config.botId,
+      auto_save_history: false,
+      user_id: user_id || '7543191937730215936',
+      stream: true,
+      additional_messages: messages,
+    };
+
+    if (customVar) {
+      (body as any).custom_variables = customVar;
     }
 
-    const response = await createCozeNonStreamingChat(
-      botIdFromProvider as string,
-      options,
-      this.config
-    );
+    const headers = this.config.headers();
+    const abortSignal = options.abortSignal;
 
-    const result = await BuildGenerateResultByChatRes(response, this.config);
-    return result;
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: headers,
+      credentials: 'include',
+      body: JSON.stringify(body),
+      signal: abortSignal,
+    });
+
+    if (!response.ok || !response.body) {
+      const rawError = await response.text();
+      let errorDetail;
+      try {
+        errorDetail = JSON.parse(rawError);
+      } catch {
+        errorDetail = rawError;
+      }
+
+      const errorMessage =
+        typeof errorDetail === 'object' && errorDetail?.msg
+          ? errorDetail.msg
+          : `Coze API error: ${response.status} ${response.statusText}`;
+
+      return BuildWarningGenerateResult(errorMessage);
+    }
+
+    const { content, finishReason, usage } = await accumulateSSEResponse(response.body);
+
+    return {
+      content,
+      finishReason,
+      usage,
+      request: { body },
+      response: { body: null },
+      warnings,
+    };
   }
 
   isVisibleMsgPart(evtData: any) {
@@ -81,7 +130,7 @@ export class CozeLanguageModel implements LanguageModelV2 {
       path: '/chat',
     });
 
-    const user_id = (options.headers ? options.headers['x-user-id'] : '') || Date.now().toString();
+    const user_id = options.headers ? options.headers['x-user-id'] : '';
     const user_var = options.headers ? options.headers['x-user-var'] : '';
     // const user_token = options.headers ? options.headers['x-user-token'] : '';
 
@@ -97,22 +146,17 @@ export class CozeLanguageModel implements LanguageModelV2 {
     const body = {
       bot_id: this.config.botId,
       auto_save_history: false,
-      user_id: '7543191937730215936', // user_id,
+      user_id: user_id || '7543191937730215936',
       stream: true,
       additional_messages: messages,
     };
 
     if (customVar) {
-      (body as any).custom_var = customVar;
+      (body as any).custom_variables = customVar;
     }
 
     const headers = this.config.headers();
 
-    // console.log('Request headers for Coze API:', JSON.stringify(headers));
-    // console.log('Request body for Coze API:', JSON.stringify(body));
-    // console.log('Request URL for Coze API:', url);
-
-    // Support abort signal for proper cancellation when clients disconnect
     const abortSignal = options.abortSignal;
 
     const response = await fetch(url, {

package/src/stream-trasnformer/fields-json-transform-stream.ts

@@ -1,15 +1,18 @@
 import { LanguageModelV2StreamPart } from '@ai-sdk/provider';
 import { JSONParser } from '@streamparser/json';
-import { createTextInfoEnqueuer } from '../utils/enqueue-text-info';
+import { createTextInfoEnqueuer, TextInfoEnqueuer } from '../utils/enqueue-text-info';
 import { rebuildFieldsJsonStructure } from '../utils/fields-json-rebuild';
 
 export const createFieldsJsonTransformStream = (enableJsonParser: boolean) => {
   let parser: JSONParser;
+  let enqueueTextDelta: TextInfoEnqueuer;
   let id: string;
   let isFirstChunk = true;
+  // 当 LLM 返回的不是 JSON 而是普通文本时，切换到直通模式
+  let passthroughMode = false;
 
   const chunkGuard = (chunk: LanguageModelV2StreamPart): boolean => {
-    if (!enableJsonParser) {
+    if (!enableJsonParser || passthroughMode) {
       return false;
     }
 
@@ -33,12 +36,10 @@ export const createFieldsJsonTransformStream = (enableJsonParser: boolean) => {
       chunk: LanguageModelV2StreamPart,
       controller: TransformStreamDefaultController<LanguageModelV2StreamPart>
     ) => {
-      if (!parser) {
+      if (!parser && !passthroughMode) {
         return;
       }
 
-      // console.log("chunk arrived", chunk);
-
       try {
         if (chunkGuard(chunk)) {
           if ('id' in chunk && 'delta' in chunk) {
@@ -66,13 +67,10 @@ export const createFieldsJsonTransformStream = (enableJsonParser: boolean) => {
         paths: ['$.*'],
       });
 
-      const enqueueTextDelta = enableJsonParser
+      enqueueTextDelta = enableJsonParser
         ? createTextInfoEnqueuer(controller)
         : (content: string) => {};
 
-      // manualChunkForfieldsBeginTips(controller);
-      // enqueueTextDelta("开始构建字段");
-
       parser.onValue = (parsedInfo: any) => {
         const value = parsedInfo.value;
 
@@ -90,17 +88,11 @@ export const createFieldsJsonTransformStream = (enableJsonParser: boolean) => {
         );
       };
 
-      let errorLogged = false;
       parser.onError = (err: any) => {
-        if (!errorLogged) {
-          console.log('is enabled', enableJsonParser);
-          console.error('JsonWidgetStream: JSON Parsing Error:', err);
-          errorLogged = true;
-          // enqueueTextDelta('error', {
-          //   type: 'agent-error',
-          //   error: '操作超时，请刷新重试',
-          // });
-        }
+        console.error('JsonWidgetStream: JSON Parsing Error:', err);
+
+        // LLM 返回的不是 JSON，切换到直通模式，后续 text-delta 直接透传
+        passthroughMode = true;
       };
 
       parser.onEnd = () => {

package/src/utils/accumulate-sse-response.ts

@@ -0,0 +1,83 @@
+import {
+  LanguageModelV2Content,
+  LanguageModelV2FinishReason,
+  LanguageModelV2Usage,
+} from '@ai-sdk/provider';
+import { ServerSentEventTransformStream } from 'parse-sse';
+import { TextDecoderStream } from 'stream/web';
+
+export interface AccumulatedSSEResponse {
+  content: LanguageModelV2Content[];
+  finishReason: LanguageModelV2FinishReason;
+  usage: LanguageModelV2Usage;
+}
+
+/**
+ * 从字节流中解码 SSE 事件并累积完整响应内容
+ */
+export async function accumulateSSEResponse(
+  body: ReadableStream<Uint8Array>
+): Promise<AccumulatedSSEResponse> {
+  const sseStream = body
+    .pipeThrough(
+      new TextDecoderStream() as ReadableWritablePair<
+        string | undefined,
+        Uint8Array<ArrayBufferLike>
+      >
+    )
+    .pipeThrough(new ServerSentEventTransformStream());
+
+  let textContent = '';
+  let reasoningContent = '';
+  let finishReason: LanguageModelV2FinishReason = 'stop';
+  let usage: LanguageModelV2Usage = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
+
+  const reader = sseStream.getReader();
+  try {
+    while (true) {
+      const { done, value: evt } = await reader.read();
+      if (done) break;
+      if (!evt) continue;
+
+      let evtData;
+      try {
+        evtData = JSON.parse(evt.data);
+      } catch {
+        continue;
+      }
+
+      const event = evt.type;
+
+      if (event === 'conversation.message.delta') {
+        if (evtData.reasoning_content) {
+          reasoningContent += evtData.reasoning_content;
+        } else if (evtData.content) {
+          textContent += evtData.content;
+        }
+      } else if (event === 'conversation.chat.completed' || event === 'done') {
+        finishReason = 'stop';
+        if (evtData.usage) {
+          usage = {
+            inputTokens: evtData.usage.input_count || 0,
+            outputTokens: evtData.usage.output_count || 0,
+            totalTokens: evtData.usage.total_count || 0,
+          };
+        }
+      } else if (event === 'error') {
+        finishReason = 'error';
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+
+  const content: LanguageModelV2Content[] = [];
+  if (reasoningContent) {
+    content.push({ type: 'reasoning', text: reasoningContent });
+  }
+  if (textContent) {
+    content.push({ type: 'text', text: textContent });
+  }
+
+  return { content, finishReason, usage };
+}