@lobehub/lobehub 2.0.0-next.100 → 2.0.0-next.102

package/packages/model-bank/src/const/modelProvider.ts

@@ -64,6 +64,7 @@ export enum ModelProvider {
   Wenxin = 'wenxin',
   XAI = 'xai',
   Xinference = 'xinference',
+  ZenMux = 'zenmux',
   ZeroOne = 'zeroone',
   ZhiPu = 'zhipu',
 }

package/packages/model-bank/src/standard-parameters/index.ts

@@ -149,6 +149,15 @@ export const ModelParamsMetaSchema = z.object({
     })
     .optional(),
 
+  resolution: z
+    .object({
+      default: z.string(),
+      description: z.string().optional(),
+      enum: z.array(z.string()),
+      type: z.literal('string').optional(),
+    })
+    .optional(),
+
   cfg: z
     .object({
       default: z.number(),

package/packages/model-runtime/src/core/RouterRuntime/createRuntime.ts

@@ -148,10 +148,9 @@ export const createRouterRuntime = ({
     }
 
     /**
-     * TODO: 考虑添加缓存机制，避免重复创建相同配置的 runtimes
+     * Resolve routers configuration and validate
      */
-    private async createRuntimesByRouters(model?: string): Promise<RuntimeItem[]> {
-      // 动态获取 routers，支持传入 model
+    private async resolveRouters(model?: string): Promise<RouterInstance[]> {
       const resolvedRouters =
         typeof this._routers === 'function'
           ? await this._routers(this._options, { model })
@@ -161,6 +160,41 @@ export const createRouterRuntime = ({
         throw new Error('empty providers');
       }
 
+      return resolvedRouters;
+    }
+
+    /**
+     * Create runtime for inference requests (chat, generateObject, etc.)
+     * Finds the router that matches the model, or uses the last router as fallback
+     */
+    private async createRuntimeForInference(model: string): Promise<RuntimeItem> {
+      const resolvedRouters = await this.resolveRouters(model);
+
+      const matchedRouter =
+        resolvedRouters.find((router) => {
+          if (router.models && router.models.length > 0) {
+            return router.models.includes(model);
+          }
+          return false;
+        }) ?? resolvedRouters.at(-1)!;
+
+      const providerAI =
+        matchedRouter.runtime ?? baseRuntimeMap[matchedRouter.apiType] ?? LobeOpenAI;
+      const finalOptions = { ...this._params, ...this._options, ...matchedRouter.options };
+      const runtime: LobeRuntimeAI = new providerAI({ ...finalOptions, id: this._id });
+
+      return {
+        id: matchedRouter.apiType,
+        models: matchedRouter.models,
+        runtime,
+      };
+    }
+
+    /**
+     * Create all runtimes for listing models
+     */
+    private async createRuntimes(): Promise<RuntimeItem[]> {
+      const resolvedRouters = await this.resolveRouters();
       return resolvedRouters.map((router) => {
         const providerAI = router.runtime ?? baseRuntimeMap[router.apiType] ?? LobeOpenAI;
         const finalOptions = { ...this._params, ...this._options, ...router.options };
@@ -176,16 +210,8 @@ export const createRouterRuntime = ({
 
     // Check if it can match a specific model, otherwise default to using the last runtime
     async getRuntimeByModel(model: string) {
-      const runtimes = await this.createRuntimesByRouters(model);
-
-      for (const runtimeItem of runtimes) {
-        const models = runtimeItem.models || [];
-        if (models.includes(model)) {
-          return runtimeItem.runtime;
-        }
-      }
-
-      return runtimes.at(-1)!.runtime;
+      const runtimeItem = await this.createRuntimeForInference(model);
+      return runtimeItem.runtime;
     }
 
     async chat(payload: ChatStreamPayload, options?: ChatMethodOptions) {
@@ -222,9 +248,8 @@ export const createRouterRuntime = ({
 
     async models() {
       if (modelsOption && typeof modelsOption === 'function') {
-        // 延迟创建 runtimes
-        const runtimes = await this.createRuntimesByRouters();
-        // 如果是函数式配置，使用最后一个运行时的客户端来调用函数
+        const runtimes = await this.createRuntimes();
+        // If it's a functional configuration, use the last runtime's client to call the function
         const lastRuntime = runtimes.at(-1)?.runtime;
         if (lastRuntime && 'client' in lastRuntime) {
           const modelList = await modelsOption({ client: (lastRuntime as any).client });
@@ -232,8 +257,7 @@ export const createRouterRuntime = ({
         }
       }
 
-      // 延迟创建 runtimes
-      const runtimes = await this.createRuntimesByRouters();
+      const runtimes = await this.createRuntimes();
       return runtimes.at(-1)?.runtime.models?.();
     }
 

package/packages/model-runtime/src/core/openaiCompatibleFactory/index.test.ts

@@ -426,7 +426,7 @@ describe('LobeOpenAICompatibleFactory', () => {
           'data: "Hello"\n\n',
           'id: a\n',
           'event: usage\n',
-          'data: {"inputTextTokens":5,"outputTextTokens":5,"totalInputTokens":5,"totalOutputTokens":5,"totalTokens":10}\n\n',
+          'data: {"inputTextTokens":5,"outputTextTokens":5,"totalInputTokens":5,"totalOutputTokens":5,"totalTokens":10,"cost":0.000005}\n\n',
           'id: output_speed\n',
           'event: speed\n',
           expect.stringMatching(/^data: {.*"tps":.*,"ttft":.*}\n\n$/), // tps ttft should be calculated with elapsed time
@@ -601,7 +601,7 @@ describe('LobeOpenAICompatibleFactory', () => {
             signal: controller.signal,
           }),
         );
-      });
+      }, 10000);
     });
 
     describe('Error', () => {

package/packages/model-runtime/src/core/streams/bedrock/claude.ts

@@ -7,18 +7,32 @@ import {
   StreamContext,
   createCallbacksTransformer,
   createSSEProtocolTransformer,
+  createTokenSpeedCalculator,
 } from '../protocol';
 import { createBedrockStream } from './common';
 
 export const AWSBedrockClaudeStream = (
   res: InvokeModelWithResponseStreamResponse | ReadableStream,
-  cb?: ChatStreamCallbacks,
+  options?: {
+    callbacks?: ChatStreamCallbacks;
+    inputStartAt?: number;
+    payload?: Parameters<typeof transformAnthropicStream>[2];
+  },
 ): ReadableStream<string> => {
   const streamStack: StreamContext = { id: 'chat_' + nanoid() };
 
   const stream = res instanceof ReadableStream ? res : createBedrockStream(res);
 
+  const transformWithPayload: typeof transformAnthropicStream = (chunk, ctx) =>
+    transformAnthropicStream(chunk, ctx, options?.payload);
+
   return stream
-    .pipeThrough(createSSEProtocolTransformer(transformAnthropicStream, streamStack))
-    .pipeThrough(createCallbacksTransformer(cb));
+    .pipeThrough(
+      createTokenSpeedCalculator(transformWithPayload, {
+        inputStartAt: options?.inputStartAt,
+        streamStack,
+      }),
+    )
+    .pipeThrough(createSSEProtocolTransformer((c) => c, streamStack))
+    .pipeThrough(createCallbacksTransformer(options?.callbacks));
 };

package/packages/model-runtime/src/core/streams/google/index.ts

@@ -148,7 +148,8 @@ const transformGoogleGenerativeAIStream = (
 
     // Check for image data before handling finishReason
     if (Array.isArray(candidate.content?.parts) && candidate.content.parts.length > 0) {
-      const part = candidate.content.parts[0];
+      // Filter out reasoning content and get first non-reasoning part
+      const part = candidate.content.parts.find((p: any) => !p.thought);
 
       if (part && part.inlineData && part.inlineData.data && part.inlineData.mimeType) {
         const imageChunk = {
@@ -182,7 +183,11 @@ const transformGoogleGenerativeAIStream = (
           ...usageChunks,
         ].filter(Boolean) as StreamProtocolChunk[];
       }
-      return { data: candidate.finishReason, id: context?.id, type: 'stop' };
+      // 当有 finishReason 但没有 text 内容时,发送一个空的 text 块以停止加载动画
+      return [
+        { data: '', id: context?.id, type: 'text' },
+        { data: candidate.finishReason, id: context?.id, type: 'stop' },
+      ];
     }
 
     if (!!text?.trim()) return { data: text, id: context?.id, type: 'text' };