- Agents/tools: add optional per-call `timeoutMs` support for image, video, music, and TTS generation tools so agents can extend provider request timeouts only when a specific generation needs it.

- Agents/subagents: add optional forked context for native `sessions_spawn` runs so agents can let a child inherit the requester transcript when needed, while keeping clean isolated sessions as the default; includes prompt guidance, context-engine hook metadata, docs, and QA coverage.

- Codex harness: add structured debug logging for embedded harness selection decisions so `/status` stays simple while gateway logs explain auto-selection and Pi fallback reasons. (#70760) Thanks @100yenadmin.

- Plugin SDK/Codex harness: add provider-owned transport/auth/follow-up seams and harness result classification so Codex-style runtimes can participate in fallback policy without core special-casing. (#70772) Thanks @100yenadmin.

- Dependencies/Pi: update bundled Pi packages to `0.70.0`, use Pi's upstream `gpt-5.5` catalog metadata for OpenAI and OpenAI Codex, and keep only local `gpt-5.5-pro` forward-compat handling.

- Models/CLI: speed up `openclaw models list --all --provider <id>` for bundled providers with safe static catalogs while keeping live and third-party providers on registry discovery. (#70632) Thanks @shakkernerd.

- Models/CLI: avoid broad registry enumeration for default `openclaw models list`, reducing default listing latency while preserving configured-row output. (#70883) Thanks @shakkernerd.

c57d43f93ec2930b099dd5c5777f201f1bdd1ab432eeb4049b6e62ff23fe8112 plugin-sdk-api-baseline.json

ece1ea689914c4070b587551e86c6bed6598feba90457ab489222e168b2d9298 plugin-sdk-api-baseline.jsonl

8ca22ea6125fb198641c676d73b4df5a3bc49079be68bef8ed0718a54c1bb53a plugin-sdk-api-baseline.json

197d9743128020062fc457228fa9139d0bd465d9e1775101bfc39137f4a10896 plugin-sdk-api-baseline.jsonl

- calls `api.runtime.*` or the matching `plugin-sdk/*-runtime` helper

- never calls a vendor implementation directly

## Provider and Harness Seams

Use provider hooks when the behavior belongs to the model provider contract

rather than the generic agent loop. Examples include provider-specific request

params after transport selection, auth-profile preference, prompt overlays, and

follow-up fallback routing after model/profile failover.

Use agent harness hooks when the behavior belongs to the runtime that is

executing a turn. Harnesses can classify successful-but-unusable attempt results

such as empty, reasoning-only, or planning-only responses so the outer model

fallback policy can make the retry decision.

Keep both seams narrow:

- core owns the retry/fallback policy

- provider plugins own provider-specific request/auth/routing hints

- harness plugins own runtime-specific attempt classification

- third-party plugins return hints, not direct mutations of core state

## File checklist

For a new capability, expect to touch these areas:

---

Plugins extend OpenClaw with new capabilities: channels, model providers,

tools, skills, speech, realtime transcription, realtime voice,

media-understanding, image generation, video generation, web fetch, web

agent harnesses, tools, skills, speech, realtime transcription, realtime

voice, media-understanding, image generation, video generation, web fetch, web

search, and more. Some plugins are **core** (shipped with OpenClaw), others

are **external** (published on npm by the community).

sessionId: params.sessionId,

provider: params.provider,

model: params.modelId,

resolvedRef: `${params.provider}/${params.modelId}`,

assistantTexts: [],

},

ctx: hookContext,

sessionId: params.sessionId,

provider: params.provider,

model: params.modelId,

resolvedRef: `${params.provider}/${params.modelId}`,

assistantTexts: result.assistantTexts,

...(result.lastAssistant ? { lastAssistant: result.lastAssistant } : {}),

...(result.attemptUsage ? { usage: result.attemptUsage } : {}),

it("lets /status bypass a busy Telegram topic lane", async () => {

installPerKeySequentializer();

loadConfig.mockReturnValue({

commands: { native: true },

channels: {

telegram: {

dmPolicy: "open",

sessionId: params.sessionId,

provider: params.provider,

model: context.modelId,

resolvedRef: `${params.provider}/${context.modelId}`,

assistantTexts,

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

...(output.usage ? { usage: output.usage } : {}),

export {

abortEmbeddedAgentRun,

compactEmbeddedAgentSession,

isEmbeddedAgentRunActive,

isEmbeddedAgentRunStreaming,

queueEmbeddedAgentMessage,

resolveActiveEmbeddedAgentRunSessionId,

resolveEmbeddedSessionLane,

runEmbeddedAgent,

waitForEmbeddedAgentRunEnd,

} from "./pi-embedded-runner.js";

export type {

EmbeddedAgentCompactResult,

EmbeddedAgentMeta,

EmbeddedAgentRunMeta,

EmbeddedAgentRunResult,

} from "./pi-embedded-runner.js";

expect(piRunAttempt).not.toHaveBeenCalled();

});

it("annotates non-ok harness result classifications for outer model fallback", async () => {

process.env.OPENCLAW_AGENT_RUNTIME = "auto";

const classify = vi.fn(() => "empty" as const);

registerAgentHarness(

{

id: "codex",

label: "Classifying Codex",

supports: (ctx) =>

ctx.provider === "codex" ? { supported: true, priority: 100 } : { supported: false },

runAttempt: vi.fn(async () => createAttemptResult("codex")),

classify,

},

{ ownerPluginId: "codex" },

);

const params = createAttemptParams();

const result = await runAgentHarnessAttemptWithFallback(params);

expect(classify).toHaveBeenCalledWith(

expect.objectContaining({ sessionIdUsed: "codex" }),

params,

);

expect(result).toMatchObject({

agentHarnessId: "codex",

agentHarnessResultClassification: "empty",

});

});

it("honors env fallback override over config fallback", async () => {

process.env.OPENCLAW_AGENT_RUNTIME = "auto";

process.env.OPENCLAW_AGENT_HARNESS_FALLBACK = "none";

});

if (harness.id === "pi") {

const result = await harness.runAttempt(params);

return { ...result, agentHarnessId: harness.id };

return applyHarnessResultClassification(harness, result, params);

}

try {

const result = await harness.runAttempt(params);

return { ...result, agentHarnessId: harness.id };

return applyHarnessResultClassification(harness, result, params);

} catch (error) {

log.warn(`${harness.label} failed; not falling back to embedded PI backend`, {

harnessId: harness.id,

});

}

function applyHarnessResultClassification(

harness: AgentHarness,

result: EmbeddedRunAttemptResult,

params: EmbeddedRunAttemptParams,

): EmbeddedRunAttemptResult {

const classification = harness.classify?.(result, params);

if (!classification || classification === "ok") {

return { ...result, agentHarnessId: harness.id };

}

return {

...result,

agentHarnessId: harness.id,

agentHarnessResultClassification: classification,

};

}

function resolvePinnedAgentHarnessPolicy(

agentHarnessId: string | undefined,

): AgentHarnessPolicy | undefined {