fix: use Codex context windows for OpenAI runtime (#81906)

jalehman · web-flow · commit 4004c9342d7d · 2026-05-14T15:38:50.000-07:00
* fix: use Codex context windows for OpenAI runtime

* test: satisfy status model fixture types

* fix: note Codex context window budget fix
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -167,6 +167,7 @@ Docs: https://docs.openclaw.ai
 - Agents/memory-flush: surface non-abort memory-flush failures (provider timeout, transport error, generic agent failure) as visible reply payloads so the outer reply loop short-circuits and isolated cron runs propagate the error into `meta.error` instead of completing silently with `status: "ok"` and an empty payload. Previously only the specific "Memory flush writes are restricted to ..." message was surfaced. Fixes #80755. Thanks @nailujac.
 - Channels/loop-guard: enforce shared per-pair bot loop protection in the core channel-turn kernel, with Discord, Slack, Matrix, and Google Chat supplying bot-pair facts where they can reliably identify accepted bot-authored messages. The generic guard keys on `(scope, conversation, participant pair)`, suppresses every additional bot-to-bot event in either direction once a pair crosses the configured budget, and lifts suppression after `cooldownSeconds`. Defaults are `maxEventsPerWindow: 20`, `windowSeconds: 60`, and `cooldownSeconds: 60` whenever a channel lets bot-authored messages reach dispatch; they can be set globally via `channels.defaults.botLoopProtection` and overridden per channel/account or supported per-conversation config. Fixes #58789. Thanks @pandadev66.
 - Agents/memory-flush: surface non-abort memory-flush failures (provider timeout, transport error, generic agent failure) as visible reply payloads so the outer reply loop short-circuits and isolated cron runs propagate the error into `meta.error` instead of completing silently with `status: "ok"` and an empty payload. Previously only the specific "Memory flush writes are restricted to ..." message was surfaced. Refs #80755. Thanks @kinjitakabe and @nailujac.
+- Codex harness: use the active Codex runtime context window for OpenAI-selected budgeting, manual `/compact`, and `/status`, so stale OpenAI session metadata no longer overstates context limits. (#81906) thanks @jalehman.
 
 ## 2026.5.12
 
diff --git a/src/agents/openai-codex-routing.ts b/src/agents/openai-codex-routing.ts
@@ -149,3 +149,15 @@ export function resolveOpenAIRuntimeProviderForPi(params: {
     ? OPENAI_CODEX_PROVIDER_ID
     : params.provider;
 }
+
+export function resolveContextConfigProviderForRuntime(params: {
+  provider: string;
+  runtimeId?: string;
+}): string {
+  const provider = normalizeProviderId(params.provider);
+  const runtimeId = normalizeEmbeddedAgentRuntime(params.runtimeId);
+  if (provider === OPENAI_PROVIDER_ID && runtimeId === "codex") {
+    return OPENAI_CODEX_PROVIDER_ID;
+  }
+  return params.provider;
+}
diff --git a/src/agents/pi-embedded-runner/compact.queued.ts b/src/agents/pi-embedded-runner/compact.queued.ts
@@ -20,7 +20,11 @@ import { resolveUserPath } from "../../utils.js";
 import { resolveAgentDir, resolveSessionAgentIds } from "../agent-scope.js";
 import { resolveContextWindowInfo } from "../context-window-guard.js";
 import { DEFAULT_CONTEXT_TOKENS, DEFAULT_MODEL, DEFAULT_PROVIDER } from "../defaults.js";
-import { maybeCompactAgentHarnessSession } from "../harness/selection.js";
+import {
+  maybeCompactAgentHarnessSession,
+  resolveAgentHarnessPolicy,
+} from "../harness/selection.js";
+import { resolveContextConfigProviderForRuntime } from "../openai-codex-routing.js";
 import { ensureRuntimePluginsLoaded } from "../runtime-plugins.js";
 import type { CompactEmbeddedPiSessionParams } from "./compact.types.js";
 import { asCompactionHookRunner, runPostCompactionSideEffects } from "./compaction-hooks.js";
@@ -83,9 +87,19 @@ export async function compactEmbeddedPiSession(
       params.config,
     );
     const ceRuntimeModel = ceModel as ProviderRuntimeModel | undefined;
+    const ceHarnessPolicy = resolveAgentHarnessPolicy({
+      provider: ceProvider,
+      modelId: ceModelId,
+      config: params.config,
+      agentId: agentIds.sessionAgentId,
+      sessionKey: params.sessionKey,
+    });
     contextTokenBudget = resolveContextWindowInfo({
       cfg: params.config,
-      provider: ceProvider,
+      provider: resolveContextConfigProviderForRuntime({
+        provider: ceProvider,
+        runtimeId: ceHarnessPolicy.runtime,
+      }),
       modelId: ceModelId,
       modelContextTokens: readPiModelContextTokens(ceModel),
       modelContextWindow: ceRuntimeModel?.contextWindow,
diff --git a/src/agents/pi-embedded-runner/compact.ts b/src/agents/pi-embedded-runner/compact.ts
@@ -58,6 +58,7 @@ import { formatUserTime, resolveUserTimeFormat, resolveUserTimezone } from "../d
 import { DEFAULT_CONTEXT_TOKENS, DEFAULT_MODEL, DEFAULT_PROVIDER } from "../defaults.js";
 import { resolveOpenClawReferencePaths } from "../docs-path.js";
 import { coerceToFailoverError, describeFailoverError } from "../failover-error.js";
+import { resolveAgentHarnessPolicy } from "../harness/selection.js";
 import { resolveHeartbeatPromptForSystemPrompt } from "../heartbeat-system-prompt.js";
 import {
   applyAuthHeaderOverride,
@@ -68,6 +69,7 @@ import {
 import { isFallbackSummaryError, runWithModelFallback } from "../model-fallback.js";
 import { supportsModelTools } from "../model-tool-support.js";
 import { ensureOpenClawModelsJson } from "../models-config.js";
+import { resolveContextConfigProviderForRuntime } from "../openai-codex-routing.js";
 import { createBundleLspToolRuntime } from "../pi-bundle-lsp-runtime.js";
 import { createBundleMcpToolRuntime } from "../pi-bundle-mcp-tools.js";
 import { ensureSessionHeader } from "../pi-embedded-helpers.js";
@@ -646,9 +648,19 @@ async function compactEmbeddedPiSessionDirectOnce(
     // Apply contextTokens cap to model so pi-coding-agent's auto-compaction
     // threshold uses the effective limit, not the native context window.
     const runtimeModelWithContext = runtimeModel as ProviderRuntimeModel;
+    const runtimeHarnessPolicy = resolveAgentHarnessPolicy({
+      provider,
+      modelId,
+      config: params.config,
+      agentId: effectiveSkillAgentId,
+      sessionKey: params.sessionKey,
+    });
     const ctxInfo = resolveContextWindowInfo({
       cfg: params.config,
-      provider,
+      provider: resolveContextConfigProviderForRuntime({
+        provider,
+        runtimeId: runtimeHarnessPolicy.runtime,
+      }),
       modelId,
       modelContextTokens: readPiModelContextTokens(runtimeModel),
       modelContextWindow: runtimeModelWithContext.contextWindow,
diff --git a/src/agents/pi-embedded-runner/run.ts b/src/agents/pi-embedded-runner/run.ts
@@ -62,6 +62,7 @@ import {
   shouldPreferExplicitConfigApiKeyAuth,
 } from "../model-auth.js";
 import { ensureOpenClawModelsJson } from "../models-config.js";
+import { resolveContextConfigProviderForRuntime } from "../openai-codex-routing.js";
 import {
   retireSessionMcpRuntime,
   retireSessionMcpRuntimeForSessionKey,
@@ -189,16 +190,6 @@ const COMPACTION_CONTINUATION_RETRY_INSTRUCTION =
   "The previous attempt compacted the conversation context before producing a final user-visible answer. Continue from the compacted transcript and produce the final answer now. Do not restart from scratch, do not repeat completed work, and do not rerun tools unless the transcript clearly lacks required evidence.";
 type EmbeddedRunAttemptForRunner = Awaited<ReturnType<typeof runEmbeddedAttemptWithBackend>>;
 
-function resolveHarnessContextConfigProvider(params: {
-  provider: string;
-  harnessId: string;
-}): string {
-  if (params.harnessId === "codex" && params.provider.trim().toLowerCase() === "openai") {
-    return "openai-codex";
-  }
-  return params.provider;
-}
-
 function resolveEmbeddedRunLaneTimeoutMs(timeoutMs: number): number | undefined {
   if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
     return undefined;
@@ -597,9 +588,9 @@ export async function runEmbeddedPiAgent(
       const resolvedRuntimeModel = resolveEffectiveRuntimeModel({
         cfg: params.config,
         provider,
-        contextConfigProvider: resolveHarnessContextConfigProvider({
+        contextConfigProvider: resolveContextConfigProviderForRuntime({
           provider,
-          harnessId: agentHarness.id,
+          runtimeId: agentHarness.id,
         }),
         modelId,
         runtimeModel,
diff --git a/src/auto-reply/reply/commands-compact.test.ts b/src/auto-reply/reply/commands-compact.test.ts
@@ -20,8 +20,12 @@ vi.mock("./commands-compact.runtime.js", () => ({
   waitForEmbeddedPiRunEnd: vi.fn().mockResolvedValue(undefined),
 }));
 
-const { compactEmbeddedPiSession, incrementCompactionCount, resolveSessionFilePathOptions } =
-  await import("./commands-compact.runtime.js");
+const {
+  compactEmbeddedPiSession,
+  formatContextUsageShort,
+  incrementCompactionCount,
+  resolveSessionFilePathOptions,
+} = await import("./commands-compact.runtime.js");
 const { handleCompactCommand } = await import("./commands-compact.js");
 
 function buildCompactParams(
@@ -342,4 +346,54 @@ describe("handleCompactCommand", () => {
     expect(call.sessionEntry.sessionId).toBe("target-session");
     expect(call.tokensAfter).toBe(321);
   });
+
+  it("resolves /compact context budget from the active Codex runtime config instead of stale session metadata", async () => {
+    vi.mocked(compactEmbeddedPiSession).mockResolvedValueOnce({
+      ok: true,
+      compacted: true,
+      result: {
+        summary: "compacted",
+        firstKeptEntryId: "first-kept",
+        tokensBefore: 199_000,
+        tokensAfter: 56_000,
+      },
+    });
+
+    await handleCompactCommand(
+      {
+        ...buildCompactParams("/compact", {
+          agents: {
+            defaults: {
+              models: {
+                "openai/gpt-5.5": {
+                  agentRuntime: { id: "codex" },
+                },
+              },
+            },
+          },
+          commands: { text: true },
+          channels: { whatsapp: { allowFrom: ["*"] } },
+          models: {
+            providers: {
+              "openai-codex": {
+                models: [{ id: "gpt-5.5", contextWindow: 258_000 }],
+              },
+            },
+          },
+        } as unknown as OpenClawConfig),
+        provider: "openai",
+        model: "openai/gpt-5.5",
+        contextTokens: 0,
+        sessionEntry: {
+          sessionId: "live-session",
+          updatedAt: Date.now(),
+          contextTokens: 400_000,
+        },
+      } as HandleCommandsParams,
+      true,
+    );
+
+    expect(requireCompactEmbeddedPiSessionCall().contextTokenBudget).toBe(258_000);
+    expect(vi.mocked(formatContextUsageShort)).toHaveBeenLastCalledWith(56_000, 258_000);
+  });
 });
diff --git a/src/auto-reply/reply/commands-compact.ts b/src/auto-reply/reply/commands-compact.ts
@@ -1,4 +1,12 @@
 import { resolveAgentDir, resolveSessionAgentId } from "../../agents/agent-scope.js";
+import { resolveContextTokensForModel } from "../../agents/context.js";
+import { resolveAgentHarnessPolicy } from "../../agents/harness/selection.js";
+import {
+  OPENAI_CODEX_PROVIDER_ID,
+  OPENAI_PROVIDER_ID,
+  resolveContextConfigProviderForRuntime,
+} from "../../agents/openai-codex-routing.js";
+import { normalizeProviderId } from "../../agents/provider-id.js";
 import type { OpenClawConfig } from "../../config/types.openclaw.js";
 import { logVerbose } from "../../globals.js";
 import { createLazyImportLoader } from "../../shared/lazy-promise.js";
@@ -75,6 +83,99 @@ function formatCompactionReason(reason?: string): string | undefined {
   return text;
 }
 
+function resolveManualCompactContextTokenBudget(params: {
+  cfg: OpenClawConfig;
+  provider?: string;
+  model?: string;
+  agentId: string;
+  sessionKey: string;
+  liveContextTokens?: number;
+  persistedContextTokens?: number;
+}): number | undefined {
+  const liveContextTokens =
+    typeof params.liveContextTokens === "number" &&
+    Number.isFinite(params.liveContextTokens) &&
+    params.liveContextTokens > 0
+      ? Math.floor(params.liveContextTokens)
+      : undefined;
+
+  const model = normalizeOptionalString(params.model);
+  const provider = normalizeOptionalString(params.provider);
+  if (!model || !provider) {
+    return liveContextTokens ?? resolvePersistedContextTokens(params.persistedContextTokens);
+  }
+
+  const harnessPolicy = resolveAgentHarnessPolicy({
+    provider,
+    modelId: model,
+    config: params.cfg,
+    agentId: params.agentId,
+    sessionKey: params.sessionKey,
+  });
+  const contextConfigProvider = resolveContextConfigProviderForRuntime({
+    provider,
+    runtimeId: harnessPolicy.runtime,
+  });
+  const configuredContextTokens = resolveContextTokensForModel({
+    cfg: params.cfg,
+    provider: contextConfigProvider,
+    model: resolveManualCompactContextModelId({
+      provider,
+      contextConfigProvider,
+      model,
+    }),
+    allowAsyncLoad: false,
+  });
+  if (typeof configuredContextTokens === "number" && configuredContextTokens > 0) {
+    const configuredBudget = Math.floor(configuredContextTokens);
+    return liveContextTokens !== undefined
+      ? Math.min(liveContextTokens, configuredBudget)
+      : configuredBudget;
+  }
+
+  if (liveContextTokens !== undefined) {
+    return liveContextTokens;
+  }
+
+  return resolvePersistedContextTokens(params.persistedContextTokens);
+}
+
+function resolvePersistedContextTokens(value: number | undefined): number | undefined {
+  return typeof value === "number" && Number.isFinite(value) && value > 0
+    ? Math.floor(value)
+    : undefined;
+}
+
+function resolveManualCompactContextModelId(params: {
+  provider: string;
+  contextConfigProvider: string;
+  model: string;
+}): string {
+  const model = params.model.trim();
+  const slashIndex = model.indexOf("/");
+  if (slashIndex <= 0) {
+    return model;
+  }
+
+  const modelProvider = normalizeProviderId(model.slice(0, slashIndex));
+  const selectedProvider = normalizeProviderId(params.provider);
+  const contextConfigProvider = normalizeProviderId(params.contextConfigProvider);
+  const modelId = model.slice(slashIndex + 1).trim();
+  if (!modelId) {
+    return model;
+  }
+
+  if (
+    modelProvider === selectedProvider ||
+    modelProvider === contextConfigProvider ||
+    (modelProvider === OPENAI_PROVIDER_ID && contextConfigProvider === OPENAI_CODEX_PROVIDER_ID)
+  ) {
+    return modelId;
+  }
+
+  return model;
+}
+
 export const handleCompactCommand: CommandHandler = async (params) => {
   const compactRequested =
     params.command.commandBodyNormalized === "/compact" ||
@@ -116,6 +217,15 @@ export const handleCompactCommand: CommandHandler = async (params) => {
     agentId: sessionAgentId,
     isGroup: params.isGroup,
   });
+  const contextTokenBudget = resolveManualCompactContextTokenBudget({
+    cfg: params.cfg,
+    provider: params.provider,
+    model: params.model,
+    agentId: sessionAgentId,
+    sessionKey: params.sessionKey,
+    liveContextTokens: params.contextTokens,
+    persistedContextTokens: targetSessionEntry.contextTokens,
+  });
   const result = await runtime.compactEmbeddedPiSession({
     sessionId,
     sessionKey: params.sessionKey,
@@ -143,6 +253,7 @@ export const handleCompactCommand: CommandHandler = async (params) => {
     skillsSnapshot: targetSessionEntry.skillsSnapshot,
     provider: params.provider,
     model: params.model,
+    contextTokenBudget,
     agentHarnessId:
       targetSessionEntry.sessionId === sessionId ? targetSessionEntry.agentHarnessId : undefined,
     thinkLevel: params.resolvedThinkLevel ?? (await params.resolveDefaultThinkingLevel()),
@@ -186,7 +297,7 @@ export const handleCompactCommand: CommandHandler = async (params) => {
     tokensAfterCompaction ?? runtime.resolveFreshSessionTotalTokens(targetSessionEntry);
   const contextSummary = runtime.formatContextUsageShort(
     typeof totalTokens === "number" && totalTokens > 0 ? totalTokens : null,
-    params.contextTokens ?? targetSessionEntry.contextTokens ?? null,
+    contextTokenBudget ?? null,
   );
   const reason = formatCompactionReason(result.reason);
   const line = reason
diff --git a/src/auto-reply/reply/commands-status.test.ts b/src/auto-reply/reply/commands-status.test.ts
diff --git a/src/auto-reply/reply/directive-handling.persist.ts b/src/auto-reply/reply/directive-handling.persist.ts
diff --git a/src/status/status-message.ts b/src/status/status-message.ts
