mioku-service-webui 4.4.5 → 4.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mioku-service-webui",
-  "version": "4.4.5",
+  "version": "4.5.0",
   "description": "Mioku WebUI 服务",
   "main": "index.ts",
   "type": "module",

package/routes/ai.ts

@@ -3,7 +3,7 @@ import { logger } from "mioki";
 import { getChatConfig, updateChatConfig } from "../system";
 import { listStickerCatalog } from "../database";
 import aiService from "mioku-service-ai";
-import type { AIUsageRange } from "mioku-service-ai/usage/types";
+import type { AIModelRole, AIProtocol, AIUsageRange } from "mioku";
 
 const DEFAULT_MEMORY_GROUP_HISTORY_LIMIT = 300;
 const DEFAULT_MEMORY_USER_HISTORY_LIMIT = 100;
@@ -12,6 +12,17 @@ const DEFAULT_TOPIC_HISTORY_WINDOW_COUNT = 3;
 const DEFAULT_EXPRESSION_LEARN_AFTER_MESSAGES = 100;
 const DEFAULT_EXPRESSION_SAMPLE_SIZE = 8;
 const usageRanges = new Set<AIUsageRange>(["today", "7d", "30d"]);
+const protocols = new Set<AIProtocol>([
+  "openai-chat",
+  "openai-response",
+  "anthropic",
+  "gemini",
+]);
+const roles = new Set<AIModelRole>(["main", "working", "vision"]);
+
+function getAIApi() {
+  return aiService?.api as any;
+}
 
 function normalizePersonalizationConfig(input: any): any {
   const data =
@@ -122,14 +133,48 @@ function normalizePersonalizationConfig(input: any): any {
   return data;
 }
 
+function sanitizeBaseForSave(body: any): any {
+  if (!body || typeof body !== "object") return body;
+  const next = { ...body };
+  delete next.apiUrl;
+  delete next.apiKey;
+  delete next.model;
+  delete next.workingModel;
+  delete next.multimodalWorkingModel;
+  delete next.isMultimodal;
+  return next;
+}
+
 export function createAIRoutes() {
   const app = new Hono();
 
-  app.get("/base", (c) =>
-    c.json({ ok: true, data: getChatConfig("base.json") }),
-  );
+  app.get("/base", (c) => {
+    const data = getChatConfig("base.json") || {};
+    const api = getAIApi();
+    const rolesData = api?.getRoleBindings?.() ?? {};
+    const models = api?.listModels?.() ?? [];
+    const pickModelId = (full?: string) => {
+      if (!full) return "";
+      const idx = full.indexOf("/");
+      return idx > 0 ? full.slice(idx + 1) : full;
+    };
+    const vision = models.find((item: any) => item.id === rolesData.vision);
+    return c.json({
+      ok: true,
+      data: {
+        ...data,
+        model: pickModelId(rolesData.main) || data.model || "",
+        workingModel: pickModelId(rolesData.working) || data.workingModel || "",
+        multimodalWorkingModel:
+          pickModelId(rolesData.vision) || data.multimodalWorkingModel || "",
+        isMultimodal: vision?.capabilities?.includes?.("vision") ?? true,
+        providersManaged: true,
+      },
+    });
+  });
+
   app.put("/base", async (c) => {
-    const body = await c.req.json();
+    const body = sanitizeBaseForSave(await c.req.json());
     logger.info(`[webui-action] ai.base.update`);
     return c.json({ ok: true, data: updateChatConfig("base.json", body) });
   });
@@ -161,48 +206,230 @@ export function createAIRoutes() {
     });
   });
 
+  app.get("/providers", (c) => {
+    const api = getAIApi();
+    if (!api?.listProviders) {
+      return c.json({ ok: false, error: "AI_SERVICE_UNAVAILABLE" }, 503);
+    }
+    const providers = api.listProviders().map((item: any) => ({
+      ...item,
+      apiKey: item.apiKey ? "***" : "",
+      hasApiKey: Boolean(item.apiKey),
+    }));
+    return c.json({ ok: true, data: providers });
+  });
+
+  app.post("/providers", async (c) => {
+    const api = getAIApi();
+    if (!api?.createProvider) {
+      return c.json({ ok: false, error: "AI_SERVICE_UNAVAILABLE" }, 503);
+    }
+    const body = await c.req.json();
+    const protocol = String(body?.protocol || "openai-chat") as AIProtocol;
+    if (!protocols.has(protocol)) {
+      return c.json({ ok: false, error: "INVALID_PROTOCOL" }, 400);
+    }
+    logger.info(`[webui-action] ai.provider.create`, {
+      name: body?.name,
+      protocol,
+    });
+    const created = await api.createProvider({
+      id: body?.id,
+      name: body?.name,
+      protocol,
+      apiUrl: body?.apiUrl,
+      apiKey: body?.apiKey,
+      enabled: body?.enabled !== false,
+      headers: body?.headers,
+    });
+    return c.json({
+      ok: true,
+      data: {
+        ...created,
+        apiKey: created.apiKey ? "***" : "",
+        hasApiKey: Boolean(created.apiKey),
+      },
+    });
+  });
+
+  app.put("/providers/:id", async (c) => {
+    const api = getAIApi();
+    if (!api?.updateProvider) {
+      return c.json({ ok: false, error: "AI_SERVICE_UNAVAILABLE" }, 503);
+    }
+    const id = c.req.param("id");
+    const body = await c.req.json();
+    logger.info(`[webui-action] ai.provider.update`, { id });
+    const patch: Record<string, unknown> = { ...body };
+    if (patch.apiKey === "***" || patch.apiKey === "") delete patch.apiKey;
+    if (patch.protocol && !protocols.has(patch.protocol as AIProtocol)) {
+      return c.json({ ok: false, error: "INVALID_PROTOCOL" }, 400);
+    }
+    const updated = await api.updateProvider(id, patch);
+    return c.json({
+      ok: true,
+      data: {
+        ...updated,
+        apiKey: updated.apiKey ? "***" : "",
+        hasApiKey: Boolean(updated.apiKey),
+      },
+    });
+  });
+
+  app.delete("/providers/:id", (c) => {
+    const api = getAIApi();
+    if (!api?.removeProvider) {
+      return c.json({ ok: false, error: "AI_SERVICE_UNAVAILABLE" }, 503);
+    }
+    const id = c.req.param("id");
+    logger.info(`[webui-action] ai.provider.remove`, { id });
+    return c.json({ ok: Boolean(api.removeProvider(id)) });
+  });
+
+  app.post("/providers/:id/test", async (c) => {
+    const api = getAIApi();
+    if (!api?.testProvider) {
+      return c.json({ ok: false, error: "AI_SERVICE_UNAVAILABLE" }, 503);
+    }
+    const id = c.req.param("id");
+    logger.info(`[webui-action] ai.provider.test`, { id });
+    const result = await api.testProvider(id);
+    return c.json({ ok: true, data: result });
+  });
+
+  app.post("/providers/:id/models/refresh", async (c) => {
+    const api = getAIApi();
+    if (!api?.refreshModels) {
+      return c.json({ ok: false, error: "AI_SERVICE_UNAVAILABLE" }, 503);
+    }
+    const id = c.req.param("id");
+    logger.info(`[webui-action] ai.models.refresh`, { id });
+    const models = await api.refreshModels(id);
+    return c.json({ ok: true, data: models });
+  });
+
+  app.get("/models", (c) => {
+    const api = getAIApi();
+    if (!api?.listModels) {
+      return c.json({ ok: false, error: "AI_SERVICE_UNAVAILABLE" }, 503);
+    }
+    const providerId = c.req.query("providerId") || undefined;
+    return c.json({ ok: true, data: api.listModels(providerId) });
+  });
+
+  app.post("/models", async (c) => {
+    const api = getAIApi();
+    if (!api?.registerCustomModel) {
+      return c.json({ ok: false, error: "AI_SERVICE_UNAVAILABLE" }, 503);
+    }
+    const body = await c.req.json();
+    logger.info(`[webui-action] ai.model.create`, {
+      providerId: body?.providerId,
+      modelId: body?.modelId,
+    });
+    const model = api.registerCustomModel({
+      providerId: body?.providerId,
+      modelId: body?.modelId,
+      name: body?.name,
+      capabilities: body?.capabilities,
+    });
+    return c.json({ ok: true, data: model });
+  });
+
+  app.delete("/models/:id", (c) => {
+    const api = getAIApi();
+    if (!api?.removeCustomModel) {
+      return c.json({ ok: false, error: "AI_SERVICE_UNAVAILABLE" }, 503);
+    }
+    const id = decodeURIComponent(c.req.param("id"));
+    logger.info(`[webui-action] ai.model.remove`, { id });
+    return c.json({ ok: Boolean(api.removeCustomModel(id)) });
+  });
+
+  app.get("/roles", (c) => {
+    const api = getAIApi();
+    if (!api?.getRoleBindings) {
+      return c.json({ ok: false, error: "AI_SERVICE_UNAVAILABLE" }, 503);
+    }
+    return c.json({ ok: true, data: api.getRoleBindings() });
+  });
+
+  app.put("/roles", async (c) => {
+    const api = getAIApi();
+    if (!api?.setRoleBinding) {
+      return c.json({ ok: false, error: "AI_SERVICE_UNAVAILABLE" }, 503);
+    }
+    const body = await c.req.json();
+    logger.info(`[webui-action] ai.roles.update`, body);
+    for (const role of ["main", "working", "vision"] as AIModelRole[]) {
+      if (!(role in (body || {}))) continue;
+      const value = body[role];
+      if (value === null || value === undefined || value === "") {
+        api.setRoleBinding(role, undefined);
+      } else {
+        api.setRoleBinding(role, String(value));
+      }
+    }
+    return c.json({ ok: true, data: api.getRoleBindings() });
+  });
+
   app.get("/instances", (c) => {
-    const names = aiService?.api?.list?.() ?? [];
-    return c.json({ ok: true, data: names });
+    const api = getAIApi();
+    if (api?.listInstances) {
+      return c.json({ ok: true, data: api.listInstances() });
+    }
+    const names = api?.list?.() ?? [];
+    return c.json({ ok: true, data: names.map((name: string) => ({ name })) });
   });
 
   app.post("/instances", async (c) => {
     const body = await c.req.json();
     logger.info(`[webui-action] ai.instance.create`, {
       name: body?.name,
-      apiUrl: body?.apiUrl,
-      modelType: body?.modelType,
+      providerId: body?.providerId,
+      modelId: body?.modelId,
     });
-    if (!aiService?.api?.create) {
+    const api = getAIApi();
+    if (api?.createInstance && body?.providerId && body?.modelId) {
+      await api.createInstance({
+        name: body.name,
+        providerId: body.providerId,
+        modelId: body.modelId,
+        role: roles.has(body.role) ? body.role : undefined,
+      });
+      return c.json({ ok: true, data: api.listInstances?.() ?? api.list?.() });
+    }
+    if (!api?.create) {
       return c.json({ ok: false, error: "AI_SERVICE_UNAVAILABLE" }, 503);
     }
-
-    await aiService.api.create({
+    await api.create({
       name: body.name,
       apiUrl: body.apiUrl,
       apiKey: body.apiKey,
       modelType: body.modelType || "text",
+      model: body.model,
     });
-    return c.json({ ok: true, data: aiService.api.list() });
+    return c.json({ ok: true, data: api.list() });
   });
 
   app.delete("/instances/:name", (c) => {
     const name = c.req.param("name");
     logger.info(`[webui-action] ai.instance.remove`, { name });
-    const ok = aiService?.api?.remove?.(name);
+    const ok = getAIApi()?.remove?.(name);
     return c.json({ ok: Boolean(ok) });
   });
 
   app.post("/default/:name", (c) => {
     const name = c.req.param("name");
     logger.info(`[webui-action] ai.instance.set-default`, { name });
-    const ok = aiService?.api?.setDefault?.(name);
+    const ok = getAIApi()?.setDefault?.(name);
     return c.json({ ok: Boolean(ok) });
   });
 
   app.get("/skills", (c) => {
-    const skills = aiService?.api?.getAllSkills?.();
-    const tools = aiService?.api?.getAllTools?.();
+    const api = getAIApi();
+    const skills = api?.getAllSkills?.();
+    const tools = api?.getAllTools?.();
     return c.json({
       ok: true,
       data: {
@@ -217,7 +444,8 @@ export function createAIRoutes() {
   );
 
   app.get("/usage", (c) => {
-    if (!aiService?.api?.getUsageSummary) {
+    const api = getAIApi();
+    if (!api?.getUsageSummary) {
       return c.json({ ok: false, error: "AI_USAGE_UNAVAILABLE" }, 503);
     }
 
@@ -236,7 +464,7 @@ export function createAIRoutes() {
 
     return c.json({
       ok: true,
-      data: aiService.api.getUsageSummary({ range, botId }),
+      data: api.getUsageSummary({ range, botId }),
     });
   });