Merge d4f31fb into 4bdf224

MonkeyLeeT · web-flow · commit 991baa813d91 · 2026-07-08T02:48:38.000Z
diff --git a/packages/ai/src/providers/google-shared.test.ts b/packages/ai/src/providers/google-shared.test.ts
@@ -6,6 +6,7 @@ import { AssistantMessageEventStream } from "../utils/event-stream.js";
 import { SYSTEM_PROMPT_CACHE_BOUNDARY } from "../utils/system-prompt-cache-boundary.js";
 import {
   buildGoogleGenerateContentParams,
+  buildGoogleSimpleThinking,
   consumeGoogleGenerateContentStream,
 } from "./google-shared.js";
 
@@ -53,6 +54,30 @@ function createOutput(): AssistantMessage {
   };
 }
 
+describe("buildGoogleSimpleThinking", () => {
+  it.each(["xhigh", "max"] as const)(
+    "keeps thinking disabled when reasoning=%s clamps to off",
+    (reasoning) => {
+      const offOnlyThinkingModel = {
+        ...model,
+        id: "gemini-3-flash-preview",
+        thinkingLevelMap: {
+          minimal: null,
+          low: null,
+          medium: null,
+          high: null,
+          xhigh: null,
+          max: null,
+        },
+      } satisfies Model<"google-generative-ai">;
+
+      expect(buildGoogleSimpleThinking(offOnlyThinkingModel, { reasoning })).toEqual({
+        enabled: false,
+      });
+    },
+  );
+});
+
 async function* chunks(items: GenerateContentResponse[]) {
   yield* items;
 }
diff --git a/packages/ai/src/providers/google-shared.ts b/packages/ai/src/providers/google-shared.ts
@@ -557,8 +557,11 @@ export function buildGoogleSimpleThinking<T extends GoogleApiType>(
   }
 
   const clampedReasoning = clampThinkingLevel(model, options.reasoning);
+  if (clampedReasoning === "off") {
+    return { enabled: false };
+  }
   const effort = (
-    clampedReasoning === "off" || clampedReasoning === "max" ? "high" : clampedReasoning
+    clampedReasoning === "max" ? "high" : clampedReasoning
   ) as ClampedGoogleThinkingLevel;
 
   if (
diff --git a/src/agents/google-simple-completion-stream.test.ts b/src/agents/google-simple-completion-stream.test.ts
@@ -24,15 +24,16 @@ vi.mock("./custom-api-registry.js", () => ({
   ensureCustomApiRegistered,
 }));
 
-const { prepareGoogleSimpleCompletionModel } = await import(
-  "./google-simple-completion-stream.js"
-);
+const { prepareGoogleSimpleCompletionModel } = await import("./google-simple-completion-stream.js");
 
 const GOOGLE_SIMPLE_COMPLETION_API = "openclaw-google-generative-ai-simple";
 
 // Mirrors the provider catalog shape closely enough for wrapper registration
 // without pulling live Google model discovery into unit tests.
-function makeGoogleModel(id = "gemini-flash-latest"): Model<"google-generative-ai"> {
+function makeGoogleModel(
+  id = "gemini-flash-latest",
+  overrides: Partial<Model<"google-generative-ai">> = {},
+): Model<"google-generative-ai"> {
   return {
     id,
     name: id,
@@ -45,6 +46,7 @@ function makeGoogleModel(id = "gemini-flash-latest"): Model<"google-generative-a
     contextWindow: 1_000_000,
     maxTokens: 8192,
     headers: {},
+    ...overrides,
   };
 }
 
@@ -152,4 +154,63 @@ describe("prepareGoogleSimpleCompletionModel", () => {
       ).payload.generationConfig.thinkingConfig,
     ).not.toHaveProperty("thinkingBudget");
   });
+
+  it.each(["xhigh", "max"] as const)(
+    "preserves clamped-off intent in the final Gemini 3 payload for reasoning=%s",
+    async (reasoning) => {
+      const actual = await vi.importActual<
+        typeof import("../plugin-sdk/provider-stream-shared.js")
+      >("../plugin-sdk/provider-stream-shared.js");
+      sanitizeGoogleThinkingPayload.mockImplementationOnce(actual.sanitizeGoogleThinkingPayload);
+      streamSimple.mockImplementationOnce((_model, _context, options) => {
+        const payload = {
+          generationConfig: {
+            thinkingConfig: { thinkingLevel: "MINIMAL" },
+          },
+        };
+        options?.onPayload?.(payload, _model);
+        return { content: [{ type: "text", text: "ok" }], payload };
+      });
+      const model = makeGoogleModel("gemini-3-flash-preview", {
+        thinkingLevelMap: {
+          minimal: null,
+          low: null,
+          medium: null,
+          high: null,
+          xhigh: null,
+          max: null,
+        },
+      });
+      const wrapped = prepareGoogleSimpleCompletionModel(model);
+      const streamFn = ensureCustomApiRegistered.mock.calls[0]?.[1] as (
+        ...args: unknown[]
+      ) => unknown;
+
+      const result = await streamFn(wrapped, { messages: [] }, { apiKey: "key", reasoning });
+
+      expect(sanitizeGoogleThinkingPayload).toHaveBeenCalledWith({
+        payload: {
+          generationConfig: {
+            thinkingConfig: { thinkingLevel: "MINIMAL" },
+          },
+        },
+        modelId: "gemini-3-flash-preview",
+        thinkingLevel: "off",
+      });
+      expect(result).toMatchObject({
+        payload: {
+          generationConfig: {
+            thinkingConfig: { thinkingLevel: "MINIMAL" },
+          },
+        },
+      });
+      expect(
+        (
+          result as {
+            payload: { generationConfig: { thinkingConfig: Record<string, unknown> } };
+          }
+        ).payload.generationConfig.thinkingConfig,
+      ).not.toHaveProperty("includeThoughts");
+    },
+  );
 });
diff --git a/src/agents/google-simple-completion-stream.ts b/src/agents/google-simple-completion-stream.ts
@@ -4,8 +4,9 @@
  * This registers a patched Google stream API that keeps the normal Google
  * backend but sanitizes unsupported thinking payload options for simple models.
  */
+import { clampThinkingLevel } from "@openclaw/ai/internal/runtime";
 import { streamSimple } from "../llm/stream.js";
-import type { Api, Model } from "../llm/types.js";
+import type { Api, Model, ModelThinkingLevel } from "../llm/types.js";
 import {
   sanitizeGoogleThinkingPayload,
   streamWithPayloadPatch,
@@ -20,26 +21,28 @@ const GOOGLE_SIMPLE_COMPLETION_API: Api = "openclaw-google-generative-ai-simple"
 const SOURCE_API: Api = "google-generative-ai";
 
 function resolveGoogleSimpleThinkingLevel(
+  model: Model,
   reasoning: unknown,
 ): GoogleThinkingInputLevel | undefined {
   switch (reasoning) {
+    case "adaptive":
+      return reasoning;
     case "off":
     case "minimal":
     case "low":
     case "medium":
-    case "adaptive":
     case "high":
     case "max":
     case "xhigh":
-      return reasoning;
+      return clampThinkingLevel(model, reasoning as ModelThinkingLevel);
     default:
       return undefined;
   }
 }
 
 function buildGoogleSimpleCompletionStreamFn(): StreamFn {
   return (model, context, options) => {
-    const googleModel = { ...model, api: SOURCE_API };
+    const googleModel: Model = { ...model, api: SOURCE_API };
     return streamWithPayloadPatch(
       streamSimple as unknown as StreamFn,
       googleModel,
@@ -50,6 +53,7 @@ function buildGoogleSimpleCompletionStreamFn(): StreamFn {
           payload,
           modelId: model.id,
           thinkingLevel: resolveGoogleSimpleThinkingLevel(
+            googleModel,
             (options as { reasoning?: unknown } | undefined)?.reasoning,
           ),
         });
