runId: "run-claude-channel-wrapper",

messageChannel: "telegram",

messageProvider: "acp",

currentChannelId: "telegram:-100123:topic:42",

currentThreadTs: "42",

currentMessageId: "reply-message-1",

});

expect(params.messageChannel).toBe("telegram");

expect(params.messageProvider).toBe("acp");

expect(params.currentChannelId).toBe("telegram:-100123:topic:42");

expect(params.currentThreadTs).toBe("42");

expect(params.currentMessageId).toBe("reply-message-1");

expect(params.cwd).toBe("/tmp/task-repo");

});

images: params.images,

messageChannel: params.messageChannel,

messageProvider: params.messageProvider,

currentChannelId: params.currentChannelId,

currentThreadTs: params.currentThreadTs,

currentMessageId: params.currentMessageId,

};

}

"x-openclaw-agent-id": "${OPENCLAW_MCP_AGENT_ID}",

"x-openclaw-account-id": "${OPENCLAW_MCP_ACCOUNT_ID}",

"x-openclaw-message-channel": "${OPENCLAW_MCP_MESSAGE_CHANNEL}",

"x-openclaw-current-channel-id": "${OPENCLAW_MCP_CURRENT_CHANNEL_ID}",

"x-openclaw-current-thread-ts": "${OPENCLAW_MCP_CURRENT_THREAD_TS}",

"x-openclaw-current-message-id": "${OPENCLAW_MCP_CURRENT_MESSAGE_ID}",

"x-openclaw-inbound-event-kind": "${OPENCLAW_MCP_INBOUND_EVENT_KIND}",

"x-openclaw-source-reply-delivery-mode": "${OPENCLAW_MCP_SOURCE_REPLY_DELIVERY_MODE}",

},

cfg: expect.any(Object),

sessionKey: "agent:main:test",

messageProvider: undefined,

currentChannelId: undefined,

currentThreadTs: undefined,

currentMessageId: undefined,

accountId: undefined,

inboundEventKind: undefined,

sourceReplyDeliveryMode: undefined,

config: createCliBackendConfig(),

currentInboundEventKind: "room_event",

messageChannel: "telegram",

currentChannelId: "telegram:-100123:topic:42",

currentThreadTs: "42",

currentMessageId: "reply-message-1",

sourceReplyDeliveryMode: "message_tool_only",

});

expect(context.preparedBackend.env).toMatchObject({

OPENCLAW_MCP_MESSAGE_CHANNEL: "telegram",

OPENCLAW_MCP_CURRENT_CHANNEL_ID: "telegram:-100123:topic:42",

OPENCLAW_MCP_CURRENT_THREAD_TS: "42",

OPENCLAW_MCP_CURRENT_MESSAGE_ID: "reply-message-1",

OPENCLAW_MCP_INBOUND_EVENT_KIND: "room_event",

OPENCLAW_MCP_SOURCE_REPLY_DELIVERY_MODE: "message_tool_only",

});

OPENCLAW_MCP_ACCOUNT_ID: params.agentAccountId ?? "",

OPENCLAW_MCP_SESSION_KEY: params.sessionKey ?? "",

OPENCLAW_MCP_MESSAGE_CHANNEL: params.messageChannel ?? params.messageProvider ?? "",

OPENCLAW_MCP_CURRENT_CHANNEL_ID: params.currentChannelId ?? "",

OPENCLAW_MCP_CURRENT_THREAD_TS: params.currentThreadTs ?? "",

OPENCLAW_MCP_CURRENT_MESSAGE_ID:

params.currentMessageId != null ? String(params.currentMessageId) : "",

OPENCLAW_MCP_INBOUND_EVENT_KIND: params.currentInboundEventKind ?? "",

OPENCLAW_MCP_SOURCE_REPLY_DELIVERY_MODE: params.sourceReplyDeliveryMode ?? "",

}

cfg: params.config ?? getRuntimeConfig(),

sessionKey: params.sessionKey ?? "",

messageProvider: params.messageChannel ?? params.messageProvider,

currentChannelId: params.currentChannelId,

currentThreadTs: params.currentThreadTs,

currentMessageId: params.currentMessageId,

accountId: params.agentAccountId,

inboundEventKind: params.currentInboundEventKind,

sourceReplyDeliveryMode: params.sourceReplyDeliveryMode,

skillsSnapshot?: SkillSnapshot;

messageChannel?: string;

messageProvider?: string;

currentChannelId?: string;

currentThreadTs?: string;

currentMessageId?: string | number;

agentAccountId?: string;

/** Trusted sender identity bit for channel action auth. */

senderIsOwner?: boolean;

expect(parameters.properties?.timeoutMs).toMatchObject({ type: "integer", minimum: 1 });

});

it("instructs agents to use continuationMessage when a restart still needs a reply", async () => {

it("instructs agents to use continuationMessage for internal post-restart work", async () => {

const tool = createGatewayTool();

expect(tool.description).toContain("still owe the user a reply");

expect(tool.description).toContain("post-restart work must continue internally");

expect(tool.description).toContain(

"visible follow-up from that turn must use the message tool",

);

expect(tool.description).toContain("continuationMessage");

expect(tool.description).toContain("do not write restart sentinel files directly");

expect(tool.description).toContain("Do not write restart sentinel files directly");

});

it("writes an agentTurn continuation into the restart sentinel", async () => {

});

});

it("defaults session-scoped restarts to a success continuation", async () => {

const { DEFAULT_RESTART_SUCCESS_CONTINUATION_MESSAGE } =

await import("../../infra/restart-sentinel.js");

it("does not infer a continuation for session-scoped restarts", async () => {

const tool = createGatewayTool({

agentSessionKey: "agent:main:main",

config: {},

const payload = requireRestartSentinelPayload();

expect(payload.sessionKey).toBe("agent:main:main");

expect(payload.continuation).toEqual({

kind: "agentTurn",

message: DEFAULT_RESTART_SUCCESS_CONTINUATION_MESSAGE,

});

expect(payload.continuation).toBeNull();

});

it("removes the prepared sentinel when restart emission is rejected", async () => {

label: "Gateway",

name: "gateway",

description:

"Gateway restart/config/update. Before config edits, use config.schema.lookup with targeted dot path. Prefer config.patch for partial merge; config.apply only full replace. Writes hot-reload or restart as needed. Always pass human `note` for post-restart delivery. If still owe the user a reply, pass one-shot `continuationMessage`; do not write restart sentinel files directly.",

"Gateway restart/config/update. Before config edits, use config.schema.lookup with targeted dot path. Prefer config.patch for partial merge; config.apply only full replace. Writes hot-reload or restart as needed. Always pass human `note` for post-restart delivery. If post-restart work must continue internally, pass one-shot `continuationMessage`; visible follow-up from that turn must use the message tool. Do not write restart sentinel files directly.",

parameters: GatewayToolSchema,

execute: async (_toolCallId, args) => {

const params = args as Record<string, unknown>;

originatingChannel: params.followupRun.originatingChannel,

provider: params.sessionCtx.Provider,

});

const cliCurrentThreadId =

params.followupRun.originatingThreadId ?? params.sessionCtx.MessageThreadId;

const isRestartSentinelContinuation =

params.sessionCtx.InputProvenance?.kind === "internal_system" &&

params.sessionCtx.InputProvenance.sourceTool === "restart-sentinel";

const cliCurrentMessageId = isRestartSentinelContinuation

? params.sessionCtx.ReplyToId

: (params.sessionCtx.MessageSidFull ?? params.sessionCtx.MessageSid);

const result = await agentTurnTiming.measure("cli_run", () =>

runCliAgentWithLifecycle({

runId,

skillsSnapshot: params.followupRun.run.skillsSnapshot,

messageChannel: params.followupRun.originatingChannel ?? undefined,

messageProvider: hookMessageProvider,

currentChannelId:

params.followupRun.originatingTo ??

params.sessionCtx.OriginatingTo ??

params.sessionCtx.To,

currentThreadTs:

cliCurrentThreadId != null ? String(cliCurrentThreadId) : undefined,

currentMessageId: cliCurrentMessageId,

agentAccountId: params.followupRun.run.agentAccountId,

senderIsOwner: params.followupRun.run.senderIsOwner,

disableTools: params.opts?.disableTools,

expect(context.currentChannelId).toBe("channel:123456789012345678");

expect(context.currentMessageId).toBe("msg-9");

});

it("does not expose restart-sentinel synthetic ids as message-tool reply targets", () => {

hoisted.getChannelPluginMock.mockReturnValue({

threading: {

buildToolContext: ({

context,

}: {

context: { To?: string; MessageThreadId?: string | number };

}) => ({

currentChannelId: context.To,

currentThreadTs:

context.MessageThreadId != null ? String(context.MessageThreadId) : undefined,

}),

},

});

const context = buildThreadingToolContext({

sessionCtx: {

Provider: "webchat",

OriginatingChannel: "telegram",

OriginatingTo: "telegram:-1003841603622:topic:928",

MessageThreadId: 928,

MessageSid: "restart-sentinel:agent:main:telegram:agentTurn:123",

InputProvenance: {

kind: "internal_system",

sourceChannel: "telegram",

sourceTool: "restart-sentinel",

},

},

config: {},

hasRepliedRef: undefined,

});

expect(context.currentChannelId).toBe("telegram:-1003841603622:topic:928");

expect(context.currentThreadTs).toBe("928");

expect(context.currentMessageId).toBeUndefined();

});

it("uses restart-sentinel reply target when one exists", () => {

const context = buildThreadingToolContext({

sessionCtx: {

Provider: "webchat",

OriginatingChannel: "whatsapp",

OriginatingTo: "whatsapp:+15550002",

ReplyToId: "provider-reply-id",

MessageSid: "restart-sentinel:agent:main:whatsapp:agentTurn:123",

InputProvenance: {

kind: "internal_system",

sourceChannel: "whatsapp",

sourceTool: "restart-sentinel",

},

},

config: {},

hasRepliedRef: undefined,

});

expect(context.currentChannelId).toBe("whatsapp:+15550002");

expect(context.currentMessageId).toBe("provider-reply-id");

});

});

hasRepliedRef: { value: boolean } | undefined;

}): ChannelThreadingToolContext {

const { sessionCtx, config, hasRepliedRef } = params;

const currentMessageId = sessionCtx.MessageSidFull ?? sessionCtx.MessageSid;

const isRestartSentinelContinuation =

sessionCtx.InputProvenance?.kind === "internal_system" &&

sessionCtx.InputProvenance.sourceTool === "restart-sentinel";

const currentMessageId = isRestartSentinelContinuation

? sessionCtx.ReplyToId

: (sessionCtx.MessageSidFull ?? sessionCtx.MessageSid);

const originProvider = resolveOriginMessageProvider({

originatingChannel: sessionCtx.OriginatingChannel,

provider: sessionCtx.Provider,