fix(plugins): ignore throwing provider runtime hooks

vincentkoc · vincentkoc · commit 42398b15f272 · 2026-06-01T08:36:18.000+02:00
diff --git a/src/plugins/provider-runtime.test.ts b/src/plugins/provider-runtime.test.ts
@@ -1329,6 +1329,38 @@ describe("provider-runtime", () => {
     expect(resolvePluginProvidersMock).toHaveBeenCalledTimes(1);
   });
 
+  it("ignores throwing model-id normalization hooks", () => {
+    resolvePluginProvidersMock.mockReturnValue([
+      {
+        id: "fuzz-provider",
+        pluginId: "fuzzplugin\nWARN forged",
+        label: "Fuzz Provider",
+        aliases: ["fuzz"],
+        auth: [],
+        normalizeModelId: () => {
+          throw new Error("bad\nmodel hook");
+        },
+      },
+    ]);
+
+    expect(
+      normalizeProviderModelIdWithPlugin({
+        provider: "fuzz",
+        context: {
+          provider: "fuzz",
+          modelId: "demo-model",
+        },
+      }),
+    ).toBeUndefined();
+
+    expect(providerRuntimeWarnMock).toHaveBeenCalledTimes(1);
+    const warning = firstMockStringArg(providerRuntimeWarnMock, "provider warning");
+    expect(warning).toContain('Provider plugin "fuzzpluginWARN forged"');
+    expect(warning).toContain("normalizeModelId hook failed");
+    expect(warning).toContain("badmodel hook");
+    expect(warning).not.toContain("\n");
+  });
+
   it("resolves config hooks through hook-only aliases without changing provider surfaces", () => {
     resolvePluginProvidersMock.mockReturnValue([
       {
@@ -1662,6 +1694,50 @@ describe("provider-runtime", () => {
     });
   });
 
+  it("keeps scanning transport hooks after one provider hook throws", () => {
+    resolvePluginProvidersMock.mockImplementation((params) => {
+      const plugins: ProviderPlugin[] = [
+        {
+          id: "custom-fuzz",
+          pluginId: "fuzzplugin",
+          label: "Fuzz Provider",
+          auth: [],
+          normalizeTransport: () => {
+            throw new Error("bad transport hook");
+          },
+        },
+        {
+          id: "fuzz-transport-family",
+          pluginId: "fuzzplugin",
+          label: "Fuzz Transport Family",
+          auth: [],
+          normalizeTransport: ({ api, baseUrl }) =>
+            api === "openai-completions" ? { api: "openai-responses", baseUrl } : undefined,
+        },
+      ];
+      return params.providerRefs?.includes("custom-fuzz") ? [plugins[0]] : plugins;
+    });
+
+    expect(
+      normalizeProviderTransportWithPlugin({
+        provider: "custom-fuzz",
+        context: {
+          provider: "custom-fuzz",
+          api: "openai-completions",
+          baseUrl: "https://api.example.com/v1",
+        },
+      }),
+    ).toEqual({
+      api: "openai-responses",
+      baseUrl: "https://api.example.com/v1",
+    });
+
+    expect(providerRuntimeWarnMock).toHaveBeenCalledTimes(1);
+    expect(firstMockStringArg(providerRuntimeWarnMock, "provider warning")).toContain(
+      'Provider plugin "fuzzplugin" normalizeTransport hook failed',
+    );
+  });
+
   it("invalidates cached runtime providers when config mutates in place", () => {
     const config = {
       plugins: {
diff --git a/src/plugins/provider-runtime.ts b/src/plugins/provider-runtime.ts
@@ -14,6 +14,7 @@ import {
 import type { ProviderSystemPromptContribution } from "../agents/system-prompt-contribution.js";
 import type { ModelProviderConfig } from "../config/types.js";
 import type { OpenClawConfig } from "../config/types.openclaw.js";
+import { formatErrorMessage } from "../infra/errors.js";
 import { createSubsystemLogger } from "../logging/subsystem.js";
 import { normalizeProviderModelIdWithManifest } from "./manifest-model-id-normalization.js";
 import { resolvePluginMetadataSnapshot } from "./plugin-metadata-snapshot.js";
@@ -123,6 +124,29 @@ function matchesAnyProviderPluginRef(provider: ProviderPlugin, providerRefs: rea
   return providerRefs.some((providerRef) => matchesProviderPluginRef(provider, providerRef));
 }
 
+function getProviderRuntimePluginKey(plugin: ProviderPlugin): string {
+  return `${plugin.pluginId ?? ""}:${plugin.id}`;
+}
+
+function runProviderRuntimeHook<TResult>(params: {
+  plugin: ProviderPlugin | undefined;
+  hookName: string;
+  run: (plugin: ProviderPlugin) => TResult;
+}): TResult | undefined {
+  if (!params.plugin) {
+    return undefined;
+  }
+  try {
+    return params.run(params.plugin);
+  } catch (error) {
+    const pluginId = params.plugin.pluginId ?? params.plugin.id;
+    log.warn(
+      `Provider plugin "${sanitizeForLog(pluginId)}" ${sanitizeForLog(params.hookName)} hook failed; ignoring hook: ${sanitizeForLog(formatErrorMessage(error))}`,
+    );
+    return undefined;
+  }
+}
+
 function hasExplicitProviderRuntimePluginActivation(params: {
   provider: string;
   config?: OpenClawConfig;
@@ -369,8 +393,13 @@ export function normalizeProviderModelIdWithPlugin(params: {
 }): string | undefined {
   const plugin = resolveProviderHookPlugin(params);
   return (
-    normalizeOptionalString(plugin?.normalizeModelId?.(params.context)) ??
-    normalizeProviderModelIdWithManifest(params)
+    normalizeOptionalString(
+      runProviderRuntimeHook({
+        plugin,
+        hookName: "normalizeModelId",
+        run: (providerPlugin) => providerPlugin.normalizeModelId?.(params.context),
+      }),
+    ) ?? normalizeProviderModelIdWithManifest(params)
   );
 }
 
@@ -385,16 +414,28 @@ export function normalizeProviderTransportWithPlugin(params: {
     (normalized.api ?? params.context.api) !== params.context.api ||
     (normalized.baseUrl ?? params.context.baseUrl) !== params.context.baseUrl;
   const matchedPlugin = resolveProviderHookPlugin(params);
-  const normalizedMatched = matchedPlugin?.normalizeTransport?.(params.context);
+  const normalizedMatched = runProviderRuntimeHook({
+    plugin: matchedPlugin,
+    hookName: "normalizeTransport",
+    run: (providerPlugin) => providerPlugin.normalizeTransport?.(params.context),
+  });
+  const matchedPluginKey = matchedPlugin ? getProviderRuntimePluginKey(matchedPlugin) : undefined;
   if (normalizedMatched && hasTransportChange(normalizedMatched)) {
     return normalizedMatched;
   }
 
   for (const candidate of resolveProviderPluginsForHooks(params)) {
-    if (!candidate.normalizeTransport || candidate === matchedPlugin) {
+    if (
+      !candidate.normalizeTransport ||
+      (matchedPluginKey && getProviderRuntimePluginKey(candidate) === matchedPluginKey)
+    ) {
       continue;
     }
-    const normalized = candidate.normalizeTransport(params.context);
+    const normalized = runProviderRuntimeHook({
+      plugin: candidate,
+      hookName: "normalizeTransport",
+      run: (providerPlugin) => providerPlugin.normalizeTransport?.(params.context),
+    });
     if (normalized && hasTransportChange(normalized)) {
       return normalized;
     }
