重构主控编排与运行时预热链路，统一工作区提示词/专家调度协议并补齐 wiki 记忆注入与写回闭环。

同时收敛启动与运维脚本默认行为（含 wiki worker）、更新 Admin 可观测性与相关测试，降低首轮时延并提高运行稳定性。

Made-with: Cursor

openclaw/extensions/arcee/api.ts

@@ -0,0 +1,8 @@
+export { buildArceeModelDefinition, ARCEE_BASE_URL, ARCEE_MODEL_CATALOG } from "./models.js";
+export { buildArceeProvider, buildArceeOpenRouterProvider } from "./provider-catalog.js";
+export {
+  applyArceeConfig,
+  applyArceeOpenRouterConfig,
+  ARCEE_DEFAULT_MODEL_REF,
+  ARCEE_OPENROUTER_DEFAULT_MODEL_REF,
+} from "./onboard.js";

openclaw/extensions/arcee/index.test.ts

@@ -0,0 +1,211 @@
+import { describe, expect, it } from "vitest";
+import { resolveProviderPluginChoice } from "../../src/plugins/provider-auth-choice.runtime.js";
+import { resolveProviderAuthEnvVarCandidates } from "../../src/secrets/provider-env-vars.js";
+import { registerSingleProviderPlugin } from "../../test/helpers/plugins/plugin-registration.js";
+import arceePlugin from "./index.js";
+
+describe("arcee provider plugin", () => {
+  it("registers Arcee AI with direct and OpenRouter auth choices", async () => {
+    const provider = await registerSingleProviderPlugin(arceePlugin);
+
+    expect(provider.id).toBe("arcee");
+    expect(provider.label).toBe("Arcee AI");
+    expect(provider.envVars).toEqual(["ARCEEAI_API_KEY", "OPENROUTER_API_KEY"]);
+    expect(provider.auth).toHaveLength(2);
+
+    const directChoice = resolveProviderPluginChoice({
+      providers: [provider],
+      choice: "arceeai-api-key",
+    });
+    expect(directChoice).not.toBeNull();
+    expect(directChoice?.provider.id).toBe("arcee");
+    expect(directChoice?.method.id).toBe("arcee-platform");
+
+    const orChoice = resolveProviderPluginChoice({
+      providers: [provider],
+      choice: "arceeai-openrouter",
+    });
+    expect(orChoice).not.toBeNull();
+    expect(orChoice?.provider.id).toBe("arcee");
+    expect(orChoice?.method.id).toBe("openrouter");
+  });
+
+  it("stores the OpenRouter onboarding path under the OpenRouter auth profile", async () => {
+    const provider = await registerSingleProviderPlugin(arceePlugin);
+    const openRouterMethod = provider.auth?.find((method) => method.id === "openrouter");
+    if (!openRouterMethod?.runNonInteractive) {
+      throw new Error("expected OpenRouter non-interactive auth");
+    }
+
+    const config = await openRouterMethod.runNonInteractive({
+      config: {},
+      opts: {},
+      env: {},
+      runtime: {
+        error: () => {},
+        exit: () => {},
+        log: () => {},
+      },
+      resolveApiKey: async () => ({
+        key: "sk-or-test",
+        source: "profile",
+      }),
+      toApiKeyCredential: () => null,
+    } as never);
+
+    expect(config?.auth?.profiles?.["openrouter:default"]).toMatchObject({
+      provider: "openrouter",
+      mode: "api_key",
+    });
+    expect(config?.models?.providers?.arcee).toMatchObject({
+      baseUrl: "https://openrouter.ai/api/v1",
+      api: "openai-completions",
+    });
+    expect(config?.models?.providers?.arcee?.models?.map((model) => model.id)).toEqual([
+      "arcee/trinity-mini",
+      "arcee/trinity-large-preview",
+      "arcee/trinity-large-thinking",
+    ]);
+  });
+
+  it("keeps direct Arcee auth env candidates separate from OpenRouter", () => {
+    const candidates = resolveProviderAuthEnvVarCandidates();
+
+    expect(candidates.arcee).toEqual(["ARCEEAI_API_KEY"]);
+    expect(candidates.openrouter).toEqual(["OPENROUTER_API_KEY"]);
+  });
+
+  it("builds the direct Arcee AI model catalog", async () => {
+    const provider = await registerSingleProviderPlugin(arceePlugin);
+    expect(provider.catalog).toBeDefined();
+
+    const catalog = await provider.catalog!.run({
+      config: {},
+      env: {},
+      resolveProviderApiKey: (id: string) =>
+        id === "arcee" ? { apiKey: "test-key" } : { apiKey: undefined },
+      resolveProviderAuth: () => ({
+        apiKey: "test-key",
+        mode: "api_key",
+        source: "env",
+      }),
+    } as never);
+
+    expect(catalog && "provider" in catalog).toBe(true);
+    if (!catalog || !("provider" in catalog)) {
+      throw new Error("expected single-provider catalog");
+    }
+
+    expect(catalog.provider.api).toBe("openai-completions");
+    expect(catalog.provider.baseUrl).toBe("https://api.arcee.ai/api/v1");
+    expect(catalog.provider.models?.map((model) => model.id)).toEqual([
+      "trinity-mini",
+      "trinity-large-preview",
+      "trinity-large-thinking",
+    ]);
+  });
+
+  it("builds the OpenRouter-backed Arcee AI model catalog", async () => {
+    const provider = await registerSingleProviderPlugin(arceePlugin);
+
+    const catalog = await provider.catalog!.run({
+      config: {},
+      env: {},
+      resolveProviderApiKey: (id: string) =>
+        id === "openrouter" ? { apiKey: "sk-or-test" } : { apiKey: undefined },
+      resolveProviderAuth: () => ({
+        apiKey: "sk-or-test",
+        mode: "api_key",
+        source: "env",
+      }),
+    } as never);
+
+    expect(catalog && "provider" in catalog).toBe(true);
+    if (!catalog || !("provider" in catalog)) {
+      throw new Error("expected single-provider catalog");
+    }
+
+    expect(catalog.provider.baseUrl).toBe("https://openrouter.ai/api/v1");
+    expect(catalog.provider.models?.map((model) => model.id)).toEqual([
+      "arcee/trinity-mini",
+      "arcee/trinity-large-preview",
+      "arcee/trinity-large-thinking",
+    ]);
+  });
+
+  it("normalizes Arcee OpenRouter models to vendor-prefixed runtime ids", async () => {
+    const provider = await registerSingleProviderPlugin(arceePlugin);
+
+    expect(
+      provider.normalizeResolvedModel?.({
+        modelId: "arcee/trinity-large-thinking",
+        model: {
+          provider: "arcee",
+          id: "trinity-large-thinking",
+          name: "Trinity Large Thinking",
+          api: "openai-completions",
+          baseUrl: "https://openrouter.ai/api/v1",
+        },
+      } as never),
+    ).toMatchObject({
+      id: "arcee/trinity-large-thinking",
+    });
+
+    expect(
+      provider.normalizeResolvedModel?.({
+        modelId: "arcee/trinity-large-thinking",
+        model: {
+          provider: "arcee",
+          id: "trinity-large-thinking",
+          name: "Trinity Large Thinking",
+          api: "openai-completions",
+          baseUrl: "https://api.arcee.ai/api/v1",
+        },
+      } as never),
+    ).toBeUndefined();
+  });
+
+  it("canonicalizes stale OpenRouter /v1 config and transport metadata", async () => {
+    const provider = await registerSingleProviderPlugin(arceePlugin);
+
+    expect(
+      provider.normalizeConfig?.({
+        provider: "arcee",
+        providerConfig: {
+          api: "openai-completions",
+          baseUrl: "https://openrouter.ai/v1/",
+          models: [],
+        },
+      } as never),
+    ).toMatchObject({
+      baseUrl: "https://openrouter.ai/api/v1",
+    });
+
+    expect(
+      provider.normalizeResolvedModel?.({
+        modelId: "arcee/trinity-large-thinking",
+        model: {
+          provider: "arcee",
+          id: "trinity-large-thinking",
+          name: "Trinity Large Thinking",
+          api: "openai-completions",
+          baseUrl: "https://openrouter.ai/v1",
+        },
+      } as never),
+    ).toMatchObject({
+      id: "arcee/trinity-large-thinking",
+      baseUrl: "https://openrouter.ai/api/v1",
+    });
+
+    expect(
+      provider.normalizeTransport?.({
+        provider: "arcee",
+        api: "openai-completions",
+        baseUrl: "https://openrouter.ai/v1",
+      } as never),
+    ).toEqual({
+      api: "openai-completions",
+      baseUrl: "https://openrouter.ai/api/v1",
+    });
+  });
+});

openclaw/extensions/arcee/index.ts

@@ -0,0 +1,142 @@
+import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
+import { createProviderApiKeyAuthMethod } from "openclaw/plugin-sdk/provider-auth-api-key";
+import {
+  readConfiguredProviderCatalogEntries,
+  type ProviderCatalogContext,
+} from "openclaw/plugin-sdk/provider-catalog-shared";
+import { OPENAI_COMPATIBLE_REPLAY_HOOKS } from "openclaw/plugin-sdk/provider-model-shared";
+import {
+  applyArceeConfig,
+  applyArceeOpenRouterConfig,
+  ARCEE_DEFAULT_MODEL_REF,
+  ARCEE_OPENROUTER_DEFAULT_MODEL_REF,
+} from "./onboard.js";
+import {
+  buildArceeProvider,
+  buildArceeOpenRouterProvider,
+  normalizeArceeOpenRouterBaseUrl,
+  toArceeOpenRouterModelId,
+} from "./provider-catalog.js";
+
+const PROVIDER_ID = "arcee";
+const ARCEE_WIZARD_GROUP = {
+  groupId: "arcee",
+  groupLabel: "Arcee AI",
+  groupHint: "Direct API or OpenRouter",
+} as const;
+
+function buildArceeAuthMethods() {
+  return [
+    createProviderApiKeyAuthMethod({
+      providerId: PROVIDER_ID,
+      methodId: "arcee-platform",
+      label: "Arcee AI API key",
+      hint: "Direct access to Arcee platform",
+      optionKey: "arceeaiApiKey",
+      flagName: "--arceeai-api-key",
+      envVar: "ARCEEAI_API_KEY",
+      promptMessage: "Enter Arcee AI API key",
+      defaultModel: ARCEE_DEFAULT_MODEL_REF,
+      expectedProviders: [PROVIDER_ID],
+      applyConfig: (cfg) => applyArceeConfig(cfg),
+      wizard: {
+        choiceId: "arceeai-api-key",
+        choiceLabel: "Arcee AI API key",
+        choiceHint: "Direct (chat.arcee.ai)",
+        ...ARCEE_WIZARD_GROUP,
+      },
+    }),
+    createProviderApiKeyAuthMethod({
+      providerId: PROVIDER_ID,
+      methodId: "openrouter",
+      label: "OpenRouter API key",
+      hint: "Access Arcee models via OpenRouter",
+      optionKey: "openrouterApiKey",
+      flagName: "--openrouter-api-key",
+      envVar: "OPENROUTER_API_KEY",
+      promptMessage: "Enter OpenRouter API key",
+      profileId: "openrouter:default",
+      defaultModel: ARCEE_OPENROUTER_DEFAULT_MODEL_REF,
+      expectedProviders: [PROVIDER_ID, "openrouter"],
+      applyConfig: (cfg) => applyArceeOpenRouterConfig(cfg),
+      wizard: {
+        choiceId: "arceeai-openrouter",
+        choiceLabel: "OpenRouter API key",
+        choiceHint: "Via OpenRouter (openrouter.ai)",
+        ...ARCEE_WIZARD_GROUP,
+      },
+    }),
+  ];
+}
+
+async function resolveArceeCatalog(ctx: ProviderCatalogContext) {
+  const directKey = ctx.resolveProviderApiKey(PROVIDER_ID).apiKey;
+  if (directKey) {
+    return { provider: { ...buildArceeProvider(), apiKey: directKey } };
+  }
+
+  const openRouterKey = ctx.resolveProviderApiKey("openrouter").apiKey;
+  if (openRouterKey) {
+    return { provider: { ...buildArceeOpenRouterProvider(), apiKey: openRouterKey } };
+  }
+
+  return null;
+}
+
+function normalizeArceeResolvedModel<T extends { baseUrl?: string; id: string }>(
+  model: T,
+): T | undefined {
+  const normalizedBaseUrl = normalizeArceeOpenRouterBaseUrl(model.baseUrl);
+  if (!normalizedBaseUrl) {
+    return undefined;
+  }
+  const normalizedId = toArceeOpenRouterModelId(model.id);
+  if (normalizedId === model.id && normalizedBaseUrl === model.baseUrl) {
+    return undefined;
+  }
+  return {
+    ...model,
+    id: normalizedId,
+    baseUrl: normalizedBaseUrl,
+  };
+}
+
+export default definePluginEntry({
+  id: PROVIDER_ID,
+  name: "Arcee AI Provider",
+  description: "Bundled Arcee AI provider plugin",
+  register(api) {
+    api.registerProvider({
+      id: PROVIDER_ID,
+      label: "Arcee AI",
+      docsPath: "/providers/arcee",
+      envVars: ["ARCEEAI_API_KEY", "OPENROUTER_API_KEY"],
+      auth: buildArceeAuthMethods(),
+      catalog: {
+        run: resolveArceeCatalog,
+      },
+      augmentModelCatalog: ({ config }) =>
+        readConfiguredProviderCatalogEntries({
+          config,
+          providerId: PROVIDER_ID,
+        }),
+      normalizeConfig: ({ providerConfig }) => {
+        const normalizedBaseUrl = normalizeArceeOpenRouterBaseUrl(providerConfig.baseUrl);
+        return normalizedBaseUrl && normalizedBaseUrl !== providerConfig.baseUrl
+          ? { ...providerConfig, baseUrl: normalizedBaseUrl }
+          : undefined;
+      },
+      normalizeResolvedModel: ({ model }) => normalizeArceeResolvedModel(model),
+      normalizeTransport: ({ api, baseUrl }) => {
+        const normalizedBaseUrl = normalizeArceeOpenRouterBaseUrl(baseUrl);
+        return normalizedBaseUrl && normalizedBaseUrl !== baseUrl
+          ? {
+              api,
+              baseUrl: normalizedBaseUrl,
+            }
+          : undefined;
+      },
+      ...OPENAI_COMPATIBLE_REPLAY_HOOKS,
+    });
+  },
+});

openclaw/extensions/arcee/models.ts

@@ -0,0 +1,67 @@
+import type { ModelDefinitionConfig } from "openclaw/plugin-sdk/provider-model-shared";
+
+export const ARCEE_BASE_URL = "https://api.arcee.ai/api/v1";
+
+export const ARCEE_MODEL_CATALOG: ModelDefinitionConfig[] = [
+  {
+    id: "trinity-mini",
+    name: "Trinity Mini 26B",
+    reasoning: false,
+    input: ["text"],
+    contextWindow: 131072,
+    maxTokens: 80000,
+    cost: {
+      input: 0.045,
+      output: 0.15,
+      cacheRead: 0.045,
+      cacheWrite: 0.045,
+    },
+  },
+  {
+    id: "trinity-large-preview",
+    name: "Trinity Large Preview",
+    reasoning: false,
+    input: ["text"],
+    contextWindow: 131072,
+    maxTokens: 16384,
+    cost: {
+      input: 0.25,
+      output: 1.0,
+      cacheRead: 0.25,
+      cacheWrite: 0.25,
+    },
+  },
+  {
+    id: "trinity-large-thinking",
+    name: "Trinity Large Thinking",
+    reasoning: true,
+    input: ["text"],
+    contextWindow: 262144,
+    maxTokens: 80000,
+    cost: {
+      input: 0.25,
+      output: 0.9,
+      cacheRead: 0.25,
+      cacheWrite: 0.25,
+    },
+    compat: {
+      supportsReasoningEffort: false,
+    },
+  },
+];
+
+export function buildArceeModelDefinition(
+  model: (typeof ARCEE_MODEL_CATALOG)[number],
+): ModelDefinitionConfig {
+  return {
+    id: model.id,
+    name: model.name,
+    api: "openai-completions",
+    reasoning: model.reasoning,
+    input: model.input,
+    cost: model.cost,
+    contextWindow: model.contextWindow,
+    maxTokens: model.maxTokens,
+    ...(model.compat ? { compat: model.compat } : {}),
+  };
+}

openclaw/extensions/arcee/onboard.ts

@@ -0,0 +1,47 @@
+import {
+  createModelCatalogPresetAppliers,
+  type OpenClawConfig,
+} from "openclaw/plugin-sdk/provider-onboard";
+import { ARCEE_BASE_URL } from "./models.js";
+import {
+  buildArceeCatalogModels,
+  buildArceeOpenRouterCatalogModels,
+  OPENROUTER_BASE_URL,
+} from "./provider-catalog.js";
+
+export const ARCEE_DEFAULT_MODEL_REF = "arcee/trinity-large-thinking";
+export const ARCEE_OPENROUTER_DEFAULT_MODEL_REF = "arcee/trinity-large-thinking";
+
+const arceePresetAppliers = createModelCatalogPresetAppliers({
+  primaryModelRef: ARCEE_DEFAULT_MODEL_REF,
+  resolveParams: (_cfg: OpenClawConfig) => ({
+    providerId: "arcee",
+    api: "openai-completions",
+    baseUrl: ARCEE_BASE_URL,
+    catalogModels: buildArceeCatalogModels(),
+    aliases: [{ modelRef: ARCEE_DEFAULT_MODEL_REF, alias: "Arcee AI" }],
+  }),
+});
+
+const arceeOpenRouterPresetAppliers = createModelCatalogPresetAppliers({
+  primaryModelRef: ARCEE_OPENROUTER_DEFAULT_MODEL_REF,
+  resolveParams: (_cfg: OpenClawConfig) => ({
+    providerId: "arcee",
+    api: "openai-completions",
+    baseUrl: OPENROUTER_BASE_URL,
+    catalogModels: buildArceeOpenRouterCatalogModels(),
+    aliases: [{ modelRef: ARCEE_OPENROUTER_DEFAULT_MODEL_REF, alias: "Arcee AI (OpenRouter)" }],
+  }),
+});
+
+export function applyArceeProviderConfig(cfg: OpenClawConfig): OpenClawConfig {
+  return arceePresetAppliers.applyProviderConfig(cfg);
+}
+
+export function applyArceeConfig(cfg: OpenClawConfig): OpenClawConfig {
+  return arceePresetAppliers.applyConfig(cfg);
+}
+
+export function applyArceeOpenRouterConfig(cfg: OpenClawConfig): OpenClawConfig {
+  return arceeOpenRouterPresetAppliers.applyConfig(cfg);
+}

openclaw/extensions/arcee/openclaw.plugin.json

@@ -0,0 +1,43 @@
+{
+  "id": "arcee",
+  "enabledByDefault": true,
+  "providers": ["arcee"],
+  "providerAuthEnvVars": {
+    "arcee": ["ARCEEAI_API_KEY"]
+  },
+  "providerAuthChoices": [
+    {
+      "provider": "arcee",
+      "method": "arcee-platform",
+      "choiceId": "arceeai-api-key",
+      "choiceLabel": "Arcee AI API key",
+      "choiceHint": "Direct (chat.arcee.ai)",
+      "groupId": "arcee",
+      "groupLabel": "Arcee AI",
+      "groupHint": "Direct API or OpenRouter",
+      "optionKey": "arceeaiApiKey",
+      "cliFlag": "--arceeai-api-key",
+      "cliOption": "--arceeai-api-key <key>",
+      "cliDescription": "Arcee AI API key"
+    },
+    {
+      "provider": "arcee",
+      "method": "openrouter",
+      "choiceId": "arceeai-openrouter",
+      "choiceLabel": "OpenRouter API key",
+      "choiceHint": "Via OpenRouter (openrouter.ai)",
+      "groupId": "arcee",
+      "groupLabel": "Arcee AI",
+      "groupHint": "Direct API or OpenRouter",
+      "optionKey": "openrouterApiKey",
+      "cliFlag": "--openrouter-api-key",
+      "cliOption": "--openrouter-api-key <key>",
+      "cliDescription": "OpenRouter API key for Arcee AI models"
+    }
+  ],
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {}
+  }
+}

openclaw/extensions/arcee/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "@openclaw/arcee-provider",
+  "version": "2026.4.20",
+  "private": true,
+  "description": "OpenClaw Arcee provider plugin",
+  "type": "module",
+  "devDependencies": {
+    "@openclaw/plugin-sdk": "workspace:*"
+  },
+  "openclaw": {
+    "extensions": [
+      "./index.ts"
+    ]
+  }
+}

openclaw/extensions/arcee/provider-catalog.ts

@@ -0,0 +1,58 @@
+import type { ModelProviderConfig } from "openclaw/plugin-sdk/provider-model-shared";
+import { buildArceeModelDefinition, ARCEE_BASE_URL, ARCEE_MODEL_CATALOG } from "./models.js";
+
+export const OPENROUTER_BASE_URL = "https://openrouter.ai/api/v1";
+const OPENROUTER_LEGACY_BASE_URL = "https://openrouter.ai/v1";
+
+function normalizeBaseUrl(baseUrl: string | undefined): string {
+  return (baseUrl ?? "").trim().replace(/\/+$/, "");
+}
+
+export function normalizeArceeOpenRouterBaseUrl(baseUrl: string | undefined): string | undefined {
+  const normalized = normalizeBaseUrl(baseUrl);
+  if (!normalized) {
+    return undefined;
+  }
+  if (normalized === OPENROUTER_BASE_URL || normalized === OPENROUTER_LEGACY_BASE_URL) {
+    return OPENROUTER_BASE_URL;
+  }
+  return undefined;
+}
+
+export function isArceeOpenRouterBaseUrl(baseUrl: string | undefined): boolean {
+  return normalizeArceeOpenRouterBaseUrl(baseUrl) === OPENROUTER_BASE_URL;
+}
+
+export function toArceeOpenRouterModelId(modelId: string): string {
+  const normalized = modelId.trim();
+  if (!normalized || normalized.startsWith("arcee/")) {
+    return normalized;
+  }
+  return `arcee/${normalized}`;
+}
+
+export function buildArceeCatalogModels(): NonNullable<ModelProviderConfig["models"]> {
+  return ARCEE_MODEL_CATALOG.map(buildArceeModelDefinition);
+}
+
+export function buildArceeOpenRouterCatalogModels(): NonNullable<ModelProviderConfig["models"]> {
+  return buildArceeCatalogModels().map((model) =>
+    Object.assign({}, model, { id: toArceeOpenRouterModelId(model.id) }),
+  );
+}
+
+export function buildArceeProvider(): ModelProviderConfig {
+  return {
+    baseUrl: ARCEE_BASE_URL,
+    api: "openai-completions",
+    models: buildArceeCatalogModels(),
+  };
+}
+
+export function buildArceeOpenRouterProvider(): ModelProviderConfig {
+  return {
+    baseUrl: OPENROUTER_BASE_URL,
+    api: "openai-completions",
+    models: buildArceeOpenRouterCatalogModels(),
+  };
+}

openclaw/extensions/arcee/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "extends": "../tsconfig.package-boundary.base.json",
+  "compilerOptions": {
+    "rootDir": "."
+  },
+  "include": ["./*.ts", "./src/**/*.ts"],
+  "exclude": [
+    "./**/*.test.ts",
+    "./dist/**",
+    "./node_modules/**",
+    "./src/test-support/**",
+    "./src/**/*test-helpers.ts",
+    "./src/**/*test-harness.ts",
+    "./src/**/*test-support.ts"
+  ]
+}