feat/non streaming support

packages/frameworks/vue/src/chat/CustomModelProvider.ts

@@ -1,8 +1,7 @@
 import { BaseModelProvider, type ChatCompletionRequest, type ChatCompletionResponse } from '@opentiny/tiny-robot-kit';
 import { chat } from './chat-api';
 import type { IChatConfig, ICustomComponentItem, CustomFetch, ICustomActionItem } from './chat.types';
-import type { IGenPromptSnippet, IGenPromptExample } from '@opentiny/genui-sdk-core';
-import type { IChatMessage, IStreamData } from '@opentiny/genui-sdk-core';
+import type { IGenPromptSnippet, IGenPromptExample, IChatMessage, IStreamData, IStreamDelta } from '@opentiny/genui-sdk-core';
 import type { IResponseHandler } from './response-handler';
 
 async function readChunk(reader: ReadableStreamDefaultReader<Uint8Array>, handler: (data: string) => void) {
@@ -73,6 +72,7 @@ export class CustomModelProvider extends BaseModelProvider {
       model,
       temperature,
       signal: request.options?.signal,
+      stream: request.options?.stream ?? true,
       customComponents,
       customSnippets,
       customExamples,
@@ -81,8 +81,103 @@ export class CustomModelProvider extends BaseModelProvider {
     });
   }
 
-  async chat(_: ChatCompletionRequest) {
-    return {} as ChatCompletionResponse;
+  async chat(request: ChatCompletionRequest): Promise<ChatCompletionResponse> {
+    let response: Response;
+    try {
+      response = await this.getData(request);
+    } catch (error) {
+      throw error;
+    }
+    const json = await response.json();
+
+    // 将非流式伪装成流式
+    const chatMessage = this.buildChatMessageFromResponse(json, request);
+
+    const choice = json.choices?.[0] ?? {};
+    const message = choice.message ?? {};
+
+    return {
+      id: json.id,
+      object: json.object ?? 'chat.completion',
+      created: json.created,
+      model: json.model,
+      choices: [
+        {
+          index: 0,
+          message: {
+            role: 'assistant',
+            content: chatMessage.content,
+            reasoning_content: message.reasoning_content,
+            tool_calls: message.tool_calls,
+          },
+          finish_reason: choice.finish_reason ?? 'stop',
+        },
+      ],
+      usage: json.usage,
+      role: chatMessage.role,
+      content: chatMessage.content,
+      messages: chatMessage.messages,
+      finishInfo: chatMessage.finishInfo,
+    } as ChatCompletionResponse & IChatMessage;
+  }
+
+  private buildChatMessageFromResponse(json: any, request: ChatCompletionRequest): IChatMessage {
+    const message = json.choices?.[0]?.message ?? {};
+
+    const context: any = {};
+    this.setupStreamContext(context, request);
+
+    let chatMessage!: IChatMessage;
+    this.handlerStart(context, {
+      onData: (data: IChatMessage) => {
+        chatMessage = data;
+      },
+      onDone: () => {},
+      onError: () => {},
+    });
+
+    const base = {
+      id: json.id,
+      object: 'chat.completion.chunk',
+      model: json.model,
+      created: json.created,
+    };
+
+    const deltas: IStreamDelta[] = [];
+    if (message.reasoning_content) {
+      deltas.push({ reasoning_content: message.reasoning_content });
+    }
+    if (message.tool_calls?.length) {
+      deltas.push({ tool_calls: message.tool_calls });
+    }
+    if (message.tool_calls_result?.length) {
+      deltas.push({ tool_calls_result: message.tool_calls_result });
+    }
+    if (message.content) {
+      deltas.push({ content: message.content });
+    }
+    for (const delta of deltas) {
+      this.handlerChunk(
+        JSON.stringify({
+          ...base,
+          choices: [{ index: 0, delta, finish_reason: null }],
+        }),
+        context,
+      );
+    }
+
+    this.handlerChunk(
+      JSON.stringify({
+        ...base,
+        choices: [{ index: 0, delta: {}, finish_reason: json.choices?.[0]?.finish_reason ?? 'stop' }],
+        usage: json.usage,
+      }),
+      context,
+    );
+
+    this.handlerEnd(context);
+
+    return chatMessage;
   }
 
   async chatStream(request: any, handler: { onData: any; onDone: any; onError: any }) {

packages/frameworks/vue/src/chat/GenuiChat.vue

@@ -257,6 +257,7 @@ const client = new AIClient({
 let conversation = useConversation({
   client,
   autoSave: false,
+  useStreamByDefault: props.stream ?? true,
   events: {
     onReceiveData(data, messages, preventDefault) {
       messages.value.push(data as any);

packages/frameworks/vue/src/chat/chat-api.ts

@@ -27,14 +27,15 @@ export const chat = async (
     model: string,
     temperature: number,
     signal: any,
+    stream: boolean,
     customComponents: ICustomComponentItem[],
     customSnippets: IGenPromptSnippet[],
     customExamples: IGenPromptExample[],
     customActions: ICustomActionItem[],
     customFetch?: CustomFetch,
   }
 ) => {
-  const { url, messages, model, temperature, signal, customComponents, customSnippets, customExamples, customActions, customFetch } = chatOptions;
+  const { url, messages, model, temperature, signal, stream, customComponents, customSnippets, customExamples, customActions, customFetch } = chatOptions;
   const tgCustomConfig = {
     customComponents: removeRefFromCustomComponents(customComponents),
     customSnippets: customSnippets,
@@ -56,6 +57,7 @@ export const chat = async (
       messages: messages,
       model: model,
       temperature: temperature,
+      stream: stream ?? true,
       metadata: requestMetadata,
     }),
   };

packages/frameworks/vue/src/chat/chat.types.ts

@@ -87,6 +87,7 @@ export interface IChatProps {
   url?: string;
   model?: string;
   temperature?: number;
+  stream?: boolean;
   messages?: IMessage[];
   chatConfig?: IChatConfig;
   requiredCompleteFieldSelectors?: string[];

packages/frameworks/vue/src/chat/tiny-robot-patch/useMessage.ts

@@ -127,6 +127,17 @@ export function useMessage(options: UseMessageOptions): UseMessageReturn {
     });
 
     chatOnReceiveData(response);
+
+    const onFinish = options.events?.onFinish;
+    let defaultPrevented = false;
+    if (onFinish) {
+      onFinish(response.choices?.[0]?.finish_reason ?? 'stop', { messages, messageState }, () => {
+        defaultPrevented = true;
+      });
+    }
+    if (!defaultPrevented && messageState.status !== STATUS.ABORTED) {
+      messageState.status = STATUS.FINISHED;
+    }
   };
 
   const streamChatOnReceiveData = (data: ChatCompletionStreamResponse) => {

sites/playground/server/src/chat-genui.ts

@@ -1,5 +1,5 @@
 import { type Request, type Response } from 'express';
-import { streamText, stepCountIs, tool } from 'ai';
+import { streamText, generateText, stepCountIs, tool, type GenerateTextResult, type ToolSet } from 'ai';
 import getRawBody from 'raw-body';
 import fs from 'node:fs/promises';
 import path from 'node:path';
@@ -31,6 +31,80 @@ type StreamTextOptions = Parameters<typeof streamText>[0];
 
 const BUSY_ERROR_MESSAGE = '算力繁忙，请切换其他模型或稍后重试';
 
+function buildCompletionFromGenerateText(result: GenerateTextResult<any, any>): any {
+  const message: any = { role: 'assistant', content: '' };
+  const reasoningParts: string[] = [];
+  const toolCalls: any[] = [];
+  const toolResults: any[] = [];
+
+  for (const step of result.steps) {
+    if (step.reasoningText) reasoningParts.push(step.reasoningText);
+    if (step.text) message.content += step.text;
+    for (const toolCall of step.toolCalls) {
+      toolCalls.push({
+        id: toolCall.toolCallId,
+        type: 'function',
+        function: {
+          name: toolCall.toolName,
+          arguments: stringifyToolInput(toolCall.input),
+        },
+      });
+    }
+    for (const toolResult of step.toolResults) {
+      toolResults.push({
+        id: toolResult.toolCallId,
+        type: 'function',
+        function: {
+          name: toolResult.toolName,
+          arguments: stringifyToolInput(toolResult.input),
+          result: toolResult.output,
+        },
+      });
+    }
+  }
+
+  if (reasoningParts.length) message.reasoning_content = reasoningParts.join('');
+  if (toolCalls.length) message.tool_calls = toolCalls;
+  if (toolResults.length) message.tool_calls_result = toolResults;
+
+  const { inputTokens, outputTokens, totalTokens } = result.totalUsage;
+  return {
+    id: result.response?.id ?? `chatcmpl-${Date.now()}`,
+    object: 'chat.completion',
+    created: Date.now(),
+    model: result.response?.modelId ?? '',
+    choices: [
+      {
+        index: 0,
+        message,
+        finish_reason: mapFinishReason(result.finishReason),
+      },
+    ],
+    usage: {
+      prompt_tokens: inputTokens,
+      completion_tokens: outputTokens,
+      total_tokens: totalTokens,
+    },
+  };
+}
+
+/** 工具入参序列化为 OpenAI 协议要求的 JSON 字符串 */
+function stringifyToolInput(input: unknown): string {
+  if (typeof input === 'string') return input;
+  try {
+    return JSON.stringify(input ?? {});
+  } catch {
+    return '{}';
+  }
+}
+
+/** AI SDK 的 finishReason 映射为 OpenAI 协议的取值 */
+function mapFinishReason(finishReason: string): string {
+  if (finishReason === 'tool-calls') return 'tool_calls';
+  if (finishReason === 'content-filter') return 'content_filter';
+  return finishReason;
+}
+
 function extractStatusCode(error: any): number | undefined {
   if (!error) {
     return undefined;
@@ -246,6 +320,7 @@ export function createChatGenui() {
   const chatGenuiHandler = async (req: Request, res: Response): Promise<void> => {
     const abort = new AbortController();
     const body = JSON.parse(await getRawBody(req, { encoding: 'utf-8' }));
+    const isStreaming = body.stream !== false;
     if (process.env.CHAT_UI_REPLAY_MODE === 'true') {
       res.setHeader('Content-Type', 'text/event-stream');
       const text = await fs.readFile(path.join(fileURLToPath(import.meta.url), '../replay/replay.txt'), 'utf-8');
@@ -387,6 +462,36 @@ export function createChatGenui() {
       }
     });
 
+    if (!isStreaming) {
+      const generateOptions = {
+        model: model!,
+        temperature,
+        system: options.system,
+        messages: options.messages,
+        abortSignal: abort.signal,
+        tools: tools as ToolSet,
+        toolChoice: 'auto' as const,
+        stopWhen: stepCountIs(maxSteps),
+        ...(providerOptions ? { providerOptions } : {}),
+      };
+
+      try {
+        const result = await generateText(generateOptions);
+        if (abort.signal.aborted) {
+          res.status(499).json({ message: 'Request aborted', type: 'AbortedError', param: null, code: 499 });
+          return;
+        }
+        res.json(buildCompletionFromGenerateText(result));
+      } catch (error: any) {
+        const statusCode = error?.statusCode ?? 500;
+        const message = error?.message || 'Internal Server Error';
+        console.error('Error in chat-genui generateText:', error);
+        const errorResponse = { message, type: 'Internal Server Error', param: null, code: 'Internal Server Error' };
+        res.status(statusCode).json(errorResponse);
+      }
+      return;
+    }
+
     try {
       const stream = streamText(options);
 

sites/playground/web/src/views/ChatView.vue

@@ -33,6 +33,7 @@ const rendererSlots = {
   <PlaygroundViewShell>
     <GenuiConfigProvider :theme="theme" :locale="locale" :materials="materials" style="height: 100%">
       <GenuiChat
+        :stream="false"
         :url="url"
         :ref="setChatRef"
         :messages="messages"