Vendor OpenClaw source as Adolf fork baseline

Adolf is a fork/vendored clone of github.com/openclaw/openclaw (v2026.6.11),
free to diverge. Tree copied sans upstream .git; upstream remote added for
future syncs. Node pinned to 24 (.nvmrc); engines already require >=22.19.
Preserves docs/ARCHITECTURE.md.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LeqyaxJF2nbRXJtae2kNB2

extensions/fireworks/README.md

@@ -0,0 +1,13 @@
+# Fireworks OpenClaw provider
+
+Official OpenClaw provider plugin for Fireworks.
+
+## Install
+
+```sh
+openclaw plugins install @openclaw/fireworks-provider
+```
+
+## Docs
+
+See `docs/providers/fireworks.md` in the OpenClaw repository, or the published docs at `https://docs.openclaw.ai/providers/fireworks`.

extensions/fireworks/index.test.ts

@@ -0,0 +1,198 @@
+// Fireworks tests cover index plugin behavior.
+import type { ProviderRuntimeModel } from "openclaw/plugin-sdk/plugin-entry";
+import {
+  registerSingleProviderPlugin,
+  resolveProviderPluginChoice,
+} from "openclaw/plugin-sdk/plugin-test-runtime";
+import { describe, expect, it } from "vitest";
+import {
+  createProviderDynamicModelContext,
+  runSingleProviderCatalog,
+} from "../test-support/provider-model-test-helpers.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";
+import { resolveThinkingProfile } from "./provider-policy-api.js";
+
+const FIREWORKS_KIMI_K2_6_MODEL_ID = "accounts/fireworks/models/kimi-k2p6";
+
+function createFireworksDefaultRuntimeModel(params: { reasoning: boolean }): ProviderRuntimeModel {
+  return {
+    id: FIREWORKS_DEFAULT_MODEL_ID,
+    name: FIREWORKS_DEFAULT_MODEL_ID,
+    provider: "fireworks",
+    api: "openai-completions",
+    baseUrl: FIREWORKS_BASE_URL,
+    reasoning: params.reasoning,
+    input: ["text", "image"],
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    contextWindow: FIREWORKS_DEFAULT_CONTEXT_WINDOW,
+    maxTokens: FIREWORKS_DEFAULT_MAX_TOKENS,
+  };
+}
+
+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);
+    if (!resolved) {
+      throw new Error("expected Fireworks api-key auth choice");
+    }
+    expect(resolved.provider.id).toBe("fireworks");
+    expect(resolved.method.id).toBe("api-key");
+  });
+
+  it("builds the Fireworks catalog", async () => {
+    const provider = await registerSingleProviderPlugin(fireworksPlugin);
+    const catalogProvider = await runSingleProviderCatalog(provider);
+
+    expect(catalogProvider.api).toBe("openai-completions");
+    expect(catalogProvider.baseUrl).toBe(FIREWORKS_BASE_URL);
+    const models = catalogProvider.models;
+    if (!models) {
+      throw new Error("expected Fireworks catalog models");
+    }
+    expect(models.map((model) => model.id)).toEqual([
+      FIREWORKS_KIMI_K2_6_MODEL_ID,
+      FIREWORKS_DEFAULT_MODEL_ID,
+    ]);
+    expect(models[0]?.reasoning).toBe(false);
+    expect(models[0]?.input).toEqual(["text", "image"]);
+    expect(models[0]?.contextWindow).toBe(262144);
+    expect(models[0]?.maxTokens).toBe(262144);
+    expect(models[1]?.reasoning).toBe(false);
+    expect(models[1]?.input).toEqual(["text", "image"]);
+    expect(models[1]?.contextWindow).toBe(FIREWORKS_DEFAULT_CONTEXT_WINDOW);
+    expect(models[1]?.maxTokens).toBe(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?.(
+      createProviderDynamicModelContext({
+        provider: "fireworks",
+        modelId: "accounts/fireworks/models/qwen3.6-plus",
+        models: [createFireworksDefaultRuntimeModel({ reasoning: true })],
+      }),
+    );
+
+    expect(resolved?.provider).toBe("fireworks");
+    expect(resolved?.id).toBe("accounts/fireworks/models/qwen3.6-plus");
+    expect(resolved?.api).toBe("openai-completions");
+    expect(resolved?.baseUrl).toBe(FIREWORKS_BASE_URL);
+    expect(resolved?.reasoning).toBe(true);
+    expect(resolved?.input).toEqual(["text", "image"]);
+  });
+
+  it("disables reasoning metadata for Fireworks Kimi dynamic models", async () => {
+    const provider = await registerSingleProviderPlugin(fireworksPlugin);
+    const resolved = provider.resolveDynamicModel?.(
+      createProviderDynamicModelContext({
+        provider: "fireworks",
+        modelId: "accounts/fireworks/models/kimi-k2p5",
+        models: [createFireworksDefaultRuntimeModel({ reasoning: false })],
+      }),
+    );
+
+    expect(resolved?.provider).toBe("fireworks");
+    expect(resolved?.id).toBe("accounts/fireworks/models/kimi-k2p5");
+    expect(resolved?.reasoning).toBe(false);
+    expect(resolved?.input).toEqual(["text", "image"]);
+  });
+
+  it("keeps Fireworks GLM dynamic models text-only", async () => {
+    const provider = await registerSingleProviderPlugin(fireworksPlugin);
+    const resolved = provider.resolveDynamicModel?.(
+      createProviderDynamicModelContext({
+        provider: "fireworks",
+        modelId: "accounts/fireworks/models/glm-5p1",
+        models: [createFireworksDefaultRuntimeModel({ reasoning: false })],
+      }),
+    );
+
+    expect(resolved?.provider).toBe("fireworks");
+    expect(resolved?.id).toBe("accounts/fireworks/models/glm-5p1");
+    expect(resolved?.input).toEqual(["text"]);
+  });
+
+  it("disables reasoning metadata for Fireworks Kimi k2.5 aliases", async () => {
+    const provider = await registerSingleProviderPlugin(fireworksPlugin);
+    const resolved = provider.resolveDynamicModel?.(
+      createProviderDynamicModelContext({
+        provider: "fireworks",
+        modelId: "accounts/fireworks/routers/kimi-k2.5-turbo",
+        models: [createFireworksDefaultRuntimeModel({ reasoning: false })],
+      }),
+    );
+
+    expect(resolved?.provider).toBe("fireworks");
+    expect(resolved?.id).toBe("accounts/fireworks/routers/kimi-k2.5-turbo");
+    expect(resolved?.reasoning).toBe(false);
+  });
+
+  it("defers manifest catalog models to core static-catalog resolution", async () => {
+    const provider = await registerSingleProviderPlugin(fireworksPlugin);
+    for (const modelId of [FIREWORKS_KIMI_K2_6_MODEL_ID, FIREWORKS_DEFAULT_MODEL_ID]) {
+      const resolved = provider.resolveDynamicModel?.(
+        createProviderDynamicModelContext({
+          provider: "fireworks",
+          modelId,
+          models: [createFireworksDefaultRuntimeModel({ reasoning: false })],
+        }),
+      );
+
+      expect(resolved).toBeUndefined();
+    }
+  });
+
+  it("exposes off-only thinking policy for Fireworks Kimi models", async () => {
+    const provider = await registerSingleProviderPlugin(fireworksPlugin);
+
+    expect(
+      provider.resolveThinkingProfile?.({
+        provider: "fireworks",
+        modelId: "accounts/fireworks/routers/kimi-k2p5-turbo",
+      }),
+    ).toEqual({
+      levels: [{ id: "off" }],
+      defaultLevel: "off",
+    });
+    expect(
+      provider.resolveThinkingProfile?.({
+        provider: "fireworks",
+        modelId: FIREWORKS_KIMI_K2_6_MODEL_ID,
+      }),
+    ).toEqual({
+      levels: [{ id: "off" }],
+      defaultLevel: "off",
+    });
+    expect(
+      provider.resolveThinkingProfile?.({
+        provider: "fireworks",
+        modelId: "accounts/fireworks/models/qwen3.6-plus",
+      }),
+    ).toBeUndefined();
+    expect(resolveThinkingProfile({ modelId: FIREWORKS_KIMI_K2_6_MODEL_ID })).toEqual({
+      levels: [{ id: "off" }],
+      defaultLevel: "off",
+    });
+    expect(
+      resolveThinkingProfile({
+        modelId: "accounts/fireworks/models/qwen3.6-plus",
+      }),
+    ).toBeUndefined();
+  });
+});

extensions/fireworks/index.ts

@@ -0,0 +1,106 @@
+// Fireworks plugin entrypoint registers its OpenClaw integration.
+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,
+  isFireworksCatalogModelId,
+} from "./provider-catalog.js";
+import { wrapFireworksProviderStream } from "./stream.js";
+import { resolveFireworksThinkingProfile } from "./thinking-policy.js";
+
+const PROVIDER_ID = "fireworks";
+
+function isFireworksGlmModelId(modelId: string): boolean {
+  const normalized = modelId.trim().toLowerCase();
+  const lastSegment = normalized.split("/").pop() ?? normalized;
+  return /^glm[-_.]/.test(lastSegment);
+}
+
+function resolveFireworksDynamicInput(modelId: string): Array<"text" | "image"> {
+  return isFireworksGlmModelId(modelId) ? ["text"] : ["text", "image"];
+}
+
+function resolveFireworksDynamicModel(ctx: ProviderResolveDynamicModelContext) {
+  const modelId = ctx.modelId.trim();
+  if (!modelId) {
+    return undefined;
+  }
+
+  if (isFireworksCatalogModelId(modelId)) {
+    return undefined;
+  }
+
+  const isKimiModel = isFireworksKimiModelId(modelId);
+  const input = resolveFireworksDynamicInput(modelId);
+
+  return (
+    cloneFirstTemplateModel({
+      providerId: PROVIDER_ID,
+      modelId,
+      templateIds: [FIREWORKS_DEFAULT_MODEL_ID],
+      ctx,
+      patch: {
+        provider: PROVIDER_ID,
+        reasoning: !isKimiModel,
+        input,
+      },
+    }) ??
+    normalizeModelCompat({
+      id: modelId,
+      name: modelId,
+      provider: PROVIDER_ID,
+      api: "openai-completions",
+      baseUrl: FIREWORKS_BASE_URL,
+      reasoning: !isKimiModel,
+      input,
+      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,
+    resolveThinkingProfile: ({ modelId }) => resolveFireworksThinkingProfile(modelId),
+    resolveDynamicModel: (ctx) => resolveFireworksDynamicModel(ctx),
+    isModernModelRef: () => true,
+  },
+});

extensions/fireworks/model-id.ts

@@ -0,0 +1,6 @@
+// Fireworks plugin module implements model id behavior.
+export function isFireworksKimiModelId(modelId: string): boolean {
+  const normalized = modelId.trim().toLowerCase();
+  const lastSegment = normalized.split("/").pop() ?? normalized;
+  return /^kimi-k2(?:p[56]|[.-][56])(?:[-_].+)?$/.test(lastSegment);
+}

extensions/fireworks/npm-shrinkwrap.json

@@ -0,0 +1,12 @@
+{
+  "name": "@openclaw/fireworks-provider",
+  "version": "2026.6.11",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "@openclaw/fireworks-provider",
+      "version": "2026.6.11"
+    }
+  }
+}

extensions/fireworks/onboard.ts

@@ -0,0 +1,31 @@
+// Fireworks setup module handles plugin onboarding behavior.
+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 applyFireworksConfig(cfg: OpenClawConfig): OpenClawConfig {
+  return fireworksPresetAppliers.applyConfig(cfg);
+}

extensions/fireworks/openclaw.plugin.json

@@ -0,0 +1,80 @@
+{
+  "id": "fireworks",
+  "activation": {
+    "onStartup": false
+  },
+  "enabledByDefault": true,
+  "providers": ["fireworks"],
+  "setup": {
+    "providers": [
+      {
+        "id": "fireworks",
+        "envVars": ["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"
+    }
+  ],
+  "modelCatalog": {
+    "providers": {
+      "fireworks": {
+        "baseUrl": "https://api.fireworks.ai/inference/v1",
+        "api": "openai-completions",
+        "models": [
+          {
+            "id": "accounts/fireworks/models/kimi-k2p6",
+            "name": "Kimi K2.6",
+            "reasoning": false,
+            "input": ["text", "image"],
+            "contextWindow": 262144,
+            "maxTokens": 262144,
+            "cost": {
+              "input": 0.95,
+              "output": 4,
+              "cacheRead": 0,
+              "cacheWrite": 0
+            }
+          },
+          {
+            "id": "accounts/fireworks/routers/kimi-k2p5-turbo",
+            "name": "Kimi K2.5 Turbo (Fire Pass)",
+            "reasoning": false,
+            "input": ["text", "image"],
+            "contextWindow": 256000,
+            "maxTokens": 256000,
+            "compat": {
+              "unsupportedToolSchemaKeywords": ["not"]
+            },
+            "cost": {
+              "input": 0,
+              "output": 0,
+              "cacheRead": 0,
+              "cacheWrite": 0
+            }
+          }
+        ]
+      }
+    },
+    "discovery": {
+      "fireworks": "static"
+    }
+  },
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {}
+  }
+}

extensions/fireworks/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@openclaw/fireworks-provider",
+  "version": "2026.6.11",
+  "description": "OpenClaw Fireworks provider plugin",
+  "type": "module",
+  "devDependencies": {
+    "@openclaw/plugin-sdk": "workspace:*"
+  },
+  "openclaw": {
+    "extensions": [
+      "./index.ts"
+    ],
+    "install": {
+      "clawhubSpec": "clawhub:@openclaw/fireworks-provider",
+      "npmSpec": "@openclaw/fireworks-provider",
+      "defaultChoice": "npm",
+      "minHostVersion": ">=2026.6.9"
+    },
+    "compat": {
+      "pluginApi": ">=2026.6.11"
+    },
+    "build": {
+      "openclawVersion": "2026.6.11",
+      "bundledDist": false
+    },
+    "release": {
+      "publishToClawHub": true,
+      "publishToNpm": true
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/openclaw/openclaw"
+  }
+}

extensions/fireworks/provider-catalog.ts

@@ -0,0 +1,43 @@
+// Fireworks provider module implements model/runtime integration.
+import { buildManifestModelProviderConfig } from "openclaw/plugin-sdk/provider-catalog-shared";
+import type {
+  ModelDefinitionConfig,
+  ModelProviderConfig,
+} from "openclaw/plugin-sdk/provider-model-shared";
+import manifest from "./openclaw.plugin.json" with { type: "json" };
+
+const FIREWORKS_MANIFEST_PROVIDER = buildManifestModelProviderConfig({
+  providerId: "fireworks",
+  catalog: manifest.modelCatalog.providers.fireworks,
+});
+
+export const FIREWORKS_BASE_URL = FIREWORKS_MANIFEST_PROVIDER.baseUrl;
+export const FIREWORKS_DEFAULT_MODEL_ID = "accounts/fireworks/routers/kimi-k2p5-turbo";
+
+function requireFireworksManifestModel(id: string): ModelDefinitionConfig {
+  const model = FIREWORKS_MANIFEST_PROVIDER.models.find((entry) => entry.id === id);
+  if (!model) {
+    throw new Error(`Missing Fireworks modelCatalog row ${id}`);
+  }
+  return model;
+}
+
+const FIREWORKS_DEFAULT_MODEL = requireFireworksManifestModel(FIREWORKS_DEFAULT_MODEL_ID);
+
+export const FIREWORKS_DEFAULT_CONTEXT_WINDOW = FIREWORKS_DEFAULT_MODEL.contextWindow;
+export const FIREWORKS_DEFAULT_MAX_TOKENS = FIREWORKS_DEFAULT_MODEL.maxTokens;
+
+export function isFireworksCatalogModelId(modelId: string): boolean {
+  return FIREWORKS_MANIFEST_PROVIDER.models.some((model) => model.id === modelId);
+}
+
+export function buildFireworksCatalogModels(): ModelDefinitionConfig[] {
+  return FIREWORKS_MANIFEST_PROVIDER.models.map((model) => structuredClone(model));
+}
+
+export function buildFireworksProvider(): ModelProviderConfig {
+  return buildManifestModelProviderConfig({
+    providerId: "fireworks",
+    catalog: manifest.modelCatalog.providers.fireworks,
+  });
+}

extensions/fireworks/provider-policy-api.ts

@@ -0,0 +1,9 @@
+// Fireworks API module exposes the plugin public contract.
+import { resolveFireworksThinkingProfile } from "./thinking-policy.js";
+
+export function resolveThinkingProfile(params: {
+  provider?: string;
+  modelId: string;
+}): ReturnType<typeof resolveFireworksThinkingProfile> {
+  return resolveFireworksThinkingProfile(params.modelId);
+}

extensions/fireworks/stream.test.ts

@@ -0,0 +1,185 @@
+// Fireworks tests cover stream plugin behavior.
+import type { StreamFn } from "openclaw/plugin-sdk/agent-core";
+import type { Context, Model } from "openclaw/plugin-sdk/llm";
+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",
+      }),
+    ).toEqual({ 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",
+      }),
+    ).toEqual({ thinking: { type: "disabled" } });
+  });
+
+  it("forces thinking disabled for Fireworks Kimi k2.6 models", () => {
+    expect(
+      capturePayload({
+        provider: "fireworks",
+        api: "openai-completions",
+        modelId: "accounts/fireworks/models/kimi-k2p6",
+      }),
+    ).toEqual({ thinking: { type: "disabled" } });
+
+    expect(
+      capturePayload({
+        provider: "fireworks",
+        api: "openai-completions",
+        modelId: "accounts/fireworks/routers/kimi-k2.6-turbo",
+      }),
+    ).toEqual({ thinking: { type: "disabled" } });
+  });
+
+  it("strips reasoning fields when disabling Fireworks Kimi thinking", () => {
+    const k2p5Payload = capturePayload({
+      provider: "fireworks",
+      api: "openai-completions",
+      modelId: "accounts/fireworks/models/kimi-k2p5",
+      initialPayload: {
+        reasoning_effort: "low",
+        reasoning: { effort: "low" },
+        reasoningEffort: "low",
+      },
+    });
+    const k2p6Payload = capturePayload({
+      provider: "fireworks",
+      api: "openai-completions",
+      modelId: "accounts/fireworks/models/kimi-k2p6",
+      initialPayload: {
+        reasoning_effort: "low",
+        reasoning: { effort: "low" },
+        reasoningEffort: "low",
+      },
+    });
+
+    expect(k2p5Payload).toEqual({ thinking: { type: "disabled" } });
+    expect(k2p6Payload).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();
+  });
+});

extensions/fireworks/stream.ts

@@ -0,0 +1,40 @@
+// Fireworks plugin module implements stream behavior.
+import type { StreamFn } from "openclaw/plugin-sdk/agent-core";
+import { streamSimple } from "openclaw/plugin-sdk/llm";
+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);
+}

extensions/fireworks/thinking-policy.ts

@@ -0,0 +1,18 @@
+// Fireworks plugin module implements thinking policy behavior.
+import type { ProviderThinkingProfile } from "openclaw/plugin-sdk/plugin-entry";
+import { isFireworksKimiModelId } from "./model-id.js";
+
+const FIREWORKS_KIMI_THINKING_PROFILE = {
+  levels: [{ id: "off" }],
+  defaultLevel: "off",
+} as const satisfies ProviderThinkingProfile;
+
+export function resolveFireworksThinkingProfile(
+  modelId: string,
+): ProviderThinkingProfile | undefined {
+  if (!isFireworksKimiModelId(modelId)) {
+    return undefined;
+  }
+
+  return FIREWORKS_KIMI_THINKING_PROFILE;
+}

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"
+  ]
+}