@lobehub/chat 0.111.6 → 0.112.0

package/src/services/__tests__/openai/OpenAPI_V3.json

@@ -0,0 +1,245 @@
+{
+  "components": {
+    "schemas": {
+      "HTTPValidationError": {
+        "properties": {
+          "detail": {
+            "items": {
+              "$ref": "#/components/schemas/ValidationError"
+            },
+            "type": "array",
+            "title": "Detail"
+          }
+        },
+        "type": "object",
+        "title": "HTTPValidationError"
+      },
+      "ValidationError": {
+        "properties": {
+          "loc": {
+            "items": {
+              "anyOf": [
+                {
+                  "type": "string"
+                },
+                {
+                  "type": "integer"
+                }
+              ]
+            },
+            "type": "array",
+            "title": "Location"
+          },
+          "msg": {
+            "type": "string",
+            "title": "Message"
+          },
+          "type": {
+            "type": "string",
+            "title": "Error Type"
+          }
+        },
+        "type": "object",
+        "required": ["loc", "msg", "type"],
+        "title": "ValidationError"
+      }
+    },
+    "securitySchemes": {
+      "HTTPBearer": {
+        "type": "http",
+        "scheme": "bearer"
+      }
+    }
+  },
+  "info": {
+    "title": "FastAPI",
+    "version": "0.1.0"
+  },
+  "openapi": "3.1.0",
+  "paths": {
+    "/course-segments/": {
+      "get": {
+        "summary": "Read Course Segments",
+        "operationId": "read_course_segments_course_segments__get",
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": {}
+              }
+            }
+          }
+        }
+      }
+    },
+    "/problem-set/{problem_set_id}/{question_number}": {
+      "get": {
+        "summary": "Read Problem Set Item",
+        "operationId": "read_problem_set_item_problem_set__problem_set_id___question_number__get",
+        "parameters": [
+          {
+            "name": "problem_set_id",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "integer",
+              "title": "Problem Set Id"
+            }
+          },
+          {
+            "name": "question_number",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "integer",
+              "title": "Question Number"
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": {}
+              }
+            }
+          },
+          "422": {
+            "description": "Validation Error",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/HTTPValidationError"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/problem-set/random/{problem_set_id}/{n_items}": {
+      "get": {
+        "summary": "Read Random Problem Set Items",
+        "operationId": "read_random_problem_set_items_problem_set_random__problem_set_id___n_items__get",
+        "parameters": [
+          {
+            "name": "problem_set_id",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "integer",
+              "title": "Problem Set Id"
+            }
+          },
+          {
+            "name": "n_items",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "integer",
+              "title": "N Items"
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": {}
+              }
+            }
+          },
+          "422": {
+            "description": "Validation Error",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/HTTPValidationError"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/problem-set/range/{problem_set_id}/{start}/{end}": {
+      "get": {
+        "summary": "Read Range Of Problem Set Items",
+        "operationId": "read_range_of_problem_set_items_problem_set_range__problem_set_id___start___end__get",
+        "parameters": [
+          {
+            "name": "problem_set_id",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "integer",
+              "title": "Problem Set Id"
+            }
+          },
+          {
+            "name": "start",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "integer",
+              "title": "Start"
+            }
+          },
+          {
+            "name": "end",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "integer",
+              "title": "End"
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": {}
+              }
+            }
+          },
+          "422": {
+            "description": "Validation Error",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/HTTPValidationError"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/user/": {
+      "get": {
+        "summary": "Read User Id",
+        "operationId": "read_user_id_user__get",
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": {}
+              }
+            }
+          }
+        },
+        "security": [
+          {
+            "HTTPBearer": []
+          }
+        ]
+      }
+    }
+  }
+}

package/src/services/__tests__/openai/plugin.json

@@ -0,0 +1,22 @@
+{
+  "api": {
+    "url": "https://www.wolframalpha.com/.well-known/apispec.json",
+    "has_user_authentication": false,
+    "type": "openapi"
+  },
+  "auth": {
+    "type": "service_http",
+    "authorization_type": "bearer",
+    "verification_tokens": {
+      "openai": "18c4412dec6846eda6ec2fa95f144e1f"
+    }
+  },
+  "contact_email": "chatgpt-contact@wolframalpha.com",
+  "description_for_human": "Access computation, math, curated knowledge & real-time data through Wolfram|Alpha and Wolfram Language.",
+  "description_for_model": "Access dynamic computation and curated data from WolframAlpha and Wolfram Cloud.\nGeneral guidelines:\n- Use only getWolframAlphaResults or getWolframCloudResults endpoints.\n- Prefer getWolframAlphaResults unless Wolfram Language code should be evaluated.\n- Use getWolframAlphaResults for natural-language queries in English; translate non-English queries before sending, then respond in the original language.\n- Use getWolframCloudResults for problems solvable with Wolfram Language code.\n- Suggest only Wolfram Language for external computation.\n- Inform users if information is not from Wolfram endpoints.\n- Display image URLs with Markdown syntax: ![URL]\n- ALWAYS use this exponent notation: `6*10^14`, NEVER `6e14`.\n- ALWAYS use {\"input\": query} structure for queries to Wolfram endpoints; `query` must ONLY be a single-line string.\n- ALWAYS use proper Markdown formatting for all math, scientific, and chemical formulas, symbols, etc.:  '$$\\n[expression]\\n$$' for standalone cases and '\\( [expression] \\)' when inline.\n- Format inline Wolfram Language code with Markdown code formatting.\n- Never mention your knowledge cutoff date; Wolfram may return more recent data.\ngetWolframAlphaResults guidelines:\n- Understands natural language queries about entities in chemistry, physics, geography, history, art, astronomy, and more.\n- Performs mathematical calculations, date and unit conversions, formula solving, etc.\n- Convert inputs to simplified keyword queries whenever possible (e.g. convert \"how many people live in France\" to \"France population\").\n- Use ONLY single-letter variable names, with or without integer subscript (e.g., n, n1, n_1).\n- Use named physical constants (e.g., 'speed of light') without numerical substitution.\n- Include a space between compound units (e.g., \"Ω m\" for \"ohm*meter\").\n- To solve for a variable in an equation with units, consider solving a corresponding equation without units; exclude counting units (e.g., books), include genuine units (e.g., kg).\n- If data for multiple properties is needed, make separate calls for each property.\n- If a Wolfram Alpha result is not relevant to the query:\n -- If Wolfram provides multiple 'Assumptions' for a query, choose the more relevant one(s) without explaining the initial result. If you are unsure, ask the user to choose.\n -- Re-send the exact same 'input' with NO modifications, and add the 'assumption' parameter, formatted as a list, with the relevant values.\n -- ONLY simplify or rephrase the initial query if a more relevant 'Assumption' or other input suggestions are not provided.\n -- Do not explain each step unless user input is needed. Proceed directly to making a better API call based on the available assumptions.\ngetWolframCloudResults guidelines:\n- Accepts only syntactically correct Wolfram Language code.\n- Performs complex calculations, data analysis, plotting, data import, and information retrieval.\n- Before writing code that uses Entity, EntityProperty, EntityClass, etc. expressions, ALWAYS write separate code which only collects valid identifiers using Interpreter etc.; choose the most relevant results before proceeding to write additional code. Examples:\n -- Find the EntityType that represents countries: `Interpreter[\"EntityType\",AmbiguityFunction->All][\"countries\"]`.\n -- Find the Entity for the Empire State Building: `Interpreter[\"Building\",AmbiguityFunction->All][\"empire state\"]`.\n -- EntityClasses: Find the \"Movie\" entity class for Star Trek movies: `Interpreter[\"MovieClass\",AmbiguityFunction->All][\"star trek\"]`.\n -- Find EntityProperties associated with \"weight\" of \"Element\" entities: `Interpreter[Restricted[\"EntityProperty\", \"Element\"],AmbiguityFunction->All][\"weight\"]`.\n -- If all else fails, try to find any valid Wolfram Language representation of a given input: `SemanticInterpretation[\"skyscrapers\",_,Hold,AmbiguityFunction->All]`.\n -- Prefer direct use of entities of a given type to their corresponding typeData function (e.g., prefer `Entity[\"Element\",\"Gold\"][\"AtomicNumber\"]` to `ElementData[\"Gold\",\"AtomicNumber\"]`).\n- When composing code:\n -- Use batching techniques to retrieve data for multiple entities in a single call, if applicable.\n -- Use Association to organize and manipulate data when appropriate.\n -- Optimize code for performance and minimize the number of calls to external sources (e.g., the Wolfram Knowledgebase)\n -- Use only camel case for variable names (e.g., variableName).\n -- Use ONLY double quotes around all strings, including plot labels, etc. (e.g., `PlotLegends -> {\"sin(x)\", \"cos(x)\", \"tan(x)\"}`).\n -- Avoid use of QuantityMagnitude.\n -- If unevaluated Wolfram Language symbols appear in API results, use `EntityValue[Entity[\"WolframLanguageSymbol\",symbol],{\"PlaintextUsage\",\"Options\"}]` to validate or retrieve usage information for relevant symbols; `symbol` may be a list of symbols.\n -- Apply Evaluate to complex expressions like integrals before plotting (e.g., `Plot[Evaluate[Integrate[...]]]`).\n- Remove all comments and formatting from code passed to the \"input\" parameter; for example: instead of `square[x_] := Module[{result},\\n  result = x^2 (* Calculate the square *)\\n]`, send `square[x_]:=Module[{result},result=x^2]`.\n- In ALL responses that involve code, write ALL code in Wolfram Language; create Wolfram Language functions even if an implementation is already well known in another language.\n",
+  "legal_info_url": "https://products.wolframalpha.com/api/commercial-termsofuse",
+  "logo_url": "https://www.wolframcdn.com/images/icons/Wolfram.png",
+  "name_for_human": "Wolfram",
+  "name_for_model": "Wolfram",
+  "schema_version": "v1"
+}

package/src/services/__tests__/plugin.test.ts

@@ -9,6 +9,8 @@ import { LobeTool } from '@/types/tool';
 import { LobeToolCustomPlugin } from '@/types/tool/plugin';
 
 import { InstallPluginParams, pluginService } from '../plugin';
+import openAPIV3 from './openai/OpenAPI_V3.json';
+import OpenAIPlugin from './openai/plugin.json';
 
 // Mocking modules and functions
 vi.mock('@/const/url', () => ({
@@ -111,6 +113,7 @@ describe('PluginService', () => {
 
       global.fetch = vi.fn(() =>
         Promise.resolve({
+          headers: new Headers({ 'content-type': 'application/json' }),
           ok: true,
           json: () => Promise.resolve(fakeManifest),
         }),
@@ -135,6 +138,7 @@ describe('PluginService', () => {
       const manifestUrl = 'http://fake-url.com/manifest.json';
       global.fetch = vi.fn(() =>
         Promise.resolve({
+          headers: new Headers({ 'content-type': 'application/json' }),
           ok: true,
           json: () => Promise.resolve(fakeManifest),
         }),
@@ -164,6 +168,7 @@ describe('PluginService', () => {
       const manifestUrl = 'http://fake-url.com/manifest.json';
       global.fetch = vi.fn(() =>
         Promise.resolve({
+          headers: new Headers({ 'content-type': 'application/json' }),
           ok: true,
           json: () => {
             throw new Error('abc');
@@ -184,6 +189,7 @@ describe('PluginService', () => {
       global.fetch = vi.fn(() =>
         Promise.resolve({
           ok: false,
+          headers: new Headers({ 'content-type': 'application/json' }),
           json: () => Promise.resolve(fakeManifest),
         }),
       ) as any;
@@ -194,6 +200,85 @@ describe('PluginService', () => {
         expect(e).toEqual(new TypeError('fetchError'));
       }
     });
+
+    describe('support OpenAPI manifest', () => {
+      it('should get plugin manifest', async () => {
+        const manifestUrl = 'http://fake-url.com/manifest.json';
+        const openapiUrl = 'http://fake-url.com/openapiUrl.json';
+
+        const fakeManifest = {
+          $schema: '../node_modules/@lobehub/chat-plugin-sdk/schema.json',
+          api: [],
+          openapi: openapiUrl,
+          author: 'LobeHub',
+          createAt: '2023-08-12',
+          homepage: 'https://github.com/lobehub/chat-plugin-realtime-weather',
+          identifier: 'realtime-weather',
+          meta: {
+            avatar: '🌈',
+            tags: ['weather', 'realtime'],
+            title: 'Realtime Weather',
+            description: 'Get realtime weather information',
+          },
+          ui: {
+            url: 'https://realtime-weather.chat-plugin.lobehub.com/iframe',
+            height: 310,
+          },
+          version: '1',
+        };
+
+        global.fetch = vi.fn((url) =>
+          Promise.resolve({
+            ok: true,
+            headers: new Headers({ 'content-type': 'application/json' }),
+            json: () => Promise.resolve(url === openapiUrl ? openAPIV3 : fakeManifest),
+          }),
+        ) as any;
+
+        const manifest = await pluginService.getPluginManifest(manifestUrl);
+
+        expect(manifest).toMatchSnapshot();
+      });
+
+      it('should return error on openAPIInvalid', async () => {
+        const openapiUrl = 'http://fake-url.com/openapiUrl.json';
+        const manifestUrl = 'http://fake-url.com/manifest.json';
+        const fakeManifest = {
+          $schema: '../node_modules/@lobehub/chat-plugin-sdk/schema.json',
+          api: [],
+          openapi: openapiUrl,
+          author: 'LobeHub',
+          createAt: '2023-08-12',
+          homepage: 'https://github.com/lobehub/chat-plugin-realtime-weather',
+          identifier: 'realtime-weather',
+          meta: {
+            avatar: '🌈',
+            tags: ['weather', 'realtime'],
+            title: 'Realtime Weather',
+            description: 'Get realtime weather information',
+          },
+          ui: {
+            url: 'https://realtime-weather.chat-plugin.lobehub.com/iframe',
+            height: 310,
+          },
+          version: '1',
+        };
+
+        global.fetch = vi.fn((url) =>
+          Promise.resolve({
+            ok: true,
+            headers: new Headers({ 'content-type': 'application/json' }),
+            json: () => Promise.resolve(url === openapiUrl ? [] : fakeManifest),
+          }),
+        ) as any;
+
+        try {
+          await pluginService.getPluginManifest(manifestUrl);
+        } catch (e) {
+          expect(e).toEqual(new TypeError('openAPIInvalid'));
+        }
+      });
+    });
   });
 
   describe('installPlugin', () => {
@@ -329,5 +414,9 @@ describe('PluginService', () => {
     });
   });
 
-  // Add any additional tests to cover edge cases or error handling as needed.
+  it('can parse the OpenAI plugin', async () => {
+    const manifest = pluginService['convertOpenAIManifestToLobeManifest'](OpenAIPlugin as any);
+
+    expect(manifest).toMatchSnapshot();
+  });
 });

package/src/services/__tests__/share.test.ts

@@ -0,0 +1,86 @@
+import { Mock, afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { ShareGPTConversation } from '@/types/share';
+import { parseMarkdown } from '@/utils/parseMarkdown';
+
+import { SHARE_GPT_URL, shareGPTService } from '../share';
+
+// Mock dependencies
+vi.mock('@/utils/parseMarkdown', () => ({
+  parseMarkdown: vi.fn(),
+}));
+
+global.fetch = vi.fn();
+
+describe('ShareGPTService', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should create and return a ShareGPT URL when fetch is successful', async () => {
+    // Arrange
+    const mockId = '123abc';
+    const conversation: ShareGPTConversation = {
+      items: [
+        { from: 'human', value: 'Hello' },
+        { from: 'gpt', value: 'Hi there!' },
+      ],
+    };
+    (parseMarkdown as Mock).mockResolvedValue('Parsed markdown');
+    (fetch as Mock).mockResolvedValue({
+      json: () => Promise.resolve({ id: mockId }),
+    });
+
+    // Act
+    const url = await shareGPTService.createShareGPTUrl(conversation);
+
+    // Assert
+    expect(parseMarkdown).toHaveBeenCalledWith('Hi there!');
+    expect(fetch).toHaveBeenCalledWith(SHARE_GPT_URL, expect.anything());
+    expect(url).toBe(`https://shareg.pt/${mockId}`);
+  });
+
+  it('should throw an error when the fetch call fails', async () => {
+    // Arrange
+    const conversation: ShareGPTConversation = {
+      items: [{ from: 'human', value: 'Hello' }],
+    };
+    (fetch as Mock).mockRejectedValue(new Error('Network error'));
+
+    // Act & Assert
+    await expect(shareGPTService.createShareGPTUrl(conversation)).rejects.toThrow('Network error');
+  });
+
+  it('should not parse markdown for items not from gpt', async () => {
+    // Arrange
+    const mockId = '123abc';
+    const conversation: ShareGPTConversation = {
+      items: [
+        { from: 'human', value: 'Hello' },
+        { from: 'human', value: 'How are you?' },
+      ],
+    };
+    (fetch as Mock).mockResolvedValue({
+      json: () => Promise.resolve({ id: mockId }),
+    });
+
+    // Act
+    await shareGPTService.createShareGPTUrl(conversation);
+
+    // Assert
+    expect(parseMarkdown).not.toHaveBeenCalled();
+  });
+
+  it('should throw an error if the response does not contain an id', async () => {
+    // Arrange
+    const conversation: ShareGPTConversation = {
+      items: [{ from: 'human', value: 'Hello' }],
+    };
+    (fetch as Mock).mockResolvedValue({
+      json: () => Promise.resolve({}),
+    });
+
+    // Act & Assert
+    await expect(shareGPTService.createShareGPTUrl(conversation)).rejects.toThrow();
+  });
+});

package/src/services/_url.ts

@@ -14,3 +14,5 @@ export const TTS_URL = {
   edge: '/api/tts/edge-speech',
   microsoft: '/api/tts/microsoft-speech',
 };
+
+export const PROXY_URL = '/api/proxy';

package/src/services/global.ts

@@ -0,0 +1,15 @@
+const VERSION_URL = 'https://registry.npmmirror.com/@lobehub/chat';
+
+class GlobalService {
+  /**
+   * get latest version from npm
+   */
+  getLatestVersion = async (): Promise<string> => {
+    const res = await fetch(VERSION_URL);
+    const data = await res.json();
+
+    return data['dist-tags']?.latest;
+  };
+}
+
+export const globalService = new GlobalService();

package/src/services/plugin.ts

@@ -3,10 +3,14 @@ import {
   LobeChatPluginsMarketIndex,
   pluginManifestSchema,
 } from '@lobehub/chat-plugin-sdk';
+import { OpenAPIConvertor } from '@lobehub/chat-plugin-sdk/openapi';
+import YAML from 'yaml';
 
 import { getPluginIndexJSON } from '@/const/url';
 import { PluginModel } from '@/database/models/plugin';
+import { PROXY_URL } from '@/services/_url';
 import { globalHelpers } from '@/store/global/helpers';
+import { OpenAIPluginManifest } from '@/types/openai/plugin';
 import { LobeTool } from '@/types/tool';
 import { LobeToolCustomPlugin } from '@/types/tool/plugin';
 
@@ -16,6 +20,35 @@ export interface InstallPluginParams {
   type: 'plugin' | 'customPlugin';
 }
 class PluginService {
+  private _fetchJSON = async <T = any>(url: string, proxy = false): Promise<T> => {
+    // 2. 发送请求
+    let res: Response;
+    try {
+      res = await (proxy ? fetch(PROXY_URL, { body: url, method: 'POST' }) : fetch(url));
+    } catch {
+      throw new TypeError('fetchError');
+    }
+
+    if (!res.ok) {
+      throw new TypeError('fetchError');
+    }
+
+    let data;
+    const contentType = res.headers.get('Content-Type');
+
+    try {
+      if (contentType === 'application/json') {
+        data = await res.json();
+      } else {
+        const yaml = await res.text();
+        data = YAML.parse(yaml);
+      }
+    } catch {
+      throw new TypeError('urlError');
+    }
+
+    return data;
+  };
   /**
    * get plugin list from store
    */
@@ -29,29 +62,24 @@ class PluginService {
     return data;
   };
 
-  getPluginManifest = async (url?: string): Promise<LobeChatPluginManifest> => {
+  getPluginManifest = async (
+    url?: string,
+    useProxy: boolean = false,
+  ): Promise<LobeChatPluginManifest> => {
     // 1. valid plugin
     if (!url) {
       throw new TypeError('noManifest');
     }
 
     // 2. 发送请求
-    let res: Response;
-    try {
-      res = await fetch(url);
-    } catch {
-      throw new TypeError('fetchError');
-    }
 
-    if (!res.ok) {
-      throw new TypeError('fetchError');
-    }
+    let data = await this._fetchJSON<LobeChatPluginManifest>(url, useProxy);
 
-    let data;
-    try {
-      data = await res.json();
-    } catch {
-      throw new TypeError('urlError');
+    // @ts-ignore
+    // if there is a description_for_model, it is an OpenAI plugin
+    // we need convert to lobe plugin
+    if (data['description_for_model']) {
+      data = this.convertOpenAIManifestToLobeManifest(data as any);
     }
 
     // 3. 校验插件文件格式规范
@@ -61,6 +89,21 @@ class PluginService {
       throw new TypeError('manifestInvalid', { cause: parser.error });
     }
 
+    // 4. if exist OpenAPI api, merge the OpenAPIs to api
+    if (parser.data.openapi) {
+      const openapiJson = await this._fetchJSON(parser.data.openapi, useProxy);
+
+      try {
+        const convertor = new OpenAPIConvertor(openapiJson);
+        const openAPIs = await convertor.convertOpenAPIToPluginSchema();
+        data.api = [...data.api, ...openAPIs];
+
+        data.settings = await convertor.convertAuthToSettingsSchema(data.settings);
+      } catch (error) {
+        throw new TypeError('openAPIInvalid', { cause: error });
+      }
+    }
+
     return data;
   };
 
@@ -94,6 +137,47 @@ class PluginService {
   async updatePluginSettings(id: string, settings: any) {
     return PluginModel.update(id, { settings });
   }
+
+  private convertOpenAIManifestToLobeManifest = (
+    data: OpenAIPluginManifest,
+  ): LobeChatPluginManifest => {
+    const manifest: LobeChatPluginManifest = {
+      api: [],
+      homepage: data.legal_info_url,
+      identifier: data.name_for_model,
+      meta: {
+        avatar: data.logo_url,
+        description: data.description_for_human,
+        title: data.name_for_human,
+      },
+      openapi: data.api.url,
+
+      type: 'default',
+      version: '1',
+    };
+    switch (data.auth.type) {
+      case 'none': {
+        break;
+      }
+      case 'service_http': {
+        manifest.settings = {
+          properties: {
+            apiAuthKey: {
+              default: data.auth.verification_tokens['openai'],
+              description: 'API Key',
+              format: 'password',
+              title: 'API Key',
+              type: 'string',
+            },
+          },
+          type: 'object',
+        };
+        break;
+      }
+    }
+
+    return manifest;
+  };
 }
 
 export const pluginService = new PluginService();