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

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

Made-with: Cursor

openclaw/extensions/fireworks/index.test.ts

@@ -0,0 +1,175 @@
+import type { ModelRegistry } from "@mariozechner/pi-coding-agent";
+import type {
+  ProviderResolveDynamicModelContext,
+  ProviderRuntimeModel,
+} from "openclaw/plugin-sdk/plugin-entry";
+import { describe, expect, it } from "vitest";
+import { resolveProviderPluginChoice } from "../../src/plugins/provider-auth-choice.runtime.js";
+import { registerSingleProviderPlugin } from "../../test/helpers/plugins/plugin-registration.js";
+import fireworksPlugin from "./index.js";
+import {
+  FIREWORKS_BASE_URL,
+  FIREWORKS_DEFAULT_CONTEXT_WINDOW,
+  FIREWORKS_DEFAULT_MAX_TOKENS,
+  FIREWORKS_DEFAULT_MODEL_ID,
+} from "./provider-catalog.js";
+
+function createDynamicContext(params: {
+  provider: string;
+  modelId: string;
+  models: ProviderRuntimeModel[];
+}): ProviderResolveDynamicModelContext {
+  return {
+    provider: params.provider,
+    modelId: params.modelId,
+    modelRegistry: {
+      find(providerId: string, modelId: string) {
+        return (
+          params.models.find(
+            (model) =>
+              model.provider === providerId && model.id.toLowerCase() === modelId.toLowerCase(),
+          ) ?? null
+        );
+      },
+    } as ModelRegistry,
+  };
+}
+
+describe("fireworks provider plugin", () => {
+  it("registers Fireworks with api-key auth wizard metadata", async () => {
+    const provider = await registerSingleProviderPlugin(fireworksPlugin);
+    const resolved = resolveProviderPluginChoice({
+      providers: [provider],
+      choice: "fireworks-api-key",
+    });
+
+    expect(provider.id).toBe("fireworks");
+    expect(provider.label).toBe("Fireworks");
+    expect(provider.aliases).toEqual(["fireworks-ai"]);
+    expect(provider.envVars).toEqual(["FIREWORKS_API_KEY"]);
+    expect(provider.auth).toHaveLength(1);
+    expect(resolved?.provider.id).toBe("fireworks");
+    expect(resolved?.method.id).toBe("api-key");
+  });
+
+  it("builds the Fireworks Fire Pass starter catalog", async () => {
+    const provider = await registerSingleProviderPlugin(fireworksPlugin);
+    const catalog = await provider.catalog?.run({
+      config: {},
+      env: {},
+      resolveProviderApiKey: () => ({ apiKey: "test-key" }),
+      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(FIREWORKS_BASE_URL);
+    expect(catalog.provider.models?.map((model) => model.id)).toEqual([FIREWORKS_DEFAULT_MODEL_ID]);
+    expect(catalog.provider.models?.[0]).toMatchObject({
+      reasoning: false,
+      input: ["text", "image"],
+      contextWindow: FIREWORKS_DEFAULT_CONTEXT_WINDOW,
+      maxTokens: FIREWORKS_DEFAULT_MAX_TOKENS,
+    });
+  });
+
+  it("resolves forward-compat Fireworks model ids from the default template", async () => {
+    const provider = await registerSingleProviderPlugin(fireworksPlugin);
+    const resolved = provider.resolveDynamicModel?.(
+      createDynamicContext({
+        provider: "fireworks",
+        modelId: "accounts/fireworks/models/qwen3.6-plus",
+        models: [
+          {
+            id: FIREWORKS_DEFAULT_MODEL_ID,
+            name: FIREWORKS_DEFAULT_MODEL_ID,
+            provider: "fireworks",
+            api: "openai-completions",
+            baseUrl: FIREWORKS_BASE_URL,
+            reasoning: true,
+            input: ["text", "image"],
+            cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+            contextWindow: FIREWORKS_DEFAULT_CONTEXT_WINDOW,
+            maxTokens: FIREWORKS_DEFAULT_MAX_TOKENS,
+          },
+        ],
+      }),
+    );
+
+    expect(resolved).toMatchObject({
+      provider: "fireworks",
+      id: "accounts/fireworks/models/qwen3.6-plus",
+      api: "openai-completions",
+      baseUrl: FIREWORKS_BASE_URL,
+      reasoning: true,
+    });
+  });
+
+  it("disables reasoning metadata for Fireworks Kimi dynamic models", async () => {
+    const provider = await registerSingleProviderPlugin(fireworksPlugin);
+    const resolved = provider.resolveDynamicModel?.(
+      createDynamicContext({
+        provider: "fireworks",
+        modelId: "accounts/fireworks/models/kimi-k2p5",
+        models: [
+          {
+            id: FIREWORKS_DEFAULT_MODEL_ID,
+            name: FIREWORKS_DEFAULT_MODEL_ID,
+            provider: "fireworks",
+            api: "openai-completions",
+            baseUrl: FIREWORKS_BASE_URL,
+            reasoning: false,
+            input: ["text", "image"],
+            cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+            contextWindow: FIREWORKS_DEFAULT_CONTEXT_WINDOW,
+            maxTokens: FIREWORKS_DEFAULT_MAX_TOKENS,
+          },
+        ],
+      }),
+    );
+
+    expect(resolved).toMatchObject({
+      provider: "fireworks",
+      id: "accounts/fireworks/models/kimi-k2p5",
+      reasoning: false,
+    });
+  });
+
+  it("disables reasoning metadata for Fireworks Kimi k2.5 aliases", async () => {
+    const provider = await registerSingleProviderPlugin(fireworksPlugin);
+    const resolved = provider.resolveDynamicModel?.(
+      createDynamicContext({
+        provider: "fireworks",
+        modelId: "accounts/fireworks/routers/kimi-k2.5-turbo",
+        models: [
+          {
+            id: FIREWORKS_DEFAULT_MODEL_ID,
+            name: FIREWORKS_DEFAULT_MODEL_ID,
+            provider: "fireworks",
+            api: "openai-completions",
+            baseUrl: FIREWORKS_BASE_URL,
+            reasoning: false,
+            input: ["text", "image"],
+            cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+            contextWindow: FIREWORKS_DEFAULT_CONTEXT_WINDOW,
+            maxTokens: FIREWORKS_DEFAULT_MAX_TOKENS,
+          },
+        ],
+      }),
+    );
+
+    expect(resolved).toMatchObject({
+      provider: "fireworks",
+      id: "accounts/fireworks/routers/kimi-k2.5-turbo",
+      reasoning: false,
+    });
+  });
+});

openclaw/extensions/fireworks/index.ts

@@ -0,0 +1,83 @@
+import type { ProviderResolveDynamicModelContext } from "openclaw/plugin-sdk/plugin-entry";
+import { defineSingleProviderPluginEntry } from "openclaw/plugin-sdk/provider-entry";
+import {
+  cloneFirstTemplateModel,
+  DEFAULT_CONTEXT_TOKENS,
+  normalizeModelCompat,
+  OPENAI_COMPATIBLE_REPLAY_HOOKS,
+} from "openclaw/plugin-sdk/provider-model-shared";
+import { isFireworksKimiModelId } from "./model-id.js";
+import { applyFireworksConfig, FIREWORKS_DEFAULT_MODEL_REF } from "./onboard.js";
+import {
+  buildFireworksProvider,
+  FIREWORKS_BASE_URL,
+  FIREWORKS_DEFAULT_CONTEXT_WINDOW,
+  FIREWORKS_DEFAULT_MAX_TOKENS,
+  FIREWORKS_DEFAULT_MODEL_ID,
+} from "./provider-catalog.js";
+import { wrapFireworksProviderStream } from "./stream.js";
+
+const PROVIDER_ID = "fireworks";
+function resolveFireworksDynamicModel(ctx: ProviderResolveDynamicModelContext) {
+  const modelId = ctx.modelId.trim();
+  if (!modelId) {
+    return undefined;
+  }
+
+  return (
+    cloneFirstTemplateModel({
+      providerId: PROVIDER_ID,
+      modelId,
+      templateIds: [FIREWORKS_DEFAULT_MODEL_ID],
+      ctx,
+      patch: {
+        provider: PROVIDER_ID,
+        reasoning: !isFireworksKimiModelId(modelId),
+      },
+    }) ??
+    normalizeModelCompat({
+      id: modelId,
+      name: modelId,
+      provider: PROVIDER_ID,
+      api: "openai-completions",
+      baseUrl: FIREWORKS_BASE_URL,
+      reasoning: !isFireworksKimiModelId(modelId),
+      input: ["text", "image"],
+      cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+      contextWindow: FIREWORKS_DEFAULT_CONTEXT_WINDOW,
+      maxTokens: FIREWORKS_DEFAULT_MAX_TOKENS || DEFAULT_CONTEXT_TOKENS,
+    })
+  );
+}
+
+export default defineSingleProviderPluginEntry({
+  id: PROVIDER_ID,
+  name: "Fireworks Provider",
+  description: "Bundled Fireworks AI provider plugin",
+  provider: {
+    label: "Fireworks",
+    aliases: ["fireworks-ai"],
+    docsPath: "/providers/fireworks",
+    auth: [
+      {
+        methodId: "api-key",
+        label: "Fireworks API key",
+        hint: "API key",
+        optionKey: "fireworksApiKey",
+        flagName: "--fireworks-api-key",
+        envVar: "FIREWORKS_API_KEY",
+        promptMessage: "Enter Fireworks API key",
+        defaultModel: FIREWORKS_DEFAULT_MODEL_REF,
+        applyConfig: (cfg) => applyFireworksConfig(cfg),
+      },
+    ],
+    catalog: {
+      buildProvider: buildFireworksProvider,
+      allowExplicitBaseUrl: true,
+    },
+    ...OPENAI_COMPATIBLE_REPLAY_HOOKS,
+    wrapStreamFn: wrapFireworksProviderStream,
+    resolveDynamicModel: (ctx) => resolveFireworksDynamicModel(ctx),
+    isModernModelRef: () => true,
+  },
+});

openclaw/extensions/fireworks/model-id.ts

@@ -0,0 +1,5 @@
+export function isFireworksKimiModelId(modelId: string): boolean {
+  const normalized = modelId.trim().toLowerCase();
+  const lastSegment = normalized.split("/").pop() ?? normalized;
+  return /^kimi-k2(?:p5|\.5)(?:[-_].+)?$/.test(lastSegment);
+}

openclaw/extensions/fireworks/onboard.ts

@@ -0,0 +1,34 @@
+import {
+  createDefaultModelsPresetAppliers,
+  type OpenClawConfig,
+} from "openclaw/plugin-sdk/provider-onboard";
+import {
+  buildFireworksCatalogModels,
+  buildFireworksProvider,
+  FIREWORKS_DEFAULT_MODEL_ID,
+} from "./provider-catalog.js";
+
+export const FIREWORKS_DEFAULT_MODEL_REF = `fireworks/${FIREWORKS_DEFAULT_MODEL_ID}`;
+
+const fireworksPresetAppliers = createDefaultModelsPresetAppliers({
+  primaryModelRef: FIREWORKS_DEFAULT_MODEL_REF,
+  resolveParams: (_cfg: OpenClawConfig) => {
+    const defaultProvider = buildFireworksProvider();
+    return {
+      providerId: "fireworks",
+      api: defaultProvider.api ?? "openai-completions",
+      baseUrl: defaultProvider.baseUrl,
+      defaultModels: buildFireworksCatalogModels(),
+      defaultModelId: FIREWORKS_DEFAULT_MODEL_ID,
+      aliases: [{ modelRef: FIREWORKS_DEFAULT_MODEL_REF, alias: "Kimi K2.5 Turbo" }],
+    };
+  },
+});
+
+export function applyFireworksProviderConfig(cfg: OpenClawConfig): OpenClawConfig {
+  return fireworksPresetAppliers.applyProviderConfig(cfg);
+}
+
+export function applyFireworksConfig(cfg: OpenClawConfig): OpenClawConfig {
+  return fireworksPresetAppliers.applyConfig(cfg);
+}

openclaw/extensions/fireworks/openclaw.plugin.json

@@ -0,0 +1,28 @@
+{
+  "id": "fireworks",
+  "enabledByDefault": true,
+  "providers": ["fireworks"],
+  "providerAuthEnvVars": {
+    "fireworks": ["FIREWORKS_API_KEY"]
+  },
+  "providerAuthChoices": [
+    {
+      "provider": "fireworks",
+      "method": "api-key",
+      "choiceId": "fireworks-api-key",
+      "choiceLabel": "Fireworks API key",
+      "groupId": "fireworks",
+      "groupLabel": "Fireworks",
+      "groupHint": "API key",
+      "optionKey": "fireworksApiKey",
+      "cliFlag": "--fireworks-api-key",
+      "cliOption": "--fireworks-api-key <key>",
+      "cliDescription": "Fireworks API key"
+    }
+  ],
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {}
+  }
+}

openclaw/extensions/fireworks/package.json

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

openclaw/extensions/fireworks/provider-catalog.ts

@@ -0,0 +1,38 @@
+import type {
+  ModelDefinitionConfig,
+  ModelProviderConfig,
+} from "openclaw/plugin-sdk/provider-model-shared";
+
+export const FIREWORKS_BASE_URL = "https://api.fireworks.ai/inference/v1";
+export const FIREWORKS_DEFAULT_MODEL_ID = "accounts/fireworks/routers/kimi-k2p5-turbo";
+export const FIREWORKS_DEFAULT_CONTEXT_WINDOW = 256000;
+export const FIREWORKS_DEFAULT_MAX_TOKENS = 256000;
+
+const ZERO_COST = {
+  input: 0,
+  output: 0,
+  cacheRead: 0,
+  cacheWrite: 0,
+} as const;
+
+export function buildFireworksCatalogModels(): ModelDefinitionConfig[] {
+  return [
+    {
+      id: FIREWORKS_DEFAULT_MODEL_ID,
+      name: "Kimi K2.5 Turbo (Fire Pass)",
+      reasoning: false, // Kimi K2.5 can expose reasoning in visible content on FirePass.
+      input: ["text", "image"],
+      cost: ZERO_COST,
+      contextWindow: FIREWORKS_DEFAULT_CONTEXT_WINDOW,
+      maxTokens: FIREWORKS_DEFAULT_MAX_TOKENS,
+    },
+  ];
+}
+
+export function buildFireworksProvider(): ModelProviderConfig {
+  return {
+    baseUrl: FIREWORKS_BASE_URL,
+    api: "openai-completions",
+    models: buildFireworksCatalogModels(),
+  };
+}

openclaw/extensions/fireworks/stream.test.ts

@@ -0,0 +1,155 @@
+import type { StreamFn } from "@mariozechner/pi-agent-core";
+import type { Context, Model } from "@mariozechner/pi-ai";
+import { describe, expect, it } from "vitest";
+import {
+  createFireworksKimiThinkingDisabledWrapper,
+  wrapFireworksProviderStream,
+} from "./stream.js";
+
+function capturePayload(params: {
+  provider: string;
+  api: string;
+  modelId: string;
+  initialPayload?: Record<string, unknown>;
+}): Record<string, unknown> {
+  let captured: Record<string, unknown> = {};
+  const baseStreamFn: StreamFn = (_model, _context, options) => {
+    const payload = { ...params.initialPayload };
+    options?.onPayload?.(payload, _model);
+    captured = payload;
+    return {} as ReturnType<StreamFn>;
+  };
+
+  const wrapped = createFireworksKimiThinkingDisabledWrapper(baseStreamFn);
+  void wrapped(
+    {
+      api: params.api,
+      provider: params.provider,
+      id: params.modelId,
+    } as Model<"openai-completions">,
+    { messages: [] } as Context,
+    {},
+  );
+
+  return captured;
+}
+
+describe("createFireworksKimiThinkingDisabledWrapper", () => {
+  it("forces thinking disabled for Fireworks Kimi models", () => {
+    expect(
+      capturePayload({
+        provider: "fireworks",
+        api: "openai-completions",
+        modelId: "accounts/fireworks/routers/kimi-k2p5-turbo",
+      }),
+    ).toMatchObject({ thinking: { type: "disabled" } });
+  });
+
+  it("forces thinking disabled for Fireworks Kimi k2.5 aliases", () => {
+    expect(
+      capturePayload({
+        provider: "fireworks",
+        api: "openai-completions",
+        modelId: "accounts/fireworks/routers/kimi-k2.5-turbo",
+      }),
+    ).toMatchObject({ thinking: { type: "disabled" } });
+  });
+
+  it("strips reasoning fields when disabling Fireworks Kimi thinking", () => {
+    const payload = capturePayload({
+      provider: "fireworks",
+      api: "openai-completions",
+      modelId: "accounts/fireworks/models/kimi-k2p5",
+      initialPayload: {
+        reasoning_effort: "low",
+        reasoning: { effort: "low" },
+        reasoningEffort: "low",
+      },
+    });
+
+    expect(payload).toEqual({ thinking: { type: "disabled" } });
+  });
+
+  it("passes sanitized payloads to caller onPayload hooks", () => {
+    let callbackPayload: Record<string, unknown> = {};
+    const baseStreamFn: StreamFn = (_model, _context, options) => {
+      const payload = {
+        reasoning_effort: "high",
+        reasoning: { effort: "high" },
+      };
+      options?.onPayload?.(payload, _model);
+      return {} as ReturnType<StreamFn>;
+    };
+
+    const wrapped = createFireworksKimiThinkingDisabledWrapper(baseStreamFn);
+    void wrapped(
+      {
+        api: "openai-completions",
+        provider: "fireworks",
+        id: "accounts/fireworks/routers/kimi-k2p5-turbo",
+      } as Model<"openai-completions">,
+      { messages: [] } as Context,
+      {
+        onPayload: (payload) => {
+          callbackPayload = payload as Record<string, unknown>;
+        },
+      },
+    );
+
+    expect(callbackPayload).toEqual({ thinking: { type: "disabled" } });
+  });
+
+  it("returns no provider wrapper for non-target Fireworks requests", () => {
+    expect(
+      wrapFireworksProviderStream({
+        provider: "fireworks",
+        modelId: "accounts/fireworks/models/qwen3.6-plus",
+        model: {
+          api: "openai-completions",
+          provider: "fireworks",
+          id: "accounts/fireworks/models/qwen3.6-plus",
+        } as Model<"openai-completions">,
+        streamFn: undefined,
+      } as never),
+    ).toBeUndefined();
+
+    expect(
+      wrapFireworksProviderStream({
+        provider: "fireworks",
+        modelId: "accounts/fireworks/routers/kimi-k2p5-turbo",
+        model: {
+          api: "openai-responses",
+          provider: "fireworks",
+          id: "accounts/fireworks/routers/kimi-k2p5-turbo",
+        } as Model<"openai-responses">,
+        streamFn: undefined,
+      } as never),
+    ).toBeUndefined();
+
+    expect(
+      wrapFireworksProviderStream({
+        provider: "fireworks-ai",
+        modelId: "accounts/fireworks/routers/kimi-k2p5-turbo",
+        model: {
+          api: "openai-completions",
+          provider: "fireworks-ai",
+          id: "accounts/fireworks/routers/kimi-k2p5-turbo",
+        } as Model<"openai-completions">,
+        streamFn: undefined,
+      } as never),
+    ).toBeTypeOf("function");
+
+    expect(
+      wrapFireworksProviderStream({
+        provider: "openai",
+        modelId: "gpt-5.4",
+        model: {
+          api: "openai-completions",
+          provider: "openai",
+          id: "gpt-5.4",
+        } as Model<"openai-completions">,
+        streamFn: undefined,
+      } as never),
+    ).toBeUndefined();
+  });
+});

openclaw/extensions/fireworks/stream.ts

@@ -0,0 +1,39 @@
+import type { StreamFn } from "@mariozechner/pi-agent-core";
+import { streamSimple } from "@mariozechner/pi-ai";
+import type { ProviderWrapStreamFnContext } from "openclaw/plugin-sdk/plugin-entry";
+import { normalizeProviderId } from "openclaw/plugin-sdk/provider-model-shared";
+import { streamWithPayloadPatch } from "openclaw/plugin-sdk/provider-stream-shared";
+import { isFireworksKimiModelId } from "./model-id.js";
+
+function isFireworksProviderId(providerId: string): boolean {
+  const normalized = normalizeProviderId(providerId);
+  return normalized === "fireworks" || normalized === "fireworks-ai";
+}
+
+export function createFireworksKimiThinkingDisabledWrapper(
+  baseStreamFn: StreamFn | undefined,
+): StreamFn {
+  const underlying = baseStreamFn ?? streamSimple;
+  return (model, context, options) =>
+    streamWithPayloadPatch(underlying, model, context, options, (payloadObj) => {
+      // Fireworks Kimi can emit chain-of-thought in visible `content` unless
+      // the Anthropic-style thinking toggle is explicitly disabled.
+      payloadObj.thinking = { type: "disabled" };
+      delete payloadObj.reasoning;
+      delete payloadObj.reasoning_effort;
+      delete payloadObj.reasoningEffort;
+    });
+}
+
+export function wrapFireworksProviderStream(
+  ctx: ProviderWrapStreamFnContext,
+): StreamFn | undefined {
+  if (
+    !isFireworksProviderId(ctx.provider) ||
+    ctx.model?.api !== "openai-completions" ||
+    !isFireworksKimiModelId(ctx.modelId)
+  ) {
+    return undefined;
+  }
+  return createFireworksKimiThinkingDisabledWrapper(ctx.streamFn);
+}

openclaw/extensions/fireworks/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"
+  ]
+}