duojie-helper 0.2.16 → 0.2.17

package/bin/cli.js

@@ -4,14 +4,18 @@ import { Command } from 'commander';
 import inquirer from 'inquirer';
 import chalk from 'chalk';
 import ora from 'ora';
+import { createRequire } from 'module';
 import { configureAll, configureTool, listTools, showStatus, revokeKey, fetchModels, getModels } from '../src/index.js';
 
+const require = createRequire(import.meta.url);
+const pkg = require('../package.json');
+
 const program = new Command();
 
 program
   .name('duojie')
   .description('🎮 Duojie API 一键配置助手 - 支持主流 AI 编程工具')
-  .version('0.2.3');
+  .version(pkg.version);
 
 // 默认命令 - 交互式配置
 program

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "duojie-helper",
-  "version": "0.2.16",
+  "version": "0.2.17",
   "description": "Duojie API 一键配置助手 - 支持 Claude Code, Droid, OpenClaw, Cursor, Cline 等主流 AI 编程工具",
   "type": "module",
   "bin": {

package/src/tools/openclaw.js

@@ -3,6 +3,8 @@ import path from 'path';
 import os from 'os';
 import { getModels, getApiBaseForProtocol } from '../index.js';
 
+const DUOJIE_PROVIDER_PREFIX = 'duojie-';
+
 /**
  * 获取 OpenClaw 配置路径
  * 支持 macOS / Linux / Windows（os.homedir() 跨平台处理）
@@ -46,6 +48,34 @@ function buildModelEntry(m, contextWindow, maxTokens) {
   };
 }
 
+function canonicalizeApi(api) {
+  const normalized = `${api || ''}`.toLowerCase().trim();
+  if (!normalized) return 'openai-completions';
+  if (normalized === 'openai-response') return 'openai-responses';
+  if (normalized === 'openai-completion') return 'openai-completions';
+  if (normalized === 'openai') return 'openai-completions';
+  return normalized;
+}
+
+function providerNameForApi(api) {
+  const normalized = canonicalizeApi(api);
+  if (normalized === 'anthropic-messages') return 'duojie-claude';
+  if (normalized === 'openai-completions') return 'duojie-openai';
+  if (normalized === 'openai-responses') return 'duojie-openai-responses';
+  return `duojie-${normalized.replace(/[^a-z0-9]+/g, '-')}`;
+}
+
+function stripDuojieKeysFromObject(obj) {
+  if (!obj || typeof obj !== 'object') return {};
+  const next = { ...obj };
+  for (const key of Object.keys(next)) {
+    if (`${key}`.startsWith(DUOJIE_PROVIDER_PREFIX)) {
+      delete next[key];
+    }
+  }
+  return next;
+}
+
 /**
  * 配置 OpenClaw
  *
@@ -65,60 +95,67 @@ export async function configureOpenClaw(apiKey) {
       ? await readConfig(paths.configFile)
       : {};
 
+    // OpenClaw 配置会做 schema 校验：根级未知字段可能导致校验失败
+    // 旧版本写入过 `_duojie`，这里显式剔除
+    const { _duojie: _ignoredDuojie, ...baseConfig } = existingConfig || {};
+    void _ignoredDuojie;
+
     const models = getModels();
 
-    // 构建各类模型列表
-    const claudeModels = (models.claude || []).map(m => buildModelEntry(m, 200000, 64000));
-    const gptModels    = (models.gpt    || []).map(m => buildModelEntry(m, 128000, 16384));
-    const geminiModels = (models.gemini || []).map(m => buildModelEntry(m, 1000000, 65536));
-    const otherModels  = (models.other  || []).map(m => buildModelEntry(m, 128000, 16384));
+    // 构建各类模型列表（保留 api 协议，后续按 api 拆分 providers）
+    const claudeModels = (models.claude || []).map(m => ({
+      ...m,
+      api: canonicalizeApi(m.api || 'anthropic-messages'),
+      _entry: buildModelEntry(m, 200000, 64000),
+    }));
+    const gptModels = (models.gpt || []).map(m => ({
+      ...m,
+      api: canonicalizeApi(m.api || 'openai-completions'),
+      _entry: buildModelEntry(m, 128000, 16384),
+    }));
+    const geminiModels = (models.gemini || []).map(m => ({
+      ...m,
+      api: canonicalizeApi(m.api || 'openai-completions'),
+      _entry: buildModelEntry(m, 1000000, 65536),
+    }));
+    const otherModels = (models.other || []).map(m => ({
+      ...m,
+      api: canonicalizeApi(m.api || 'openai-completions'),
+      _entry: buildModelEntry(m, 128000, 16384),
+    }));
 
-    // 构建 providers（按模型类型分组，api 协议对应文档规范）
+    const allModels = [...claudeModels, ...gptModels, ...geminiModels, ...otherModels];
+
+    // 构建 providers（按 api 协议分组，避免在同一个 provider 混用不同协议）
     const providers = {};
+    const modelIdToProvider = new Map();
 
-    if (claudeModels.length > 0) {
-      providers['duojie-claude'] = {
-        baseUrl: getApiBaseForProtocol('anthropic-messages'),
-        apiKey,
-        api: 'anthropic-messages',
-        models: claudeModels,
-      };
-    }
-    if (gptModels.length > 0) {
-      providers['duojie-gpt'] = {
-        baseUrl: getApiBaseForProtocol('anthropic-messages'),
-        apiKey,
-        api: 'anthropic-messages',
-        models: gptModels,
-      };
-    }
-    if (geminiModels.length > 0) {
-      providers['duojie-gemini'] = {
-        baseUrl: getApiBaseForProtocol('anthropic-messages'),
-        apiKey,
-        api: 'anthropic-messages',
-        models: geminiModels,
-      };
-    }
-    if (otherModels.length > 0) {
-      providers['duojie-other'] = {
-        baseUrl: getApiBaseForProtocol('anthropic-messages'),
-        apiKey,
-        api: 'anthropic-messages',
-        models: otherModels,
-      };
+    for (const m of allModels) {
+      const api = canonicalizeApi(m.api);
+      const providerName = providerNameForApi(api);
+
+      if (!providers[providerName]) {
+        providers[providerName] = {
+          baseUrl: getApiBaseForProtocol(api),
+          apiKey,
+          api,
+          models: [],
+        };
+      }
+
+      providers[providerName].models.push(m._entry);
+      modelIdToProvider.set(m.id, providerName);
     }
 
     // 默认模型：优先 gpt-5.2（如存在）
-    const gpt52 = (models.gpt || []).find(m => m.id === 'gpt-5.2')?.id || null;
-    let defaultProvider = 'duojie-claude';
+    const gpt52 = gptModels.find(m => m.id === 'gpt-5.2')?.id || null;
+    let defaultProvider = modelIdToProvider.get('claude-opus-4-6-kiro') || 'duojie-claude';
     let defaultModelId = 'claude-opus-4-6-kiro';
 
     if (gpt52) {
-      defaultProvider = 'duojie-gpt';
+      defaultProvider = modelIdToProvider.get(gpt52) || providerNameForApi('openai-completions');
       defaultModelId = gpt52;
     } else if (claudeModels.length > 0) {
-      defaultProvider = 'duojie-claude';
       defaultModelId = (
         claudeModels.find(m => m.id.includes('opus-4-6') && m.id.includes('kiro')) ||
         claudeModels.find(m => m.id.includes('opus-4-6')) ||
@@ -127,49 +164,58 @@ export async function configureOpenClaw(apiKey) {
         claudeModels.find(m => m.id.includes('sonnet')) ||
         claudeModels[0]
       ).id;
+      defaultProvider = modelIdToProvider.get(defaultModelId) || 'duojie-claude';
     } else if (gptModels.length > 0) {
-      defaultProvider = 'duojie-gpt';
       defaultModelId = gptModels[0].id;
+      defaultProvider = modelIdToProvider.get(defaultModelId) || providerNameForApi(gptModels[0].api);
+    } else if (geminiModels.length > 0) {
+      defaultModelId = geminiModels[0].id;
+      defaultProvider = modelIdToProvider.get(defaultModelId) || providerNameForApi(geminiModels[0].api);
+    } else if (otherModels.length > 0) {
+      defaultModelId = otherModels[0].id;
+      defaultProvider = modelIdToProvider.get(defaultModelId) || providerNameForApi(otherModels[0].api);
+    } else if (allModels.length > 0) {
+      defaultModelId = allModels[0].id;
+      defaultProvider = modelIdToProvider.get(defaultModelId) || providerNameForApi(allModels[0].api);
     }
 
     // 构建模型 allowlist（用于 /model 切换）
     const modelAllowList = {};
-    for (const m of claudeModels) modelAllowList[`duojie-claude/${m.id}`] = { alias: m.name };
-    for (const m of gptModels)    modelAllowList[`duojie-gpt/${m.id}`]    = { alias: m.name };
-    for (const m of geminiModels) modelAllowList[`duojie-gemini/${m.id}`] = { alias: m.name };
-    for (const m of otherModels)  modelAllowList[`duojie-other/${m.id}`]  = { alias: m.name };
+    for (const m of allModels) {
+      const providerName = modelIdToProvider.get(m.id) || providerNameForApi(m.api);
+      modelAllowList[`${providerName}/${m.id}`] = { alias: m.name || m.id };
+    }
 
-    const totalModels = claudeModels.length + gptModels.length + geminiModels.length + otherModels.length;
+    const totalModels = allModels.length;
 
     // 合并配置，保留用户已有的非 Duojie 设置
+    const existingProviders = stripDuojieKeysFromObject(baseConfig.models?.providers);
+    const existingAllowList = stripDuojieKeysFromObject(baseConfig.agents?.defaults?.models);
+
     const newConfig = {
-      ...existingConfig,
+      ...baseConfig,
       models: {
-        ...existingConfig.models,
+        ...baseConfig.models,
         mode: 'merge',
         providers: {
-          ...existingConfig.models?.providers,
+          ...existingProviders,
           ...providers,
         },
       },
       agents: {
-        ...existingConfig.agents,
+        ...baseConfig.agents,
         defaults: {
-          ...existingConfig.agents?.defaults,
+          ...baseConfig.agents?.defaults,
           model: {
-            ...existingConfig.agents?.defaults?.model,
+            ...baseConfig.agents?.defaults?.model,
             primary: `${defaultProvider}/${defaultModelId}`,
           },
           models: {
-            ...existingConfig.agents?.defaults?.models,
+            ...existingAllowList,
             ...modelAllowList,
           },
         },
       },
-      _duojie: {
-        configuredAt: new Date().toISOString(),
-        version: '0.2.8',
-      },
     };
 
     await fs.writeJson(paths.configFile, newConfig, { spaces: 2 });
@@ -196,10 +242,11 @@ configureOpenClaw.checkStatus = async function () {
 
   if (await fs.pathExists(paths.configFile)) {
     const config = await readConfig(paths.configFile);
-    if (config._duojie || config.models?.providers?.['duojie-claude']) {
+    const providerKeys = Object.keys(config.models?.providers || {});
+    if (providerKeys.some(k => `${k}`.startsWith(DUOJIE_PROVIDER_PREFIX))) {
       return { configured: true, message: '已配置 Duojie API' };
     }
-    if (config.models?.providers) {
+    if (providerKeys.length > 0) {
       return { configured: true, message: '已配置（非 Duojie）' };
     }
   }
@@ -217,12 +264,28 @@ configureOpenClaw.revoke = async function () {
     const config = await readConfig(paths.configFile);
 
     if (config.models?.providers) {
-      delete config.models.providers['duojie-claude'];
-      delete config.models.providers['duojie-gpt'];
-      delete config.models.providers['duojie-gemini'];
-      delete config.models.providers['duojie-other'];
+      for (const key of Object.keys(config.models.providers)) {
+        if (`${key}`.startsWith(DUOJIE_PROVIDER_PREFIX)) {
+          delete config.models.providers[key];
+        }
+      }
+    }
+
+    if (config.agents?.defaults?.models) {
+      for (const key of Object.keys(config.agents.defaults.models)) {
+        if (`${key}`.startsWith(DUOJIE_PROVIDER_PREFIX)) {
+          delete config.agents.defaults.models[key];
+        }
+      }
+    }
+
+    if (config.agents?.defaults?.model?.primary?.startsWith?.(DUOJIE_PROVIDER_PREFIX)) {
+      delete config.agents.defaults.model.primary;
+    }
+
+    if (config._duojie) {
+      delete config._duojie;
     }
-    delete config._duojie;
 
     await fs.writeJson(paths.configFile, config, { spaces: 2 });
   }