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

scripts/e2e/lib/openai-chat-tools/client.mjs

@@ -0,0 +1,205 @@
+// Gateway client for OpenAI chat tools E2E scenarios.
+import { readPositiveIntEnv, readTcpPortEnv } from "../env-limits.mjs";
+
+const portText = process.env.PORT;
+const token = process.env.OPENCLAW_GATEWAY_TOKEN;
+const backendModel = process.env.MODEL_REF || "openai/gpt-5.4-mini";
+
+const timeoutSeconds = readPositiveIntEnv("OPENCLAW_OPENAI_CHAT_TOOLS_TIMEOUT_SECONDS", 180);
+const maxBodyBytes = readPositiveIntEnv("OPENCLAW_OPENAI_CHAT_TOOLS_MAX_BODY_BYTES", 1048576);
+
+if (!portText || !token) {
+  throw new Error("missing PORT/OPENCLAW_GATEWAY_TOKEN");
+}
+const port = readTcpPortEnv("PORT", portText);
+if (!Number.isFinite(timeoutSeconds) || timeoutSeconds <= 0) {
+  throw new Error(`invalid OPENCLAW_OPENAI_CHAT_TOOLS_TIMEOUT_SECONDS: ${timeoutSeconds}`);
+}
+if (!Number.isFinite(maxBodyBytes) || maxBodyBytes <= 0) {
+  throw new Error(`invalid OPENCLAW_OPENAI_CHAT_TOOLS_MAX_BODY_BYTES: ${maxBodyBytes}`);
+}
+
+function cancelReaderSoon(reader) {
+  void Promise.resolve()
+    .then(() => reader.cancel())
+    .catch(() => undefined);
+}
+
+async function readResponseChunk(reader, timeoutPromise, markCanceled) {
+  const readPromise = reader.read();
+  if (!timeoutPromise) {
+    return await readPromise;
+  }
+
+  let waitingForRead = true;
+  const timeoutReadPromise = timeoutPromise.catch((error) => {
+    if (waitingForRead) {
+      markCanceled();
+      cancelReaderSoon(reader);
+    }
+    throw error;
+  });
+
+  try {
+    return await Promise.race([readPromise, timeoutReadPromise]);
+  } finally {
+    waitingForRead = false;
+  }
+}
+
+async function readBoundedResponseText(response, byteLimit, timeoutPromise) {
+  const contentLength = response.headers?.get?.("content-length");
+  if (contentLength && /^\d+$/u.test(contentLength)) {
+    const parsedContentLength = Number(contentLength);
+    if (!Number.isSafeInteger(parsedContentLength) || parsedContentLength > byteLimit) {
+      await response.body?.cancel().catch(() => undefined);
+      throw new Error(`chat completions response body exceeded ${byteLimit} bytes`);
+    }
+  }
+
+  const reader = response.body?.getReader();
+  if (!reader) {
+    return "";
+  }
+  const chunks = [];
+  let totalBytes = 0;
+  let canceled = false;
+  try {
+    for (;;) {
+      const { done, value } = await readResponseChunk(reader, timeoutPromise, () => {
+        canceled = true;
+      });
+      if (done) {
+        break;
+      }
+      totalBytes += value.byteLength;
+      if (totalBytes > byteLimit) {
+        canceled = true;
+        await reader.cancel();
+        throw new Error(`chat completions response body exceeded ${byteLimit} bytes`);
+      }
+      chunks.push(Buffer.from(value));
+    }
+  } finally {
+    if (!canceled) {
+      reader.releaseLock();
+    }
+  }
+  return Buffer.concat(chunks, totalBytes).toString("utf8");
+}
+
+const controller = new AbortController();
+const timeoutError = new Error(`chat completions request timed out after ${timeoutSeconds}s`);
+let timeout;
+const timeoutPromise = new Promise((_, reject) => {
+  timeout = setTimeout(() => {
+    controller.abort(timeoutError);
+    reject(timeoutError);
+  }, timeoutSeconds * 1000);
+  timeout.unref?.();
+});
+const started = Date.now();
+let response;
+let text;
+try {
+  response = await Promise.race([
+    fetch(`http://127.0.0.1:${port}/v1/chat/completions`, {
+      method: "POST",
+      headers: {
+        authorization: `Bearer ${token}`,
+        "content-type": "application/json",
+        "x-openclaw-model": backendModel,
+      },
+      body: JSON.stringify({
+        model: "openclaw",
+        stream: false,
+        messages: [
+          {
+            role: "user",
+            content:
+              "Use the get_weather tool exactly once for Paris, France. Return the tool call only.",
+          },
+        ],
+        tool_choice: "auto",
+        tools: [
+          {
+            type: "function",
+            function: {
+              name: "get_weather",
+              description: "Return weather for a city.",
+              strict: true,
+              parameters: {
+                type: "object",
+                additionalProperties: false,
+                properties: {
+                  city: { type: "string", description: "City and country." },
+                },
+                required: ["city"],
+              },
+            },
+          },
+        ],
+      }),
+      signal: controller.signal,
+    }),
+    timeoutPromise,
+  ]);
+  text = await readBoundedResponseText(response, maxBodyBytes, timeoutPromise);
+} finally {
+  clearTimeout(timeout);
+}
+
+let body;
+try {
+  body = text ? JSON.parse(text) : {};
+} catch {
+  throw new Error(`non-JSON response ${response.status}: ${text}`);
+}
+
+if (!response.ok) {
+  throw new Error(`chat completions request failed ${response.status}: ${JSON.stringify(body)}`);
+}
+
+const choice = body.choices?.[0];
+const toolCalls = choice?.message?.tool_calls;
+if (choice?.finish_reason !== "tool_calls") {
+  throw new Error(`expected finish_reason tool_calls: ${JSON.stringify(body)}`);
+}
+const messageContent = choice?.message?.content;
+const hasVisibleContent =
+  (typeof messageContent === "string" && messageContent.trim().length > 0) ||
+  (Array.isArray(messageContent) && messageContent.length > 0) ||
+  (messageContent !== undefined &&
+    messageContent !== null &&
+    typeof messageContent !== "string" &&
+    !Array.isArray(messageContent));
+if (hasVisibleContent) {
+  throw new Error(`expected tool call only response: ${JSON.stringify(choice.message)}`);
+}
+if (!Array.isArray(toolCalls) || toolCalls.length !== 1) {
+  throw new Error(`expected exactly one tool call: ${JSON.stringify(body)}`);
+}
+const [toolCall] = toolCalls;
+if (toolCall?.type !== "function" || toolCall?.function?.name !== "get_weather") {
+  throw new Error(`unexpected tool call: ${JSON.stringify(toolCall)}`);
+}
+
+let args;
+try {
+  args = JSON.parse(toolCall.function.arguments || "{}");
+} catch {
+  throw new Error(`tool arguments were not valid JSON: ${toolCall.function.arguments}`);
+}
+if (typeof args.city !== "string" || !/paris/i.test(args.city)) {
+  throw new Error(`expected Paris city argument: ${JSON.stringify(args)}`);
+}
+
+console.log(
+  JSON.stringify({
+    ok: true,
+    elapsedMs: Date.now() - started,
+    finishReason: choice.finish_reason,
+    toolName: toolCall.function.name,
+    args,
+  }),
+);