- `openclaw/plugin-sdk/provider-model-shared` - `ProviderReplayFamily`, `buildProviderReplayFamilyHooks(...)`, and the raw replay builders (`buildOpenAICompatibleReplayPolicy`, `buildAnthropicReplayPolicyForModel`, `buildGoogleGeminiReplayPolicy`, `buildHybridAnthropicOrOpenAIReplayPolicy`). Also exports Gemini replay helpers (`sanitizeGoogleGeminiReplayHistory`, `resolveTaggedReasoningOutputMode`) and endpoint/model helpers (`resolveProviderEndpoint`, `normalizeProviderId`, `normalizeGooglePreviewModelId`).

- `openclaw/plugin-sdk/provider-stream` - `ProviderStreamFamily`, `buildProviderStreamFamilyHooks(...)`, `composeProviderStreamWrappers(...)`, plus the shared OpenAI/Codex wrappers (`createOpenAIAttributionHeadersWrapper`, `createOpenAIFastModeWrapper`, `createOpenAIServiceTierWrapper`, `createOpenAIResponsesContextManagementWrapper`, `createCodexNativeWebSearchWrapper`), DeepSeek V4 OpenAI-compatible wrapper (`createDeepSeekV4OpenAICompatibleThinkingWrapper`), Anthropic Messages thinking prefill cleanup (`createAnthropicThinkingPrefillPayloadWrapper`), plain-text tool-call compat (`createPlainTextToolCallCompatWrapper`), and shared proxy/provider wrappers (`createOpenRouterWrapper`, `createToolStreamWrapper`, `createMinimaxFastModeWrapper`).

- `openclaw/plugin-sdk/provider-stream-shared` - lightweight payload and event wrappers for hot provider paths, including `createOpenAICompatibleCompletionsThinkingOffWrapper`, `createPayloadPatchStreamWrapper`, `createPlainTextToolCallCompatWrapper`, and `setQwenChatTemplateThinking(...)`.

- `openclaw/plugin-sdk/provider-stream-shared` - lightweight payload and event wrappers for hot provider paths, including `createOpenAICompatibleCompletionsThinkingOffWrapper`, `createPayloadPatchStreamWrapper`, `createPlainTextToolCallCompatWrapper`, `normalizeOpenAICompatibleReasoningPayload(...)`, and `setQwenChatTemplateThinking(...)`.

- `openclaw/plugin-sdk/provider-tools` - `ProviderToolCompatFamily`, `buildProviderToolCompatFamilyHooks("deepseek" | "gemini" | "openai")`, and underlying provider schema helpers.

For Gemini-family providers, keep the reasoning-output mode aligned with

| `plugin-sdk/provider-tools` | `ProviderToolCompatFamily`, `buildProviderToolCompatFamilyHooks`, and DeepSeek/Gemini/OpenAI schema cleanup + diagnostics |

| `plugin-sdk/provider-usage` | Provider usage snapshot types, shared usage fetch helpers, and provider fetchers such as `fetchClaudeUsage` |

| `plugin-sdk/provider-stream` | `ProviderStreamFamily`, `buildProviderStreamFamilyHooks`, `composeProviderStreamWrappers`, stream wrapper types, plain-text tool-call compat, and shared Anthropic/Bedrock/DeepSeek V4/Google/Kilocode/Moonshot/OpenAI/OpenRouter/Z.A.I/MiniMax/Copilot wrapper helpers |

| `plugin-sdk/provider-stream-shared` | Public shared provider stream wrapper helpers including `composeProviderStreamWrappers`, `createOpenAICompatibleCompletionsThinkingOffWrapper`, `createPlainTextToolCallCompatWrapper`, `createPayloadPatchStreamWrapper`, `createToolStreamWrapper`, `setQwenChatTemplateThinking`, and Anthropic/DeepSeek/OpenAI-compatible stream utilities |

| `plugin-sdk/provider-stream-shared` | Public shared provider stream wrapper helpers including `composeProviderStreamWrappers`, `createOpenAICompatibleCompletionsThinkingOffWrapper`, `createPlainTextToolCallCompatWrapper`, `createPayloadPatchStreamWrapper`, `createToolStreamWrapper`, `normalizeOpenAICompatibleReasoningPayload`, `setQwenChatTemplateThinking`, and Anthropic/DeepSeek/OpenAI-compatible stream utilities |

| `plugin-sdk/provider-transport-runtime` | Native provider transport helpers such as guarded fetch, transport message transforms, and writable transport event streams |

| `plugin-sdk/provider-onboard` | Onboarding config patch helpers |

| `plugin-sdk/global-singleton` | Process-local singleton/map/cache helpers |

// Kilocode plugin module implements stream behavior.

import type { ProviderWrapStreamFnContext } from "openclaw/plugin-sdk/plugin-entry";

import { resolveProviderRequestHeaders } from "openclaw/plugin-sdk/provider-http";

import { normalizeOpenAICompatibleReasoningPayload } from "openclaw/plugin-sdk/provider-stream-shared";

import { normalizeOptionalLowercaseString } from "openclaw/plugin-sdk/string-coerce-runtime";

const KILOCODE_FEATURE_HEADER = "X-KILOCODE-FEATURE";

type ThinkLevel = NonNullable<ProviderWrapStreamFnContext["thinkingLevel"]>;

type ProviderStreamFn = NonNullable<ProviderWrapStreamFnContext["streamFn"]>;

type ReasoningEffort = "none" | "minimal" | "low" | "medium" | "high" | "xhigh";

function resolveKilocodeAppHeaders(): Record<string, string> {

const feature = process.env[KILOCODE_FEATURE_ENV_VAR]?.trim() || KILOCODE_FEATURE_DEFAULT;

return { [KILOCODE_FEATURE_HEADER]: feature };

}

function mapThinkingLevelToReasoningEffort(thinkingLevel: ThinkLevel): ReasoningEffort {

if (thinkingLevel === "off") {

return "none";

}

if (thinkingLevel === "adaptive") {

return "medium";

}

if (thinkingLevel === "max") {

return "xhigh";

}

return thinkingLevel;

}

function normalizeKilocodeReasoningPayload(

payloadObj: Record<string, unknown>,

thinkingLevel?: ThinkLevel,

): void {

delete payloadObj.reasoning_effort;

if (!thinkingLevel || thinkingLevel === "off") {

return;

}

const existingReasoning = payloadObj.reasoning;

if (

existingReasoning &&

typeof existingReasoning === "object" &&

!Array.isArray(existingReasoning)

) {

const reasoningObj = existingReasoning as Record<string, unknown>;

if (!("max_tokens" in reasoningObj) && !("effort" in reasoningObj)) {

reasoningObj.effort = mapThinkingLevelToReasoningEffort(thinkingLevel);

}

} else if (!existingReasoning) {

payloadObj.reasoning = {

effort: mapThinkingLevelToReasoningEffort(thinkingLevel),

};

}

}

function normalizeKilocodeStopPayload(payloadObj: Record<string, unknown>): void {

if (typeof payloadObj.stop === "string") {

payloadObj.stop = [payloadObj.stop];

const payloadObj = asRecord(payload);

if (payloadObj) {

// Keep Kilo thinking defaults overrideable by later caller/config payload hooks.

normalizeKilocodeReasoningPayload(payloadObj, thinkingLevel);

normalizeOpenAICompatibleReasoningPayload(payloadObj, thinkingLevel);

}

const result = originalOnPayload?.(payload, payloadModel);

try {

budgets = {

publicEntrypoints: readBudgetEnv("OPENCLAW_PLUGIN_SDK_MAX_PUBLIC_ENTRYPOINTS", 321),

publicExports: readBudgetEnv("OPENCLAW_PLUGIN_SDK_MAX_PUBLIC_EXPORTS", 10328),

publicFunctionExports: readBudgetEnv("OPENCLAW_PLUGIN_SDK_MAX_PUBLIC_FUNCTION_EXPORTS", 5185),

publicExports: readBudgetEnv("OPENCLAW_PLUGIN_SDK_MAX_PUBLIC_EXPORTS", 10329),

publicFunctionExports: readBudgetEnv("OPENCLAW_PLUGIN_SDK_MAX_PUBLIC_FUNCTION_EXPORTS", 5186),

publicDeprecatedExports: readBudgetEnv(

"OPENCLAW_PLUGIN_SDK_MAX_PUBLIC_DEPRECATED_EXPORTS",

3247,

import type { StreamFn } from "../../../agents/runtime/index.js";

import type { ThinkLevel } from "../../../auto-reply/thinking.js";

import { parseStrictFiniteNumber } from "../../../infra/parse-finite-number.js";

import { normalizeOpenAICompatibleReasoningPayload } from "../../../plugin-sdk/provider-stream-shared.js";

import { streamSimple } from "../../stream.js";

import {

applyAnthropicEphemeralCacheControlMarkers,

resolveAnthropicEphemeralCacheControl,

} from "./anthropic-cache-control-payload.js";

import { isAnthropicModelRef } from "./anthropic-family-cache-semantics.js";

import { mapThinkingLevelToReasoningEffort } from "./reasoning-effort-utils.js";

import { streamWithPayloadPatch } from "./stream-payload-utils.js";

const KILOCODE_FEATURE_HEADER = "X-KILOCODE-FEATURE";

const KILOCODE_FEATURE_DEFAULT = "openclaw";

return headers;

}

function normalizeProxyReasoningPayload(payload: unknown, thinkingLevel?: ThinkLevel): void {

if (!payload || typeof payload !== "object") {

return;

}

const payloadObj = payload as Record<string, unknown>;

delete payloadObj.reasoning_effort;

if (!thinkingLevel || thinkingLevel === "off") {

return;

}

const existingReasoning = payloadObj.reasoning;

if (

existingReasoning &&

typeof existingReasoning === "object" &&

!Array.isArray(existingReasoning)

) {

const reasoningObj = existingReasoning as Record<string, unknown>;

if (!("max_tokens" in reasoningObj) && !("effort" in reasoningObj)) {

reasoningObj.effort = mapThinkingLevelToReasoningEffort(thinkingLevel);

}

} else if (!existingReasoning) {

payloadObj.reasoning = {

effort: mapThinkingLevelToReasoningEffort(thinkingLevel),

};

}

}

/** @deprecated OpenRouter provider-owned stream helper; do not use from third-party plugins. */

export function createOpenRouterSystemCacheWrapper(

baseStreamFn: StreamFn | undefined,

headers,

},

(payload) => {

normalizeProxyReasoningPayload(payload, thinkingLevel);

normalizeOpenAICompatibleReasoningPayload(payload, thinkingLevel);

},

);

};

headers,

},

(payload) => {

normalizeProxyReasoningPayload(payload, thinkingLevel);

normalizeOpenAICompatibleReasoningPayload(payload, thinkingLevel);

},

);

};

createPlainTextToolCallCompatWrapper,

defaultToolStreamExtraParams,

isOpenAICompatibleThinkingEnabled,

normalizeOpenAICompatibleReasoningPayload,

setQwenChatTemplateThinking,

stripTrailingAnthropicAssistantPrefillWhenThinking,

} from "./provider-stream-shared.js";

});

});

describe("normalizeOpenAICompatibleReasoningPayload", () => {

it("removes the legacy field and adds the selected reasoning effort", () => {

const payload: Record<string, unknown> = {

reasoning_effort: "high",

};

normalizeOpenAICompatibleReasoningPayload(payload, "adaptive");

expect(payload).toEqual({ reasoning: { effort: "medium" } });

});

it("preserves explicit reasoning controls", () => {

const withMaxTokens: Record<string, unknown> = {

reasoning_effort: "high",

reasoning: { max_tokens: 256 },

};

const withEffort: Record<string, unknown> = {

reasoning_effort: "high",

reasoning: { effort: "low", summary: "auto" },

};

normalizeOpenAICompatibleReasoningPayload(withMaxTokens, "high");

normalizeOpenAICompatibleReasoningPayload(withEffort, "high");

expect(withMaxTokens).toEqual({ reasoning: { max_tokens: 256 } });

expect(withEffort).toEqual({ reasoning: { effort: "low", summary: "auto" } });

});

it("removes only the legacy field when thinking is disabled", () => {

const payload: Record<string, unknown> = {

reasoning_effort: "high",

};

normalizeOpenAICompatibleReasoningPayload(payload, "off");

expect(payload).toEqual({});

});

});

describe("createDeepSeekV4OpenAICompatibleThinkingWrapper", () => {

it("backfills reasoning_content on every replayed assistant message when thinking is enabled", () => {

const payload = {

import { resolveOpenAIReasoningEffortForModel } from "../agents/openai-reasoning-effort.js";

import type { StreamFn } from "../agents/runtime/index.js";

import type { ThinkLevel } from "../auto-reply/thinking.js";

import { mapThinkingLevelToReasoningEffort } from "../llm/providers/stream-wrappers/reasoning-effort-utils.js";

import { streamWithPayloadPatch } from "../llm/providers/stream-wrappers/stream-payload-utils.js";

import { streamSimple } from "../llm/stream.js";

import { createAssistantMessageEventStream } from "../llm/utils/event-stream.js";

return normalized !== "off" && normalized !== "none";

}

/** Applies the shared reasoning payload policy used by OpenAI-compatible proxy providers. */

export function normalizeOpenAICompatibleReasoningPayload(

payload: Record<string, unknown>,

thinkingLevel?: ThinkLevel,

): void {

delete payload.reasoning_effort;

if (!thinkingLevel || thinkingLevel === "off") {

return;

}

const existingReasoning = payload.reasoning;

if (

existingReasoning &&

typeof existingReasoning === "object" &&

!Array.isArray(existingReasoning)

) {

const reasoning = existingReasoning as Record<string, unknown>;

if (!("max_tokens" in reasoning) && !("effort" in reasoning)) {

reasoning.effort = mapThinkingLevelToReasoningEffort(thinkingLevel);

}

} else if (!existingReasoning) {

payload.reasoning = {

effort: mapThinkingLevelToReasoningEffort(thinkingLevel),

};

}

}

/** Applies Qwen chat-template thinking flags without discarding provider-specific kwargs. */

export function setQwenChatTemplateThinking(

payload: Record<string, unknown>,