@baishuyun/coze-provider 0.0.16 → 0.1.0

package/src/coze-language-model.ts

@@ -10,14 +10,20 @@ import {
   SharedV2Headers,
   SharedV2ProviderMetadata,
 } from '@ai-sdk/provider';
-import { CozeChatConfig } from './types';
+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';
 import LLMPartTrasnformStream from './stream-trasnformer/llm-part-transform-stream';
+import { createCozeNonStreamingChat } from './utils/create-coze-non-streaming-chat';
+import {
+  BuildGenerateResultByChatRes,
+  BuildWarningGenerateResult,
+} from './utils/build-generate-result-by-chat-res';
 
 export class CozeLanguageModel implements LanguageModelV2 {
   specificationVersion: 'v2' = 'v2';
@@ -34,19 +40,74 @@ export class CozeLanguageModel implements LanguageModelV2 {
     this.config = config;
   }
 
-  doGenerate(options: LanguageModelV2CallOptions): PromiseLike<{
-    content: Array<LanguageModelV2Content>;
-    finishReason: LanguageModelV2FinishReason;
-    usage: LanguageModelV2Usage;
-    providerMetadata?: SharedV2ProviderMetadata;
-    request?: { body?: unknown };
-    response?: LanguageModelV2ResponseMetadata & {
-      headers?: SharedV2Headers;
-      body?: unknown;
+  async doGenerate(options: LanguageModelV2CallOptions): Promise<IGenerateResult> {
+    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 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 headers = this.config.headers();
+    const abortSignal = options.abortSignal;
+
+    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,
     };
-    warnings: Array<LanguageModelV2CallWarning>;
-  }> {
-    throw new Error('Method not implemented.');
   }
 
   isVisibleMsgPart(evtData: any) {
@@ -69,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'] : '';
 
@@ -85,20 +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,
     };
 
-    console.log('Request body for Coze API:', JSON.stringify(body));
-
     if (customVar) {
-      (body as any).custom_var = customVar;
+      (body as any).custom_variables = customVar;
     }
 
     const headers = this.config.headers();
 
-    // 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,14 +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;
     }
 
@@ -32,22 +36,29 @@ 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) {
             id = chunk.id;
-            parser.write(chunk.delta);
+            let delta = chunk.delta;
+            if (isFirstChunk) {
+              delta = delta.replace(/^\uFEFF/, '');
+              isFirstChunk = false;
+            }
+            parser.write(delta);
+          } else {
+            console.warn('Unexpected chunk format for JSON parsing:', chunk);
+            controller.enqueue(chunk);
           }
         } else {
           controller.enqueue(chunk);
         }
       } catch (e) {
+        console.log('write or enqueue error', e);
         controller.error(e);
       }
     },
@@ -56,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;
 
@@ -80,21 +88,11 @@ export const createFieldsJsonTransformStream = (enableJsonParser: boolean) => {
         );
       };
 
-      let errorLogged = false;
       parser.onError = (err: any) => {
-        // controller.enqueue({
-        //   type: "error",
-        //   error: "JsonWidgetStream: JSON Parsing Error:" + err.message,
-        // });
-        if (!errorLogged) {
-          console.error('JsonWidgetStream: JSON Parsing Error:', err);
-          errorLogged = true;
-        }
+        console.error('JsonWidgetStream: JSON Parsing Error:', err);
 
-        enqueueTextDelta('error', {
-          type: 'agent-error',
-          error: '操作超时，请刷新重试',
-        });
+        // LLM 返回的不是 JSON，切换到直通模式，后续 text-delta 直接透传
+        passthroughMode = true;
       };
 
       parser.onEnd = () => {

package/src/types.ts

@@ -1,6 +1,16 @@
-import { LanguageModelV2, LanguageModelV2StreamPart } from '@ai-sdk/provider';
+import {
+  LanguageModelV2,
+  LanguageModelV2CallWarning,
+  LanguageModelV2Content,
+  LanguageModelV2FinishReason,
+  LanguageModelV2ResponseMetadata,
+  LanguageModelV2StreamPart,
+  LanguageModelV2Usage,
+  SharedV2Headers,
+  SharedV2ProviderMetadata,
+} from '@ai-sdk/provider';
 import { FetchFunction } from '@ai-sdk/provider-utils';
-import { ChatEventType } from '@coze/api';
+import { ChatEventType, CreateChatData } from '@coze/api';
 
 export type CozeChatModelId = 'chat';
 
@@ -24,3 +34,16 @@ export interface McpSSE {
   type: string;
   data: string;
 }
+
+export interface IGenerateResult {
+  content: Array<LanguageModelV2Content>;
+  finishReason: LanguageModelV2FinishReason;
+  usage: LanguageModelV2Usage;
+  providerMetadata?: SharedV2ProviderMetadata;
+  request?: { body?: unknown };
+  response?: LanguageModelV2ResponseMetadata & {
+    headers?: SharedV2Headers;
+    body?: unknown;
+  };
+  warnings: Array<LanguageModelV2CallWarning>;
+}

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 };
+}

package/src/utils/build-generate-result-by-chat-res.ts

@@ -0,0 +1,71 @@
+import { CreateChatRes } from '@coze/api';
+import { CozeChatConfig, IGenerateResult } from '../types';
+import { getCozeChatMsgDetail } from './get-coze-chat-msg-detail';
+
+export const BuildWarningGenerateResult = (message: string): IGenerateResult => {
+  return {
+    content: [],
+    finishReason: 'error',
+    request: {
+      body: null,
+    },
+    usage: {
+      inputTokens: 0,
+      outputTokens: 0,
+      totalTokens: 0,
+    },
+    response: {
+      body: null,
+    },
+    warnings: [
+      {
+        type: 'other',
+        message,
+      },
+    ],
+  };
+};
+
+export const BuildGenerateResultByChatRes = async (
+  response: Response,
+  chatConfig: CozeChatConfig,
+  reqBody?: unknown
+): Promise<IGenerateResult> => {
+  if (!response.ok) {
+    return Promise.reject(
+      BuildWarningGenerateResult(`Coze API error: ${response.status} ${response.statusText}`)
+    );
+  }
+
+  const res = (await response.json()) as CreateChatRes;
+  if (res.code !== 0) {
+    return Promise.reject(BuildWarningGenerateResult(`Coze API error: ${res.code} ${res.msg}`));
+  }
+
+  const msgRes = await getCozeChatMsgDetail(res.data.conversation_id, res.data.id, chatConfig);
+  if (!msgRes.ok) {
+    return Promise.reject(
+      BuildWarningGenerateResult(
+        `Failed to get message detail: ${msgRes.status} ${msgRes.statusText}`
+      )
+    );
+  }
+  const msgDetail = await msgRes.json();
+
+  return {
+    content: msgDetail.data.message.content,
+    finishReason: msgDetail.data.message.status === 'finished' ? 'stop' : 'error',
+    request: {
+      body: reqBody,
+    },
+    usage: {
+      inputTokens: 0,
+      outputTokens: 0,
+      totalTokens: 0,
+    },
+    response: {
+      body: msgDetail,
+    },
+    warnings: [],
+  };
+};

package/src/utils/create-coze-non-streaming-chat.ts

@@ -0,0 +1,54 @@
+import { LanguageModelV2CallOptions, LanguageModelV2CallWarning } from '@ai-sdk/provider';
+import { CozeChatConfig } from '../types';
+import { convertPromptToMessages } from './prompt-to-model-msg';
+
+export const createCozeNonStreamingChat = async (
+  botId: string,
+  options: LanguageModelV2CallOptions,
+  chatConfig: CozeChatConfig
+) => {
+  const messages = convertPromptToMessages(options.prompt);
+
+  const url = chatConfig.url({
+    path: '/chat',
+  });
+
+  const user_id = (options.headers ? options.headers['x-user-id'] : '') || Date.now().toString();
+  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 body = {
+    bot_id: botId,
+    auto_save_history: true,
+    user_id: user_id || '7543191937730215936',
+    additional_messages: messages,
+    stream: false,
+  };
+
+  if (customVar) {
+    (body as any).custom_var = customVar;
+  }
+
+  const headers = chatConfig.headers();
+
+  // Support abort signal for proper cancellation when clients disconnect
+  const abortSignal = options.abortSignal;
+
+  const response = await fetch(url, {
+    method: 'POST',
+    headers: headers,
+    credentials: 'include',
+    body: JSON.stringify(body),
+    signal: abortSignal,
+  });
+
+  return response;
+};

package/src/utils/fields-json-rebuild/index.ts

@@ -55,6 +55,9 @@ const RebuilderMap: Record<FieldType, (origin: unknown) => unknown> = {
   dept: rebuildDept,
   sn: rebuildSn,
   deptgroup: rebuildDeptGroup,
+  flowState: defaultBuilder,
+  flowstate: defaultBuilder,
+  formula: defaultBuilder,
   unknown: defaultBuilder,
 };
 

package/src/utils/get-coze-chat-msg-detail.ts

@@ -0,0 +1,19 @@
+import { CozeChatConfig } from '../types';
+
+export const getCozeChatMsgDetail = async (
+  conversationId: string,
+  chatId: string,
+  chatConfig: CozeChatConfig
+) => {
+  const url = chatConfig.url({
+    path: `/chat/message/list?conversation_id=${conversationId}&chat_id=${chatId}`,
+  });
+
+  const response = await fetch(url, {
+    method: 'POST',
+    headers: chatConfig.headers(),
+    credentials: 'include',
+  });
+
+  return response;
+};