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/microsoft-foundry/provider.ts

@@ -0,0 +1,263 @@
+// Microsoft Foundry provider module implements model/runtime integration.
+import type { ProviderNormalizeResolvedModelContext } from "openclaw/plugin-sdk/core";
+import {
+  resolveClaudeThinkingProfile,
+  supportsClaudeNativeMaxEffort,
+  type ModelProviderConfig,
+  type ProviderPlugin,
+} from "openclaw/plugin-sdk/provider-model-shared";
+import { OPENAI_RESPONSES_STREAM_HOOKS } from "openclaw/plugin-sdk/provider-stream-family";
+import { apiKeyAuthMethod, entraIdAuthMethod } from "./auth.js";
+import { prepareFoundryRuntimeAuth } from "./runtime.js";
+import {
+  PROVIDER_ID,
+  applyFoundryProfileBinding,
+  applyFoundryProviderConfig,
+  buildFoundryProviderBaseUrl,
+  extractFoundryEndpoint,
+  isFoundryClaudeMythosPreview,
+  isFoundryProviderApi,
+  mergeFoundryCanonicalModelParams,
+  normalizeFoundryEndpoint,
+  resolveFoundryModelCapabilities,
+  resolveFoundryTargetProfileId,
+} from "./shared.js";
+
+type FoundryProviderHooks = Pick<ProviderPlugin, "wrapStreamFn">;
+
+const wrapOpenAIResponsesStreamFn = OPENAI_RESPONSES_STREAM_HOOKS.wrapStreamFn;
+
+const wrapMicrosoftFoundryStreamFn: NonNullable<FoundryProviderHooks["wrapStreamFn"]> = (ctx) => {
+  if (ctx.model?.api !== "openai-responses") {
+    return ctx.streamFn ?? null;
+  }
+
+  const baseStreamFn = ctx.streamFn;
+  if (!baseStreamFn) {
+    return wrapOpenAIResponsesStreamFn?.(ctx) ?? null;
+  }
+
+  const streamFnWithResponsesReplayIds: NonNullable<typeof ctx.streamFn> = (
+    model,
+    context,
+    options,
+  ) =>
+    baseStreamFn(model, context, {
+      ...options,
+      // Foundry validates encrypted reasoning replay against the original item id,
+      // even though its Responses endpoint does not support persisted `store`.
+      replayResponsesItemIds: true,
+    } as typeof options & { replayResponsesItemIds: true });
+
+  return (
+    wrapOpenAIResponsesStreamFn?.({
+      ...ctx,
+      streamFn: streamFnWithResponsesReplayIds,
+    }) ?? streamFnWithResponsesReplayIds
+  );
+};
+
+export function buildMicrosoftFoundryProvider(): ProviderPlugin {
+  return {
+    id: PROVIDER_ID,
+    label: "Microsoft Foundry",
+    docsPath: "/providers/models",
+    envVars: ["AZURE_OPENAI_API_KEY", "AZURE_OPENAI_ENDPOINT"],
+    auth: [entraIdAuthMethod, apiKeyAuthMethod],
+    onModelSelected: async (ctx) => {
+      const providerConfig = ctx.config.models?.providers?.[PROVIDER_ID];
+      if (
+        !providerConfig ||
+        !providerConfig.baseUrl?.trim() ||
+        !Array.isArray(providerConfig.models) ||
+        !ctx.model.startsWith(`${PROVIDER_ID}/`)
+      ) {
+        return;
+      }
+      const selectedModelId = ctx.model.slice(`${PROVIDER_ID}/`.length);
+      const configuredModels = providerConfig.models ?? [];
+      const existingModel = configuredModels.find(
+        (model: { id: string }) => model.id === selectedModelId,
+      );
+      const existingModelApi = isFoundryProviderApi(existingModel?.api)
+        ? existingModel.api
+        : undefined;
+      const providerApiForExistingModel =
+        existingModel && isFoundryProviderApi(providerConfig.api) ? providerConfig.api : undefined;
+      const selectedModelCapabilities = resolveFoundryModelCapabilities(
+        selectedModelId,
+        existingModel?.name,
+        existingModelApi ?? providerApiForExistingModel,
+        existingModel?.input,
+      );
+      const providerEndpoint = normalizeFoundryEndpoint(providerConfig.baseUrl ?? "");
+      const selectedProviderEndpoint =
+        extractFoundryEndpoint(existingModel?.baseUrl) ?? providerEndpoint;
+      const nextModels = configuredModels.map((model) => {
+        if (model.id !== selectedModelId) {
+          return model;
+        }
+        const selectedModelEndpoint = extractFoundryEndpoint(model.baseUrl) ?? providerEndpoint;
+        const selectedModelBaseUrl = buildFoundryProviderBaseUrl(
+          selectedModelEndpoint,
+          selectedModelId,
+          selectedModelCapabilities.modelName,
+          selectedModelCapabilities.api,
+        );
+        const nextModel = Object.assign({}, model, {
+          name: selectedModelCapabilities.modelName,
+          api: selectedModelCapabilities.api,
+          baseUrl: selectedModelBaseUrl,
+          reasoning: selectedModelCapabilities.reasoning || model.reasoning,
+          thinkingLevelMap: selectedModelCapabilities.thinkingLevelMap ?? model.thinkingLevelMap,
+          params: mergeFoundryCanonicalModelParams(
+            model.params,
+            selectedModelCapabilities.modelName,
+          ),
+          input: selectedModelCapabilities.input,
+        });
+        if (selectedModelCapabilities.compat) {
+          const explicitSupportsReasoningEffort =
+            typeof model.compat?.supportsReasoningEffort === "boolean"
+              ? model.compat.supportsReasoningEffort
+              : undefined;
+          const preserveExplicitReasoningEffort =
+            !selectedModelCapabilities.reasoning &&
+            model.reasoning &&
+            explicitSupportsReasoningEffort !== false;
+          const explicitMaxTokensField =
+            typeof model.compat?.maxTokensField === "string"
+              ? model.compat.maxTokensField
+              : preserveExplicitReasoningEffort
+                ? "max_completion_tokens"
+                : undefined;
+          nextModel.compat = {
+            ...model.compat,
+            ...selectedModelCapabilities.compat,
+            ...(explicitSupportsReasoningEffort !== undefined
+              ? { supportsReasoningEffort: explicitSupportsReasoningEffort }
+              : preserveExplicitReasoningEffort
+                ? { supportsReasoningEffort: true }
+                : undefined),
+            ...(explicitMaxTokensField ? { maxTokensField: explicitMaxTokensField } : {}),
+          };
+        }
+        return nextModel;
+      });
+      if (!nextModels.some((model) => model.id === selectedModelId)) {
+        nextModels.push({
+          id: selectedModelId,
+          name: selectedModelCapabilities.modelName,
+          api: selectedModelCapabilities.api,
+          baseUrl: buildFoundryProviderBaseUrl(
+            providerEndpoint,
+            selectedModelId,
+            selectedModelCapabilities.modelName,
+            selectedModelCapabilities.api,
+          ),
+          reasoning: selectedModelCapabilities.reasoning,
+          ...(selectedModelCapabilities.thinkingLevelMap
+            ? { thinkingLevelMap: selectedModelCapabilities.thinkingLevelMap }
+            : {}),
+          params: mergeFoundryCanonicalModelParams(undefined, selectedModelCapabilities.modelName),
+          input: selectedModelCapabilities.input,
+          cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+          contextWindow: selectedModelCapabilities.contextWindow,
+          maxTokens: selectedModelCapabilities.maxTokens,
+          ...(selectedModelCapabilities.compat ? { compat: selectedModelCapabilities.compat } : {}),
+        });
+      }
+      const nextProviderConfig: ModelProviderConfig = {
+        ...providerConfig,
+        baseUrl: buildFoundryProviderBaseUrl(
+          selectedProviderEndpoint,
+          selectedModelId,
+          selectedModelCapabilities.modelName,
+          selectedModelCapabilities.api,
+        ),
+        api: selectedModelCapabilities.api,
+        models: nextModels,
+      };
+      const targetProfileId = resolveFoundryTargetProfileId(ctx.config);
+      if (targetProfileId) {
+        applyFoundryProfileBinding(ctx.config, targetProfileId);
+      }
+      applyFoundryProviderConfig(ctx.config, nextProviderConfig);
+    },
+    resolveThinkingProfile: ({ modelId, params }) => {
+      const modelName =
+        typeof params?.canonicalModelId === "string" ? params.canonicalModelId : undefined;
+      const capabilities = resolveFoundryModelCapabilities(modelId, modelName);
+      if (!capabilities.reasoning || capabilities.api !== "anthropic-messages") {
+        return undefined;
+      }
+      const profile = resolveClaudeThinkingProfile(capabilities.modelName, undefined, {
+        includeNativeMax: supportsClaudeNativeMaxEffort({ id: capabilities.modelName }),
+      });
+      if (!isFoundryClaudeMythosPreview(capabilities.modelName)) {
+        return profile;
+      }
+      const levels = profile.levels.filter((level) => level.id !== "off");
+      return {
+        ...profile,
+        defaultLevel: "adaptive",
+        levels: levels.some((level) => level.id === "adaptive")
+          ? levels
+          : [...levels, { id: "adaptive" }],
+      };
+    },
+    normalizeResolvedModel: ({ modelId, model }: ProviderNormalizeResolvedModelContext) => {
+      const endpoint = extractFoundryEndpoint(model.baseUrl ?? "");
+      if (!endpoint) {
+        return model;
+      }
+      const capabilities = resolveFoundryModelCapabilities(
+        modelId,
+        model.name,
+        isFoundryProviderApi(model.api) ? model.api : undefined,
+        model.input,
+      );
+      const explicitSupportsReasoningEffort =
+        typeof model.compat?.supportsReasoningEffort === "boolean"
+          ? model.compat.supportsReasoningEffort
+          : undefined;
+      const preserveExplicitReasoningEffort = !capabilities.reasoning && model.reasoning;
+      const explicitMaxTokensField =
+        typeof model.compat?.maxTokensField === "string"
+          ? model.compat.maxTokensField
+          : preserveExplicitReasoningEffort
+            ? "max_completion_tokens"
+            : undefined;
+      const compat = capabilities.compat
+        ? {
+            ...model.compat,
+            ...capabilities.compat,
+            ...(explicitSupportsReasoningEffort !== undefined
+              ? { supportsReasoningEffort: explicitSupportsReasoningEffort }
+              : preserveExplicitReasoningEffort
+                ? { supportsReasoningEffort: true }
+                : undefined),
+            ...(explicitMaxTokensField ? { maxTokensField: explicitMaxTokensField } : {}),
+          }
+        : undefined;
+      return {
+        ...model,
+        name: capabilities.modelName,
+        api: capabilities.api,
+        reasoning: capabilities.reasoning || model.reasoning,
+        thinkingLevelMap: capabilities.thinkingLevelMap ?? model.thinkingLevelMap,
+        params: mergeFoundryCanonicalModelParams(model.params, capabilities.modelName),
+        input: capabilities.input,
+        baseUrl: buildFoundryProviderBaseUrl(
+          endpoint,
+          modelId,
+          capabilities.modelName,
+          capabilities.api,
+        ),
+        ...(compat ? { compat } : {}),
+      };
+    },
+    wrapStreamFn: wrapMicrosoftFoundryStreamFn,
+    prepareRuntimeAuth: prepareFoundryRuntimeAuth,
+  };
+}