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/tokenjuice/tool-result-middleware.ts

@@ -0,0 +1,154 @@
+// Tokenjuice plugin module implements tool result middleware behavior.
+import process from "node:process";
+import type {
+  AgentToolResultMiddleware,
+  AgentToolResultMiddlewareEvent,
+  OpenClawAgentToolResult,
+} from "openclaw/plugin-sdk/agent-harness";
+import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { createTokenjuiceOpenClawEmbeddedExtension } from "./runtime-api.js";
+
+type TokenjuiceToolResultHandler = (
+  event: {
+    toolName: string;
+    input: Record<string, unknown>;
+    content: OpenClawAgentToolResult["content"];
+    details: unknown;
+    isError?: boolean;
+  },
+  ctx: { cwd: string },
+) => Promise<Partial<OpenClawAgentToolResult> | void> | Partial<OpenClawAgentToolResult> | void;
+
+function readCwd(event: AgentToolResultMiddlewareEvent): string {
+  if (event.cwd?.trim()) {
+    return event.cwd;
+  }
+  const workdir = event.args.workdir;
+  if (typeof workdir === "string" && workdir.trim()) {
+    return workdir;
+  }
+  return process.cwd();
+}
+
+function readTextContent(content: OpenClawAgentToolResult["content"]): string {
+  if (typeof content === "string") {
+    return content;
+  }
+  if (!Array.isArray(content)) {
+    return "";
+  }
+  return content
+    .map((item) => {
+      if (typeof item === "string") {
+        return item;
+      }
+      if (item && typeof item === "object" && "text" in item && typeof item.text === "string") {
+        return item.text;
+      }
+      return "";
+    })
+    .filter(Boolean)
+    .join("\n");
+}
+
+function readCommand(args: Record<string, unknown>): string {
+  const command = args.command;
+  return typeof command === "string" ? command : "";
+}
+
+function hasStatus(details: Record<string, unknown>): boolean {
+  const status = details.status;
+  return typeof status === "string" && status.trim() !== "";
+}
+
+function hasFailureState(
+  event: AgentToolResultMiddlewareEvent,
+  details: Record<string, unknown> | undefined,
+): boolean {
+  const exitCode = details?.exitCode;
+  return (
+    event.isError === true ||
+    details?.ok === false ||
+    details?.success === false ||
+    details?.timedOut === true ||
+    Boolean(details?.error) ||
+    (typeof exitCode === "number" && Number.isFinite(exitCode) && exitCode !== 0)
+  );
+}
+
+function normalizeDetails(
+  event: AgentToolResultMiddlewareEvent,
+  current: OpenClawAgentToolResult,
+): unknown {
+  const isExecLike = event.toolName === "exec" || event.toolName === "bash";
+  const details = isRecord(current.details) ? current.details : undefined;
+
+  if (!isExecLike || !readCommand(event.args)) {
+    return current.details;
+  }
+  // A concrete status is already canonical. Other terminal hints are preserved below
+  // while supplying only the completed/failed status Tokenjuice requires.
+  if (details && hasStatus(details)) {
+    return current.details;
+  }
+  const aggregated = readTextContent(current.content);
+  if (!aggregated.trim()) {
+    return current.details;
+  }
+  const failed = hasFailureState(event, details);
+  const existingExitCode = details?.exitCode;
+  const exitCode =
+    typeof existingExitCode === "number" && Number.isFinite(existingExitCode)
+      ? existingExitCode
+      : failed
+        ? 1
+        : 0;
+  const synthesized = {
+    status: failed ? "failed" : "completed",
+    aggregated,
+    exitCode,
+  };
+  if (!details) {
+    return synthesized;
+  }
+  return {
+    ...synthesized,
+    ...details,
+    status: synthesized.status,
+    exitCode: synthesized.exitCode,
+  };
+}
+
+export function createTokenjuiceAgentToolResultMiddleware(): AgentToolResultMiddleware {
+  const handlers: TokenjuiceToolResultHandler[] = [];
+  createTokenjuiceOpenClawEmbeddedExtension()({
+    on(event, handler) {
+      if (event === "tool_result") {
+        handlers.push(handler as TokenjuiceToolResultHandler);
+      }
+    },
+  });
+
+  return async (event) => {
+    let current = event.result;
+    for (const handler of handlers) {
+      const next = await handler(
+        {
+          toolName: event.toolName,
+          input: event.args,
+          content: current.content,
+          details: normalizeDetails(event, current),
+          isError: event.isError,
+        },
+        { cwd: readCwd(event) },
+      );
+      if (next) {
+        current = Object.assign({}, current, {
+          content: next.content ?? current.content,
+          details: next.details ?? current.details,
+        });
+      }
+    }
+    return current === event.result ? undefined : { result: current };
+  };
+}