@full-self-developing/fsd 1.0.0

package/extensions/fireworks/index.test.ts

@@ -0,0 +1,181 @@
+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,
+  FIREWORKS_K2_6_CONTEXT_WINDOW,
+  FIREWORKS_K2_6_MAX_TOKENS,
+  FIREWORKS_K2_6_MODEL_ID,
+} from "./provider-catalog.js";
+import { resolveThinkingProfile } from "./provider-policy-api.js";
+
+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_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(FIREWORKS_K2_6_CONTEXT_WINDOW);
+    expect(models[0]?.maxTokens).toBe(FIREWORKS_K2_6_MAX_TOKENS);
+    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);
+  });
+
+  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);
+  });
+
+  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("disables reasoning metadata for Fireworks Kimi k2.6 dynamic models", async () => {
+    const provider = await registerSingleProviderPlugin(fireworksPlugin);
+    const resolved = provider.resolveDynamicModel?.(
+      createProviderDynamicModelContext({
+        provider: "fireworks",
+        modelId: "accounts/fireworks/models/kimi-k2p6",
+        models: [createFireworksDefaultRuntimeModel({ reasoning: false })],
+      }),
+    );
+
+    expect(resolved?.provider).toBe("fireworks");
+    expect(resolved?.id).toBe("accounts/fireworks/models/kimi-k2p6");
+    expect(resolved?.reasoning).toBe(false);
+  });
+
+  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_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_K2_6_MODEL_ID })).toEqual({
+      levels: [{ id: "off" }],
+      defaultLevel: "off",
+    });
+    expect(
+      resolveThinkingProfile({
+        modelId: "accounts/fireworks/models/qwen3.6-plus",
+      }),
+    ).toBeUndefined();
+  });
+});

package/extensions/fireworks/index.ts

@@ -0,0 +1,85 @@
+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";
+import { resolveFireworksThinkingProfile } from "./thinking-policy.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,
+    resolveThinkingProfile: ({ modelId }) => resolveFireworksThinkingProfile(modelId),
+    resolveDynamicModel: (ctx) => resolveFireworksDynamicModel(ctx),
+    isModernModelRef: () => true,
+  },
+});

package/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(?:p[56]|[.-][56])(?:[-_].+)?$/.test(lastSegment);
+}

package/extensions/fireworks/onboard.ts

@@ -0,0 +1,30 @@
+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);
+}

package/extensions/fireworks/openclaw.plugin.json

@@ -0,0 +1,73 @@
+{
+  "id": "fireworks",
+  "activation": {
+    "onStartup": false
+  },
+  "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"
+    }
+  ],
+  "modelCatalog": {
+    "providers": {
+      "fireworks": {
+        "baseUrl": "https://api.fireworks.ai/inference/v1",
+        "api": "openai-completions",
+        "models": [
+          {
+            "id": "accounts/fireworks/models/kimi-k2p6",
+            "name": "Kimi K2.6",
+            "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)",
+            "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": {}
+  }
+}

package/extensions/fireworks/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "@openclaw/fireworks-provider",
+  "version": "2026.5.21",
+  "private": true,
+  "description": "OpenClaw Fireworks provider plugin",
+  "type": "module",
+  "dependencies": {
+    "@earendil-works/pi-ai": "0.75.4"
+  },
+  "devDependencies": {
+    "@openclaw/plugin-sdk": "workspace:*"
+  },
+  "openclaw": {
+    "extensions": [
+      "./index.ts"
+    ]
+  }
+}

package/extensions/fireworks/provider-catalog.ts

@@ -0,0 +1,50 @@
+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";
+export const FIREWORKS_K2_6_MODEL_ID = "accounts/fireworks/models/kimi-k2p6";
+
+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);
+const FIREWORKS_K2_6_MODEL = requireFireworksManifestModel(FIREWORKS_K2_6_MODEL_ID);
+
+export const FIREWORKS_DEFAULT_CONTEXT_WINDOW = FIREWORKS_DEFAULT_MODEL.contextWindow;
+export const FIREWORKS_DEFAULT_MAX_TOKENS = FIREWORKS_DEFAULT_MODEL.maxTokens;
+export const FIREWORKS_K2_6_CONTEXT_WINDOW = FIREWORKS_K2_6_MODEL.contextWindow;
+export const FIREWORKS_K2_6_MAX_TOKENS = FIREWORKS_K2_6_MODEL.maxTokens;
+
+function cloneFireworksCatalogModel(model: ModelDefinitionConfig): ModelDefinitionConfig {
+  return {
+    ...model,
+    input: [...model.input],
+    cost: { ...model.cost },
+  };
+}
+
+export function buildFireworksCatalogModels(): ModelDefinitionConfig[] {
+  return FIREWORKS_MANIFEST_PROVIDER.models.map(cloneFireworksCatalogModel);
+}
+
+export function buildFireworksProvider(): ModelProviderConfig {
+  return buildManifestModelProviderConfig({
+    providerId: "fireworks",
+    catalog: manifest.modelCatalog.providers.fireworks,
+  });
+}

package/extensions/fireworks/provider-policy-api.ts

@@ -0,0 +1,8 @@
+import { resolveFireworksThinkingProfile } from "./thinking-policy.js";
+
+export function resolveThinkingProfile(params: {
+  provider?: string;
+  modelId: string;
+}): ReturnType<typeof resolveFireworksThinkingProfile> {
+  return resolveFireworksThinkingProfile(params.modelId);
+}

package/extensions/fireworks/stream.test.ts

@@ -0,0 +1,184 @@
+import type { StreamFn } from "@earendil-works/pi-agent-core";
+import type { Context, Model } from "@earendil-works/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",
+      }),
+    ).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();
+  });
+});

package/extensions/fireworks/stream.ts

@@ -0,0 +1,39 @@
+import type { StreamFn } from "@earendil-works/pi-agent-core";
+import { streamSimple } from "@earendil-works/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);
+}