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/test-support/debug-proxy-env-test-helpers.ts

@@ -0,0 +1,53 @@
+// Test Support helper module supports debug proxy env test helpers behavior.
+import { afterEach, vi } from "vitest";
+
+const DEBUG_PROXY_ENV_KEYS = [
+  "OPENCLAW_DEBUG_PROXY_ENABLED",
+  "OPENCLAW_DEBUG_PROXY_SESSION_ID",
+  "OPENCLAW_STATE_DIR",
+] as const;
+
+type DebugProxyEnvKey = (typeof DEBUG_PROXY_ENV_KEYS)[number];
+type DebugProxyEnvSnapshot = Partial<Record<DebugProxyEnvKey, string | undefined>>;
+
+function snapshotDebugProxyEnv(): DebugProxyEnvSnapshot {
+  return Object.fromEntries(
+    DEBUG_PROXY_ENV_KEYS.map((key) => [key, process.env[key]]),
+  ) as DebugProxyEnvSnapshot;
+}
+
+function restoreDebugProxyEnv(snapshot: DebugProxyEnvSnapshot): void {
+  for (const key of DEBUG_PROXY_ENV_KEYS) {
+    const value = snapshot[key];
+    if (value === undefined) {
+      delete process.env[key];
+    } else {
+      process.env[key] = value;
+    }
+  }
+}
+
+export function installDebugProxyTestResetHooks() {
+  const originalFetch = globalThis.fetch;
+  const originalProxyEnv = snapshotDebugProxyEnv();
+  let priorProxyEnv = originalProxyEnv;
+
+  afterEach(async () => {
+    const { closeDebugProxyCaptureStore } = await import("openclaw/plugin-sdk/proxy-capture");
+    const { closeOpenClawStateDatabaseForTest } =
+      await import("openclaw/plugin-sdk/sqlite-runtime-testing");
+    closeDebugProxyCaptureStore();
+    closeOpenClawStateDatabaseForTest();
+    globalThis.fetch = originalFetch;
+    vi.restoreAllMocks();
+    restoreDebugProxyEnv(priorProxyEnv);
+    priorProxyEnv = originalProxyEnv;
+  });
+
+  return {
+    captureProxyEnv() {
+      priorProxyEnv = snapshotDebugProxyEnv();
+    },
+    originalFetch,
+  };
+}

extensions/test-support/generation-live-test-helpers.ts

@@ -0,0 +1,2 @@
+// Test Support helper module supports generation live test helpers behavior.
+export { maybeLoadShellEnvForGenerationProviders } from "openclaw/plugin-sdk/test-env";

extensions/test-support/provider-model-test-helpers.ts

@@ -0,0 +1,59 @@
+// Test Support provider module implements model/runtime integration.
+import type { ModelRegistry } from "openclaw/plugin-sdk/agent-sessions";
+import type {
+  ProviderCatalogContext,
+  ProviderResolveDynamicModelContext,
+  ProviderRuntimeModel,
+} from "openclaw/plugin-sdk/plugin-entry";
+import type { ProviderPlugin } from "openclaw/plugin-sdk/provider-model-shared";
+
+export function createProviderDynamicModelContext(params: {
+  provider: string;
+  modelId: string;
+  models: ProviderRuntimeModel[];
+}): ProviderResolveDynamicModelContext {
+  return {
+    provider: params.provider,
+    modelId: params.modelId,
+    modelRegistry: {
+      find(providerId: string, modelId: string) {
+        return (
+          params.models.find(
+            (model) =>
+              model.provider === providerId && model.id.toLowerCase() === modelId.toLowerCase(),
+          ) ?? null
+        );
+      },
+    } as ModelRegistry,
+  };
+}
+
+export async function runSingleProviderCatalog(
+  provider: Pick<ProviderPlugin, "catalog">,
+  params: {
+    resolveProviderApiKey?: ProviderCatalogContext["resolveProviderApiKey"];
+    resolveProviderAuth?: ProviderCatalogContext["resolveProviderAuth"];
+  } = {},
+) {
+  if (!provider.catalog) {
+    throw new Error("expected provider catalog");
+  }
+
+  const catalog = await provider.catalog.run({
+    config: {},
+    env: {},
+    resolveProviderApiKey: params.resolveProviderApiKey ?? (() => ({ apiKey: "test-key" })),
+    resolveProviderAuth:
+      params.resolveProviderAuth ??
+      (() => ({
+        apiKey: "test-key",
+        mode: "api_key",
+        source: "env",
+      })),
+  } as ProviderCatalogContext);
+
+  if (!catalog || !("provider" in catalog)) {
+    throw new Error("expected single-provider catalog");
+  }
+  return catalog.provider;
+}

extensions/test-support/streaming-error-response.ts

@@ -0,0 +1,50 @@
+// Test Support plugin module implements streaming response fixtures.
+export type StreamingResponseFixture = {
+  response: Response;
+  getReadCount: () => number;
+  wasCanceled: () => boolean;
+};
+
+export function createStreamingResponse(params: {
+  status?: number;
+  chunkCount: number;
+  chunkSize: number;
+  byte?: number;
+  text?: string;
+  headers?: HeadersInit;
+}): StreamingResponseFixture {
+  let reads = 0;
+  let canceled = false;
+  const encoder = new TextEncoder();
+  const stream = new ReadableStream<Uint8Array>({
+    pull(controller) {
+      if (reads >= params.chunkCount) {
+        controller.close();
+        return;
+      }
+      reads += 1;
+      const chunk =
+        params.text !== undefined
+          ? encoder.encode(params.text.repeat(params.chunkSize))
+          : new Uint8Array(params.chunkSize).fill(params.byte ?? 120);
+      controller.enqueue(chunk);
+    },
+    cancel() {
+      canceled = true;
+    },
+  });
+  return {
+    response: new Response(stream, { status: params.status ?? 200, headers: params.headers }),
+    getReadCount: () => reads,
+    wasCanceled: () => canceled,
+  };
+}
+
+export function createStreamingErrorResponse(params: {
+  status: number;
+  chunkCount: number;
+  chunkSize: number;
+  byte: number;
+}): StreamingResponseFixture {
+  return createStreamingResponse(params);
+}