@lobehub/chat 1.136.12 → 1.136.13

package/packages/model-runtime/src/providers/anthropic/generateObject.test.ts

@@ -12,7 +12,7 @@ describe('Anthropic generateObject', () => {
             content: [
               {
                 type: 'tool_use',
-                name: 'structured_output',
+                name: 'person_extractor',
                 input: { name: 'John', age: 30 },
               },
             ],
@@ -23,8 +23,13 @@ describe('Anthropic generateObject', () => {
       const payload = {
         messages: [{ content: 'Generate a person object', role: 'user' as const }],
         schema: {
-          type: 'object',
-          properties: { name: { type: 'string' }, age: { type: 'number' } },
+          name: 'person_extractor',
+          description: 'Extract person information',
+          schema: {
+            type: 'object' as const,
+            properties: { name: { type: 'string' }, age: { type: 'number' } },
+            required: ['name', 'age'],
+          },
         },
         model: 'claude-3-5-sonnet-20241022',
       };
@@ -35,30 +40,24 @@ describe('Anthropic generateObject', () => {
         expect.objectContaining({
           model: 'claude-3-5-sonnet-20241022',
           max_tokens: 8192,
-          messages: [
-            { content: 'Generate a person object', role: 'user' },
-            {
-              content:
-                'Please use the structured_output tool to provide your response in the required format.',
-              role: 'user',
-            },
-          ],
+          messages: [{ content: 'Generate a person object', role: 'user' }],
           tools: [
             {
-              name: 'structured_output',
-              description: 'Generate structured output according to the provided schema',
+              name: 'person_extractor',
+              description: 'Extract person information',
               input_schema: {
                 type: 'object',
                 properties: {
                   name: { type: 'string' },
                   age: { type: 'number' },
                 },
+                required: ['name', 'age'],
               },
             },
           ],
           tool_choice: {
             type: 'tool',
-            name: 'structured_output',
+            name: 'person_extractor',
           },
         }),
         expect.objectContaining({}),
@@ -74,7 +73,7 @@ describe('Anthropic generateObject', () => {
             content: [
               {
                 type: 'tool_use',
-                name: 'structured_output',
+                name: 'status_extractor',
                 input: { status: 'success' },
               },
             ],
@@ -87,7 +86,10 @@ describe('Anthropic generateObject', () => {
           { content: 'You are a helpful assistant', role: 'system' as const },
           { content: 'Generate status', role: 'user' as const },
         ],
-        schema: { type: 'object', properties: { status: { type: 'string' } } },
+        schema: {
+          name: 'status_extractor',
+          schema: { type: 'object' as const, properties: { status: { type: 'string' } } },
+        },
         model: 'claude-3-5-sonnet-20241022',
       };
 
@@ -111,7 +113,7 @@ describe('Anthropic generateObject', () => {
             content: [
               {
                 type: 'tool_use',
-                name: 'structured_output',
+                name: 'data_extractor',
                 input: { data: 'test' },
               },
             ],
@@ -121,7 +123,10 @@ describe('Anthropic generateObject', () => {
 
       const payload = {
         messages: [{ content: 'Generate data', role: 'user' as const }],
-        schema: { type: 'object', properties: { data: { type: 'string' } } },
+        schema: {
+          name: 'data_extractor',
+          schema: { type: 'object' as const, properties: { data: { type: 'string' } } },
+        },
         model: 'claude-3-5-sonnet-20241022',
       };
 
@@ -155,20 +160,18 @@ describe('Anthropic generateObject', () => {
         },
       };
 
-      const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
-
       const payload = {
         messages: [{ content: 'Generate data', role: 'user' as const }],
-        schema: { type: 'object' },
+        schema: {
+          name: 'test_tool',
+          schema: { type: 'object' },
+        },
         model: 'claude-3-5-sonnet-20241022',
       };
 
-      const result = await createAnthropicGenerateObject(mockClient as any, payload);
+      const result = await createAnthropicGenerateObject(mockClient as any, payload as any);
 
-      expect(consoleSpy).toHaveBeenCalledWith('No structured output tool use found in response');
       expect(result).toBeUndefined();
-
-      consoleSpy.mockRestore();
     });
 
     it('should handle complex nested schemas', async () => {
@@ -178,7 +181,7 @@ describe('Anthropic generateObject', () => {
             content: [
               {
                 type: 'tool_use',
-                name: 'structured_output',
+                name: 'user_extractor',
                 input: {
                   user: {
                     name: 'Alice',
@@ -200,22 +203,26 @@ describe('Anthropic generateObject', () => {
       const payload = {
         messages: [{ content: 'Generate complex user data', role: 'user' as const }],
         schema: {
-          type: 'object',
-          properties: {
-            user: {
-              type: 'object',
-              properties: {
-                name: { type: 'string' },
-                profile: {
-                  type: 'object',
-                  properties: {
-                    age: { type: 'number' },
-                    preferences: { type: 'array', items: { type: 'string' } },
+          name: 'user_extractor',
+          description: 'Extract complex user information',
+          schema: {
+            type: 'object' as const,
+            properties: {
+              user: {
+                type: 'object',
+                properties: {
+                  name: { type: 'string' },
+                  profile: {
+                    type: 'object',
+                    properties: {
+                      age: { type: 'number' },
+                      preferences: { type: 'array', items: { type: 'string' } },
+                    },
                   },
                 },
               },
+              metadata: { type: 'object' },
             },
-            metadata: { type: 'object' },
           },
         },
         model: 'claude-3-5-sonnet-20241022',
@@ -248,13 +255,16 @@ describe('Anthropic generateObject', () => {
 
       const payload = {
         messages: [{ content: 'Generate data', role: 'user' as const }],
-        schema: { type: 'object' },
+        schema: {
+          name: 'test_tool',
+          schema: { type: 'object' },
+        },
         model: 'claude-3-5-sonnet-20241022',
       };
 
-      await expect(createAnthropicGenerateObject(mockClient as any, payload)).rejects.toThrow(
-        'API Error: Model not found',
-      );
+      await expect(
+        createAnthropicGenerateObject(mockClient as any, payload as any),
+      ).rejects.toThrow('API Error: Model not found');
     });
 
     it('should handle abort signals correctly', async () => {
@@ -269,7 +279,10 @@ describe('Anthropic generateObject', () => {
 
       const payload = {
         messages: [{ content: 'Generate data', role: 'user' as const }],
-        schema: { type: 'object' },
+        schema: {
+          name: 'test_tool',
+          schema: { type: 'object' },
+        },
         model: 'claude-3-5-sonnet-20241022',
       };
 
@@ -278,7 +291,7 @@ describe('Anthropic generateObject', () => {
       };
 
       await expect(
-        createAnthropicGenerateObject(mockClient as any, payload, options),
+        createAnthropicGenerateObject(mockClient as any, payload as any, options),
       ).rejects.toThrow();
     });
   });

package/packages/model-runtime/src/providers/anthropic/generateObject.ts

@@ -1,8 +1,11 @@
-import Anthropic from '@anthropic-ai/sdk';
+import type Anthropic from '@anthropic-ai/sdk';
+import debug from 'debug';
 
 import { buildAnthropicMessages } from '../../core/contextBuilders/anthropic';
 import { GenerateObjectOptions, GenerateObjectPayload } from '../../types';
 
+const log = debug('lobe-model-runtime:anthropic:generate-object');
+
 /**
  * Generate structured output using Anthropic Claude API with Function Calling
  */
@@ -13,26 +16,25 @@ export const createAnthropicGenerateObject = async (
 ) => {
   const { schema, messages, model } = payload;
 
-  // Convert OpenAI schema to Anthropic tool format
-  const tool = {
-    description: 'Generate structured output according to the provided schema',
-    input_schema: schema,
-    name: 'structured_output',
+  log('generateObject called with model: %s', model);
+  log('schema: %O', schema);
+  log('messages count: %d', messages.length);
+
+  // Convert OpenAI-style schema to Anthropic tool format
+  const tool: Anthropic.ToolUnion = {
+    description:
+      schema.description || 'Generate structured output according to the provided schema',
+    input_schema: schema.schema as any,
+    name: schema.name || 'structured_output',
   };
+
+  log('converted tool: %O', tool);
   // Convert messages to Anthropic format
   const system_message = messages.find((m) => m.role === 'system');
   const user_messages = messages.filter((m) => m.role !== 'system');
   const anthropicMessages = await buildAnthropicMessages(user_messages);
 
-  // Add instruction to use the structured output tool
-  const enhancedMessages = [
-    ...anthropicMessages,
-    {
-      content:
-        'Please use the structured_output tool to provide your response in the required format.',
-      role: 'user' as const,
-    },
-  ];
+  log('converted %d messages to Anthropic format', anthropicMessages.length);
 
   const systemPrompts = system_message?.content
     ? [
@@ -44,13 +46,15 @@ export const createAnthropicGenerateObject = async (
     : undefined;
 
   try {
+    log('calling Anthropic API with max_tokens: %d', 8192);
+
     const response = await client.messages.create(
       {
         max_tokens: 8192,
-        messages: enhancedMessages,
+        messages: anthropicMessages,
         model,
         system: systemPrompts,
-        tool_choice: { name: 'structured_output', type: 'tool' },
+        tool_choice: { name: tool.name, type: 'tool' },
         tools: [tool],
       },
       {
@@ -58,19 +62,23 @@ export const createAnthropicGenerateObject = async (
       },
     );
 
+    log('received response with %d content blocks', response.content.length);
+    log('response: %O', response);
+
     // Extract the tool use result
     const toolUseBlock = response.content.find(
-      (block) => block.type === 'tool_use' && block.name === 'structured_output',
+      (block) => block.type === 'tool_use' && block.name === tool.name,
     );
 
     if (!toolUseBlock || toolUseBlock.type !== 'tool_use') {
-      console.error('No structured output tool use found in response');
+      log('no tool use found in response (expected tool: %s)', tool.name);
       return undefined;
     }
 
+    log('extracted tool input: %O', toolUseBlock.input);
     return toolUseBlock.input;
   } catch (error) {
-    console.error('Anthropic generateObject error:', error);
+    log('generateObject error: %O', error);
     throw error;
   }
 };

package/packages/model-runtime/src/providers/deepseek/index.ts

@@ -12,6 +12,11 @@ export const LobeDeepSeekAI = createOpenAICompatibleRuntime({
   debug: {
     chatCompletion: () => process.env.DEBUG_DEEPSEEK_CHAT_COMPLETION === '1',
   },
+  // Deepseek don't support json format well
+  // use Tools calling to simulate
+  generateObject: {
+    useToolsCalling: true,
+  },
   models: async ({ client }) => {
     const modelsPage = (await client.models.list()) as any;
     const modelList: DeepSeekModelCard[] = modelsPage.data;

package/packages/model-runtime/src/providers/openai/index.test.ts

@@ -101,7 +101,6 @@ describe('LobeOpenAI', () => {
       it('should return ProviderBizError with the cause when OpenAI.APIError is thrown with cause', async () => {
         // Arrange
         const errorInfo = {
-          stack: 'abc',
           cause: {
             message: 'api is undefined',
           },
@@ -122,7 +121,6 @@ describe('LobeOpenAI', () => {
             endpoint: 'https://api.openai.com/v1',
             error: {
               cause: { message: 'api is undefined' },
-              stack: 'abc',
             },
             errorType: 'ProviderBizError',
             provider: 'openai',
@@ -133,7 +131,6 @@ describe('LobeOpenAI', () => {
       it('should return ProviderBizError with an cause response with desensitize Url', async () => {
         // Arrange
         const errorInfo = {
-          stack: 'abc',
           cause: { message: 'api is undefined' },
         };
         const apiError = new OpenAI.APIError(400, errorInfo, 'module error', {});
@@ -158,7 +155,6 @@ describe('LobeOpenAI', () => {
             endpoint: 'https://api.***.com/v1',
             error: {
               cause: { message: 'api is undefined' },
-              stack: 'abc',
             },
             errorType: 'ProviderBizError',
             provider: 'openai',
@@ -188,7 +184,6 @@ describe('LobeOpenAI', () => {
               name: genericError.name,
               cause: genericError.cause,
               message: genericError.message,
-              stack: genericError.stack,
             },
           });
         }

package/packages/model-runtime/src/providers/openrouter/index.test.ts

@@ -21,7 +21,7 @@ testProvider({
 });
 
 // Mock the console.error to avoid polluting test output
-vi.spyOn(console, 'error').mockImplementation(() => {});
+vi.spyOn(console, 'error').mockImplementation(() => { });
 
 let instance: LobeOpenAICompatibleRuntime;
 
@@ -154,8 +154,8 @@ describe('LobeOpenRouterAI', () => {
 
       const list = await instance.models();
 
-      // 验证在当前实现中，当 frontend fetch 返回非 ok 时，会返回空列表
-      expect(fetch).toHaveBeenCalledWith('https://openrouter.ai/api/frontend/models');
+      // 验证在当前实现中，当 model fetch 返回非 ok 时，会返回空列表
+      expect(fetch).toHaveBeenCalledWith('https://openrouter.ai/api/v1/models');
       expect(list.length).toBe(0);
       expect(list).toEqual([]);
     });

package/packages/model-runtime/src/providers/openrouter/index.ts

@@ -58,7 +58,7 @@ export const LobeOpenRouterAI = createOpenAICompatibleRuntime({
     let modelList: OpenRouterModelCard[] = [];
 
     try {
-      const response = await fetch('https://openrouter.ai/api/frontend/models');
+      const response = await fetch('https://openrouter.ai/api/v1/models');
       if (response.ok) {
         const data = await response.json();
         modelList = data['data'];
@@ -70,19 +70,31 @@ export const LobeOpenRouterAI = createOpenAICompatibleRuntime({
 
     // 处理前端获取的模型信息，转换为标准格式
     const formattedModels = modelList.map((model) => {
-      const { endpoint } = model;
-      const endpointModel = endpoint?.model;
+      const { top_provider, architecture, pricing, supported_parameters } = model;
 
-      const inputModalities = endpointModel?.input_modalities || model.input_modalities;
+      const inputModalities = architecture.input_modalities || [];
 
-      let displayName = model.slug?.toLowerCase().includes('deepseek') && !model.short_name?.toLowerCase().includes('deepseek')
-        ? (model.name ?? model.slug)
-        : (model.short_name ?? model.name ?? model.slug);
+      // 处理 name，默认去除冒号及其前面的内容
+      let displayName = model.name;
+      const colonIndex = displayName.indexOf(':');
+      if (colonIndex !== -1) {
+        const prefix = displayName.substring(0, colonIndex).trim();
+        const suffix = displayName.substring(colonIndex + 1).trim();
 
-      const inputPrice = formatPrice(endpoint?.pricing?.prompt);
-      const outputPrice = formatPrice(endpoint?.pricing?.completion);
-      const cachedInputPrice = formatPrice(endpoint?.pricing?.input_cache_read);
-      const writeCacheInputPrice = formatPrice(endpoint?.pricing?.input_cache_write);
+        const isDeepSeekPrefix = prefix.toLowerCase() === 'deepseek';
+        const suffixHasDeepSeek = suffix.toLowerCase().includes('deepseek');
+
+        if (isDeepSeekPrefix && !suffixHasDeepSeek) {
+          displayName = model.name;
+        } else {
+          displayName = suffix;
+        }
+      }
+
+      const inputPrice = formatPrice(pricing.prompt);
+      const outputPrice = formatPrice(pricing.completion);
+      const cachedInputPrice = formatPrice(pricing.input_cache_read);
+      const writeCacheInputPrice = formatPrice(pricing.input_cache_write);
 
       const isFree = (inputPrice === 0 || outputPrice === 0) && !displayName.endsWith('(free)');
       if (isFree) {
@@ -90,14 +102,14 @@ export const LobeOpenRouterAI = createOpenAICompatibleRuntime({
       }
 
       return {
-        contextWindowTokens: endpoint?.context_length || model.context_length,
-        description: endpointModel?.description || model.description,
+        contextWindowTokens: top_provider.context_length || model.context_length,
+        description: model.description,
         displayName,
-        functionCall: endpoint?.supports_tool_parameters || false,
-        id: endpoint?.model_variant_slug || model.slug,
+        functionCall: supported_parameters.includes('tools'),
+        id: model.id,
         maxOutput:
-          typeof endpoint?.max_completion_tokens === 'number'
-            ? endpoint.max_completion_tokens
+          typeof top_provider.max_completion_tokens === 'number'
+            ? top_provider.max_completion_tokens
             : undefined,
         pricing: {
           input: inputPrice,
@@ -105,9 +117,9 @@ export const LobeOpenRouterAI = createOpenAICompatibleRuntime({
           writeCacheInput: writeCacheInputPrice,
           output: outputPrice,
         },
-        reasoning: endpoint?.supports_reasoning || false,
-        releasedAt: new Date(model.created_at).toISOString().split('T')[0],
-        vision: Array.isArray(inputModalities) && inputModalities.includes('image'),
+        reasoning: supported_parameters.includes('reasoning'),
+        releasedAt: new Date(model.created * 1000).toISOString().split('T')[0],
+        vision: inputModalities.includes('image'),
       };
     });
 

package/packages/model-runtime/src/providers/openrouter/type.ts

@@ -5,37 +5,38 @@ interface ModelPricing {
   input_cache_write?: string;
   prompt: string;
   request?: string;
+  web_search?: string;
+  internal_reasoning?: string;
 }
 
-export interface OpenRouterModelCard {
+interface TopProvider {
   context_length: number;
-  created_at: number;
-  description?: string;
-  endpoint: OpenRouterModelEndpoint;
-  input_modalities?: string[];
-  name?: string;
-  output_modalities?: string[];
-  per_request_limits?: any | null;
-  short_name?: string;
-  slug: string;
+  max_completion_tokens: number | null;
+  is_moderated: boolean;
 }
 
-interface OpenRouterModelEndpoint {
-  context_length?: number;
-  max_completion_tokens: number | null;
-  model?: {
-    description?: string;
-    input_modalities?: string[];
-    name?: string;
-    short_name?: string;
-    slug: string;
-  };
-  model_variant_slug?: string;
+interface Architecture {
+  modality: string;
+  input_modalities: string[];
+  output_modalities: string[];
+  tokenizer: string;
+  instruct_type: string | null;
+}
+
+export interface OpenRouterModelCard {
+  id: string;
+  canonical_slug: string;
+  hugging_face_id?: string;
+  name: string;
+  created: number;
+  description?: string;
+  context_length: number;
+  architecture: Architecture;
   pricing: ModelPricing;
+  top_provider: TopProvider;
+  per_request_limits?: any | null;
   supported_parameters: string[];
-  supports_reasoning?: boolean;
-  supports_tool_parameters?: boolean;
-  variant?: 'free' | 'standard' | 'unknown';
+  default_parameters?: any | null;
 }
 
 interface OpenRouterOpenAIReasoning {

package/packages/model-runtime/src/providers/zhipu/index.test.ts

@@ -263,7 +263,6 @@ describe('LobeZhipuAI', () => {
               name: genericError.name,
               cause: genericError.cause,
               message: genericError.message,
-              stack: genericError.stack,
             },
           });
         }

package/packages/model-runtime/src/types/structureOutput.ts

@@ -4,11 +4,23 @@ interface GenerateObjectMessage {
   role: 'user' | 'system' | 'assistant';
 }
 
+interface GenerateObjectSchema {
+  description?: string;
+  name: string;
+  schema: {
+    additionalProperties?: boolean;
+    properties: Record<string, any>;
+    required?: string[];
+    type: 'object';
+  };
+  strict?: boolean;
+}
+
 export interface GenerateObjectPayload {
   messages: GenerateObjectMessage[];
   model: string;
   responseApi?: boolean;
-  schema: any;
+  schema: GenerateObjectSchema;
 }
 
 export interface GenerateObjectOptions {

package/packages/model-runtime/src/utils/handleOpenAIError.test.ts

@@ -48,7 +48,6 @@ describe('handleOpenAIError', () => {
 
       expect(result.errorResult).toEqual({
         headers: { headers, status: 401 },
-        stack: apiError.stack,
         status: 472,
       });
       expect(result.RuntimeError).toBeUndefined();
@@ -84,7 +83,6 @@ describe('handleOpenAIError', () => {
           cause: { details: 'Error details' },
           message: 'Generic error',
           name: 'Error',
-          stack: error.stack,
         },
       });
     });
@@ -100,7 +98,6 @@ describe('handleOpenAIError', () => {
           cause: undefined,
           message: 'Simple error',
           name: 'Error',
-          stack: error.stack,
         },
       });
     });
@@ -122,7 +119,6 @@ describe('handleOpenAIError', () => {
           cause: undefined,
           message: 'Custom error message',
           name: 'CustomError',
-          stack: error.stack,
         },
       });
     });
@@ -141,7 +137,6 @@ describe('handleOpenAIError', () => {
           cause: undefined,
           message: 'Object error',
           name: undefined,
-          stack: undefined,
         },
       });
     });

package/packages/model-runtime/src/utils/handleOpenAIError.ts

@@ -20,7 +20,7 @@ export const handleOpenAIError = (
     }
     // if there is no other request error, the error object is a Response like object
     else {
-      errorResult = { headers: error.headers, stack: error.stack, status: error.status };
+      errorResult = { headers: error.headers, status: error.status };
     }
 
     return {
@@ -29,7 +29,7 @@ export const handleOpenAIError = (
   } else {
     const err = error as Error;
 
-    errorResult = { cause: err.cause, message: err.message, name: err.name, stack: err.stack };
+    errorResult = { cause: err.cause, message: err.message, name: err.name };
 
     return {
       RuntimeError: AgentRuntimeErrorType.AgentRuntimeError,

package/packages/types/src/aiChat.ts

@@ -54,12 +54,24 @@ export interface SendMessageServerResponse {
   userMessageId: string;
 }
 
+export const StructureSchema = z.object({
+  description: z.string().optional(),
+  name: z.string(),
+  schema: z.object({
+    additionalProperties: z.boolean().optional(),
+    properties: z.record(z.string(), z.any()),
+    required: z.array(z.string()).optional(),
+    type: z.literal('object'),
+  }),
+  strict: z.boolean().optional(),
+});
+
 export const StructureOutputSchema = z.object({
   keyVaultsPayload: z.string(),
   messages: z.array(z.any()),
   model: z.string(),
   provider: z.string(),
-  schema: z.any(),
+  schema: StructureSchema,
 });
 
 export interface StructureOutputParams {

package/packages/types/src/index.ts

@@ -10,6 +10,7 @@ export * from './clientDB';
 export * from './discover';
 export * from './eval';
 export * from './fetch';
+export * from './files';
 export * from './hotkey';
 export * from './knowledgeBase';
 export * from './llm';