env:

RELEASE_TAG: ${{ inputs.tag }}

run: echo "Approved Docker backfill for $RELEASE_TAG"

description: Release tag to publish (for example v2026.3.14, v2026.3.14-beta.1, or fallback v2026.3.14-1)

env:

RELEASE_TAG: ${{ github.ref_name }}

- CI/channel test routing: move the built-in channel suites into `test:channels` and keep them out of `test:extensions`, so extension CI no longer fails after the channel migration while targeted test routing still sends Slack, Signal, and iMessage suites to the right lane. (#46066) Thanks @scoootscooob.

- Agents/usage tracking: stop forcing `supportsUsageInStreaming: false` on non-native openai-completions endpoints so providers like DashScope, DeepSeek, and other OpenAI-compatible backends report token usage and cost instead of showing all zeros. (#46142)

- Gateway/websocket pairing bypass for disabled auth: skip device-pairing enforcement when `gateway.auth.mode=none` so Control UI connections behind reverse proxies no longer get stuck on `pairing required` (code 1008) despite auth being explicitly disabled. (#42931)

- Auth/login lockout recovery: clear stale `auth_permanent` and `billing` disabled state for all profiles matching the target provider when `openclaw models auth login` is invoked, so users locked out by expired or revoked OAuth tokens can recover by re-authenticating instead of waiting for the cooldown timer to expire. (#43057)

- Feishu/streaming recovery: clear stale `streamingStartPromise` when card creation fails (HTTP 400) so subsequent messages can retry streaming instead of silently dropping all future replies. Fixes #43322.

- **Andrew (Bubbles) Demczuk** - Agents/Gateway/TTS/VTT

- GitHub: [@ademczuk](https://github.com/ademczuk) · X: [@ademczuk](https://x.com/ademczuk)

- Fallback correction tag: `vYYYY.M.D-N`

- Use only as a last-resort recovery tag when a published immutable release burned the original stable tag and you cannot reuse it.

- The npm package version stays `YYYY.M.D`; the `-N` suffix is only for the git tag and GitHub release.

- Prefer betas for normal pre-release iteration, then cut a clean stable tag once ready.

- The tag-triggered preview run accepts stable, beta, and fallback correction tags, and rejects versions whose CalVer date is more than 2 UTC calendar days away from the release date.

- Treat correction tags as a fallback-only escape hatch. New releases should still use `vYYYY.M.D` for stable and `vYYYY.M.D-beta.N` for beta.

- Fallback correction tags like `v2026.3.13-1` map to npm version `2026.3.13`.

- Both the preview run and the manual publish run reject tags that do not map back to `package.json`, are not on `main`, or whose CalVer date is more than 2 UTC calendar days away from the release date.

- If `[email protected]` is already published, a fallback correction tag is still useful for GitHub release and Docker recovery, but npm publish will not republish that version.

- **Tag needs recovery after a late fix**: if the original stable tag is tied to an immutable GitHub release, mint a fallback correction tag like `vX.Y.Z-1` instead of trying to force-update `vX.Y.Z`.

- Keep the npm package version at `X.Y.Z`; the correction suffix is for the git tag and GitHub release only.

- Use this only as a last resort. For normal iteration, prefer beta tags and then cut a clean stable release.

it("recovers streaming after start() throws (HTTP 400)", async () => {

const errorMock = vi.fn();

let shouldFailStart = true;

// Intercept streaming instance creation to make first start() reject

const origPush = streamingInstances.push;

streamingInstances.push = function (this: any[], ...args: any[]) {

if (shouldFailStart) {

args[0].start = vi

.fn()

.mockRejectedValue(new Error("Create card request failed with HTTP 400"));

shouldFailStart = false;

}

return origPush.apply(this, args);

} as any;

try {

createFeishuReplyDispatcher({

cfg: {} as never,

agentId: "agent",

runtime: { log: vi.fn(), error: errorMock } as never,

chatId: "oc_chat",

});

const options = createReplyDispatcherWithTypingMock.mock.calls[0]?.[0];

// First deliver with markdown triggers startStreaming - which will fail

await options.deliver({ text: "```ts\nconst x = 1\n```" }, { kind: "block" });

// Wait for the async error to propagate

await vi.waitFor(() => {

expect(errorMock).toHaveBeenCalledWith(expect.stringContaining("streaming start failed"));

});

// Second deliver should create a NEW streaming session (not stuck)

await options.deliver({ text: "```ts\nconst y = 2\n```" }, { kind: "final" });

// Two instances created: first failed, second succeeded and closed

expect(streamingInstances).toHaveLength(2);

expect(streamingInstances[1].start).toHaveBeenCalled();

expect(streamingInstances[1].close).toHaveBeenCalled();

} finally {

streamingInstances.push = origPush;

}

});

streamingStartPromise = null; // allow retry on next deliver

return monitorSignalProvider({

config: config as OpenClawConfig,

...opts,

});

await vi.waitFor(() => {

expect(sendMock).toHaveBeenCalledTimes(1);

});

await vi.waitFor(() => {

expect(sendMock).toHaveBeenCalledTimes(1);

});

config?: Record<string, unknown>;

export const getSlackHandlers = () => ensureSlackTestRuntime().handlers;

export const getSlackClient = () => ensureSlackTestRuntime().client;

function ensureSlackTestRuntime(): {

handlers: Map<string, SlackHandler>;

client: SlackClient;

} {

const globalState = globalThis as {

__slackHandlers?: Map<string, SlackHandler>;

__slackClient?: SlackClient;

};

if (!globalState.__slackHandlers) {

globalState.__slackHandlers = new Map<string, SlackHandler>();

}

if (!globalState.__slackClient) {

globalState.__slackClient = {

auth: { test: vi.fn().mockResolvedValue({ user_id: "bot-user" }) },

conversations: {

info: vi.fn().mockResolvedValue({

channel: { name: "dm", is_im: true },

}),

replies: vi.fn().mockResolvedValue({ messages: [] }),

history: vi.fn().mockResolvedValue({ messages: [] }),

},

users: {

info: vi.fn().mockResolvedValue({

user: { profile: { display_name: "Ada" } },

}),

},

assistant: {

threads: {

setStatus: vi.fn().mockResolvedValue({ ok: true }),

},

},

reactions: {

add: (...args: unknown[]) => slackTestState.reactMock(...args),

},

};

}

return {

handlers: globalState.__slackHandlers,

client: globalState.__slackClient,

};

config: slackTestState.config,

const { handlers, client: slackClient } = ensureSlackTestRuntime();

client = slackClient;