@baishuyun/coze-provider 0.0.16 → 0.0.17

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

@@ -6,6 +6,7 @@ import { rebuildFieldsJsonStructure } from '../utils/fields-json-rebuild';
 export const createFieldsJsonTransformStream = (enableJsonParser: boolean) => {
   let parser: JSONParser;
   let id: string;
+  let isFirstChunk = true;
 
   const chunkGuard = (chunk: LanguageModelV2StreamPart): boolean => {
     if (!enableJsonParser) {
@@ -42,12 +43,21 @@ export const createFieldsJsonTransformStream = (enableJsonParser: boolean) => {
         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);
       }
     },
@@ -82,19 +92,15 @@ 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.log('is enabled', enableJsonParser);
           console.error('JsonWidgetStream: JSON Parsing Error:', err);
           errorLogged = true;
+          // enqueueTextDelta('error', {
+          //   type: 'agent-error',
+          //   error: '操作超时，请刷新重试',
+          // });
         }
-
-        enqueueTextDelta('error', {
-          type: 'agent-error',
-          error: '操作超时，请刷新重试',
-        });
       };
 
       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/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;
+};