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/openai/native-web-search.ts

@@ -0,0 +1,108 @@
+// Openai plugin module implements native web search behavior.
+import type { StreamFn } from "openclaw/plugin-sdk/agent-core";
+import type { OpenClawConfig } from "openclaw/plugin-sdk/config-contracts";
+import { streamSimple } from "openclaw/plugin-sdk/llm";
+import { normalizeProviderId } from "openclaw/plugin-sdk/provider-model-shared";
+import { streamWithPayloadPatch } from "openclaw/plugin-sdk/provider-stream-shared";
+import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { isOpenAIApiBaseUrl } from "./base-url.js";
+
+const OPENAI_WEB_SEARCH_TOOL = { type: "web_search" } as const;
+
+type OpenAINativeWebSearchPatchResult =
+  | "payload_not_object"
+  | "native_tool_already_present"
+  | "injected";
+
+function isOpenAINativeWebSearchEligibleModel(model: {
+  api?: unknown;
+  provider?: unknown;
+  baseUrl?: unknown;
+}): boolean {
+  const provider = typeof model.provider === "string" ? model.provider : undefined;
+  if (model.api !== "openai-responses" || !provider || normalizeProviderId(provider) !== "openai") {
+    return false;
+  }
+  const baseUrl = typeof model.baseUrl === "string" ? model.baseUrl : undefined;
+  return !baseUrl || isOpenAIApiBaseUrl(baseUrl);
+}
+
+function shouldUseOpenAINativeWebSearchProvider(config: OpenClawConfig | undefined): boolean {
+  const provider = config?.tools?.web?.search?.provider;
+  if (typeof provider !== "string") {
+    return true;
+  }
+  const normalized = provider.trim().toLowerCase();
+  return normalized === "" || normalized === "auto" || normalized === "openai";
+}
+
+function shouldEnableOpenAINativeWebSearch(params: {
+  config?: OpenClawConfig;
+  model: { api?: unknown; provider?: unknown; baseUrl?: unknown };
+}): boolean {
+  return (
+    params.config?.tools?.web?.search?.enabled !== false &&
+    shouldUseOpenAINativeWebSearchProvider(params.config) &&
+    isOpenAINativeWebSearchEligibleModel(params.model)
+  );
+}
+
+function isNativeWebSearchTool(tool: unknown): boolean {
+  return isRecord(tool) && tool.type === OPENAI_WEB_SEARCH_TOOL.type;
+}
+
+function isManagedWebSearchTool(tool: unknown): boolean {
+  return isRecord(tool) && tool.type === "function" && tool.name === OPENAI_WEB_SEARCH_TOOL.type;
+}
+
+function raiseMinimalReasoningForOpenAINativeWebSearch(payload: Record<string, unknown>): void {
+  const reasoning = payload.reasoning;
+  if (!isRecord(reasoning) || reasoning.effort !== "minimal") {
+    return;
+  }
+  reasoning.effort = "low";
+}
+
+export function patchOpenAINativeWebSearchPayload(
+  payload: unknown,
+): OpenAINativeWebSearchPatchResult {
+  if (!isRecord(payload)) {
+    return "payload_not_object";
+  }
+
+  const existingTools = Array.isArray(payload.tools) ? payload.tools : [];
+  const filteredTools = existingTools.filter((tool) => !isManagedWebSearchTool(tool));
+  if (filteredTools.some(isNativeWebSearchTool)) {
+    if (filteredTools.length !== existingTools.length) {
+      payload.tools = filteredTools;
+    }
+    raiseMinimalReasoningForOpenAINativeWebSearch(payload);
+    return "native_tool_already_present";
+  }
+
+  payload.tools = [...filteredTools, OPENAI_WEB_SEARCH_TOOL];
+  raiseMinimalReasoningForOpenAINativeWebSearch(payload);
+  return "injected";
+}
+
+export function createOpenAINativeWebSearchWrapper(
+  baseStreamFn: StreamFn | undefined,
+  params: {
+    config?: OpenClawConfig;
+    agentId?: string;
+    nativeWebSearchAllowedByToolPolicy?: boolean;
+  },
+): StreamFn {
+  const underlying = baseStreamFn ?? streamSimple;
+  return (model, context, options) => {
+    if (!shouldEnableOpenAINativeWebSearch({ config: params.config, model })) {
+      return underlying(model, context, options);
+    }
+    if (params.nativeWebSearchAllowedByToolPolicy === false) {
+      return underlying(model, context, options);
+    }
+    return streamWithPayloadPatch(underlying, model, context, options, (payload) => {
+      patchOpenAINativeWebSearchPayload(payload);
+    });
+  };
+}