- Agents/media: avoid direct generated-media completion fallback while the announce-agent run is still pending, so async video and music completions do not duplicate raw media messages. (#77754)

- WebChat/Codex media: stage Codex app-server generated local images into managed media before Gateway display, so Codex-home image paths no longer hit `LocalMediaAccessError` while keeping Codex home out of the display allowlist. Thanks @frankekn.

- Plugins/update: repair plugin-local `openclaw` peer links for all recorded npm plugins after any npm update mutates the shared managed npm tree, so targeted or batch updates cannot leave Codex, Discord, or Brave with pruned SDK imports. (#77787) Thanks @ProspectOre.

- Codex harness: honor `models.providers.openai-codex.models[].contextTokens` for native `openai/*` Codex runtime runs and `/status` context reporting, so subscription-backed Codex agents use the configured OAuth context cap without inflating past the runtime model window. Fixes #77858. Thanks @lilesjtu.

- TUI/sessions: bound the session picker to recent rows and use exact lookup-style refreshes for the active session, so dusty stores no longer make TUI hydrate weeks-old transcripts before becoming responsive. Thanks @vincentkoc.

- Doctor/gateway: report recent supervisor restart handoffs in `openclaw doctor --deep`, using the installed service environment when available so service-managed clean exits are visible in guided diagnostics. Thanks @shakkernerd.

- Gateway/status: show recent supervisor restart handoffs in `openclaw gateway status --deep`, including JSON details, so clean service-managed restarts are reported as restart handoffs instead of opaque stopped-service diagnostics. Thanks @shakkernerd.

name?: string;

provider: string;

contextWindow?: number;

contextTokens?: number;

reasoning?: boolean;

input?: ModelInputType[];

compat?: ModelCatalogEntry["compat"];

if (contextWindow) {

entry.contextWindow = contextWindow;

}

if (row.contextTokens) {

entry.contextTokens = row.contextTokens;

}

if (typeof row.reasoning === "boolean") {

entry.reasoning = row.reasoning;

}

entry: Record<string, unknown>,

defaults?: {

contextWindow?: number;

contextTokens?: number;

},

): ModelCatalogEntry | undefined {

const id = normalizeOptionalString(entry.id) ?? "";

: defaults?.contextWindow !== undefined

? defaults.contextWindow

: PI_CUSTOM_MODEL_DEFAULT_CONTEXT_WINDOW;

const contextTokens =

typeof entry?.contextTokens === "number" && entry.contextTokens > 0

? entry.contextTokens

: defaults?.contextTokens !== undefined

? defaults.contextTokens

: undefined;

const reasoning = typeof entry?.reasoning === "boolean" ? entry.reasoning : false;

const parsedInput = Array.isArray(entry?.input)

? entry.input.filter((value): value is ModelInputType =>

entry?.compat && typeof entry.compat === "object"

? (entry.compat as ModelCatalogEntry["compat"])

: undefined;

return { id, name, provider, contextWindow, reasoning, input, compat };

return {

id,

name,

provider,

contextWindow,

...(contextTokens !== undefined ? { contextTokens } : {}),

reasoning,

input,

compat,

};

}

async function loadReadOnlyPersistedModelCatalog(params?: {

typeof providerConfig?.contextWindow === "number" && providerConfig.contextWindow > 0

? providerConfig.contextWindow

: undefined;

const providerContextTokens =

typeof providerConfig?.contextTokens === "number" && providerConfig.contextTokens > 0

? providerConfig.contextTokens

: undefined;

for (const entry of providerConfig.models as Record<string, unknown>[]) {

const normalized = normalizePersistedModelCatalogEntry(providerRaw, entry, {

contextWindow: providerContextWindow,

contextTokens: providerContextTokens,

});

if (normalized && !shouldSuppressBuiltInModel(normalized)) {

models.push(normalized);

typeof entry?.contextWindow === "number" && entry.contextWindow > 0

? entry.contextWindow

: undefined;

const contextTokens =

typeof entry?.contextTokens === "number" && entry.contextTokens > 0

? entry.contextTokens

: undefined;

const reasoning = typeof entry?.reasoning === "boolean" ? entry.reasoning : undefined;

const input = Array.isArray(entry?.input) ? entry.input : undefined;

const compat = entry?.compat && typeof entry.compat === "object" ? entry.compat : undefined;

models.push({ id, name, provider, contextWindow, reasoning, input, compat });

models.push({

id,

name,

provider,

contextWindow,

...(contextTokens !== undefined ? { contextTokens } : {}),

reasoning,

input,

compat,

});

}

if (!readOnly) {

const supplemental = await augmentModelCatalogWithProviderPlugins({

provider: string;

alias?: string;

contextWindow?: number;

contextTokens?: number;

reasoning?: boolean;

input?: ModelInputType[];

compat?: ModelCompatConfig;

}

const nextAlias = alias ?? params.entry.alias;

const nextContextWindow = configuredEntry?.contextWindow ?? params.entry.contextWindow;

const nextContextTokens = configuredEntry?.contextTokens ?? params.entry.contextTokens;

const nextReasoning = configuredEntry?.reasoning ?? params.entry.reasoning;

const nextInput = configuredEntry?.input ?? params.entry.input;

const nextCompat = configuredEntry?.compat ?? params.entry.compat;

name: configuredEntry?.name ?? params.entry.name,

...(nextAlias ? { alias: nextAlias } : {}),

...(nextContextWindow !== undefined ? { contextWindow: nextContextWindow } : {}),

...(nextContextTokens !== undefined ? { contextTokens: nextContextTokens } : {}),

...(nextReasoning !== undefined ? { reasoning: nextReasoning } : {}),

...(nextInput ? { input: nextInput } : {}),

...(nextCompat ? { compat: nextCompat } : {}),

const configuredEntry = params.metadata.configuredByKey.get(key);

const alias = params.metadata.aliasByKey.get(key);

const nextContextWindow = configuredEntry?.contextWindow;

const nextContextTokens = configuredEntry?.contextTokens;

const nextReasoning = configuredEntry?.reasoning;

const nextInput = configuredEntry?.input;

const nextCompat = configuredEntry?.compat;

provider: params.parsed.provider,

...(alias ? { alias } : {}),

...(nextContextWindow !== undefined ? { contextWindow: nextContextWindow } : {}),

...(nextContextTokens !== undefined ? { contextTokens: nextContextTokens } : {}),

...(nextReasoning !== undefined ? { reasoning: nextReasoning } : {}),

...(nextInput ? { input: nextInput } : {}),

...(nextCompat ? { compat: nextCompat } : {}),

typeof model?.contextWindow === "number" && model.contextWindow > 0

? model.contextWindow

: undefined;

const contextTokens =

typeof model?.contextTokens === "number" && model.contextTokens > 0

? model.contextTokens

: undefined;

const reasoning = typeof model?.reasoning === "boolean" ? model.reasoning : undefined;

const input = Array.isArray(model?.input) ? model.input : undefined;

const compat = model?.compat && typeof model.compat === "object" ? model.compat : undefined;

id,

name,

contextWindow,

contextTokens,

reasoning,

input,

compat,

"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;

const resolvedRuntimeModel = resolveEffectiveRuntimeModel({

cfg: params.config,

provider,

contextConfigProvider: resolveHarnessContextConfigProvider({

provider,

harnessId: agentHarness.id,

}),

modelId,

runtimeModel,

});

import { describe, expect, it, vi } from "vitest";

import { buildBeforeModelResolveAttachments, resolveHookModelSelection } from "./setup.js";

import type { ModelDefinitionConfig } from "../../../config/types.models.js";

import type { OpenClawConfig } from "../../../config/types.openclaw.js";

import type { ProviderRuntimeModel } from "../../../plugins/provider-runtime-model.types.js";

import {

buildBeforeModelResolveAttachments,

resolveEffectiveRuntimeModel,

resolveHookModelSelection,

} from "./setup.js";

const hookContext = {

sessionId: "session-1",

);

});

});

function createRuntimeModel(): ProviderRuntimeModel {

return {

provider: "openai",

id: "gpt-5.5",

name: "gpt-5.5",

baseUrl: "https://api.openai.com/v1",

api: "openai-responses",

reasoning: true,

input: ["text", "image"],

cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },

contextWindow: 1_050_000,

contextTokens: 272_000,

maxTokens: 128_000,

};

}

function createConfiguredModel(

overrides: Partial<ModelDefinitionConfig> = {},

): ModelDefinitionConfig {

return {

id: "gpt-5.5",

name: "gpt-5.5",

reasoning: true,

input: ["text", "image"],

cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },

contextWindow: 1_050_000,

contextTokens: 1_000_000,

maxTokens: 128_000,

...overrides,

};

}

describe("resolveEffectiveRuntimeModel", () => {

it("can read Codex OAuth context overrides for native Codex harness runs", () => {

const cfg = {

models: {

providers: {

"openai-codex": {

baseUrl: "https://chatgpt.com/backend-api/codex",

models: [createConfiguredModel()],

},

},

},

} satisfies OpenClawConfig;

const result = resolveEffectiveRuntimeModel({

cfg,

provider: "openai",

contextConfigProvider: "openai-codex",

modelId: "gpt-5.5",

runtimeModel: createRuntimeModel(),

});

expect(result.ctxInfo).toEqual({

source: "modelsConfig",

tokens: 1_000_000,

});

expect(result.effectiveModel.contextWindow).toBe(1_000_000);

});

it("keeps the runtime model contextTokens when no alternate context provider is supplied", () => {

const cfg = {

models: {

providers: {

"openai-codex": {

baseUrl: "https://chatgpt.com/backend-api/codex",

models: [createConfiguredModel()],

},

},

},

} satisfies OpenClawConfig;

const result = resolveEffectiveRuntimeModel({

cfg,

provider: "openai",

modelId: "gpt-5.5",

runtimeModel: createRuntimeModel(),

});

expect(result.ctxInfo).toEqual({

source: "model",

tokens: 272_000,

});

expect(result.effectiveModel.contextWindow).toBe(272_000);

});

});

export function resolveEffectiveRuntimeModel(params: {

cfg: OpenClawConfig | undefined;

provider: string;

contextConfigProvider?: string;

modelId: string;

runtimeModel: ProviderRuntimeModel;

}): {

} {

const ctxInfo = resolveContextWindowInfo({

cfg: params.cfg,

provider: params.provider,

provider: params.contextConfigProvider ?? params.provider,

modelId: params.modelId,

modelContextTokens: readPiModelContextTokens(params.runtimeModel),

modelContextWindow: params.runtimeModel.contextWindow,

addSubagentRunForTests,

resetSubagentRegistryForTests,

} from "../../agents/subagent-registry.js";

import type { ModelDefinitionConfig } from "../../config/types.models.js";

import {

completeTaskRunByRunId,

createQueuedTaskRun,

}));

const baseCfg = baseCommandTestConfig;

const codexStatusModel: ModelDefinitionConfig = {

id: "gpt-5.5",

name: "GPT-5.5",

reasoning: true,

input: ["text", "image"],

cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },

contextWindow: 1_050_000,

contextTokens: 1_000_000,

maxTokens: 128_000,

};

async function buildStatusReplyForTest(params: { sessionKey?: string; verbose?: boolean }) {

const commandParams = buildCommandTestParams("/status", baseCfg);

);

});

it("uses Codex OAuth context overrides for openai models running on the Codex harness", async () => {

registerStatusCodexHarness();

const text = await buildStatusText({

cfg: {

...baseCfg,

models: {

providers: {

"openai-codex": {

baseUrl: "https://chatgpt.com/backend-api/codex",

models: [codexStatusModel],

},

},

},

agents: {

defaults: {

agentRuntime: { id: "codex" },

},

},

},

sessionEntry: {

sessionId: "sess-status-codex-context",

updatedAt: 0,

totalTokens: 25_000,

},

sessionKey: "agent:main:main",

parentSessionKey: "agent:main:main",

sessionScope: "per-sender",

statusChannel: "mobilechat",

provider: "openai",

model: "gpt-5.5",

resolvedFastMode: false,

resolvedVerboseLevel: "off",

resolvedReasoningLevel: "off",

resolveDefaultThinkingLevel: async () => undefined,

isGroup: false,

defaultGroupActivation: () => "mention",

modelAuthOverride: "oauth",

activeModelAuthOverride: "oauth",

});

const normalized = normalizeTestText(text);

expect(normalized).toContain("Model: openai/gpt-5.5");

expect(normalized).toContain("Context: 25k/1.0m");

});

it("uses workspace-scoped auth evidence in /status auth labels", async () => {

const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), "openclaw-status-auth-label-"));

const workspaceDir = path.join(tempRoot, "workspace");