vultr/openclaw
1
0
Fork 0
mirror of https://github.com/openclaw/openclaw.git synced 2026-05-06 08:00:42 +00:00
Code Issues Packages Projects Releases Wiki Activity

fix(trace command): Improve trace raw diagnostics and trace command UX (#66089)

Browse Source 
* improve trace raw diagnostics and command acks

* address trace review feedback

* avoid sync transcript reads in raw trace

* preserve raw cli output for trace

* gate trace emission at reply time

* reflect raw trace mode in status surfaces
This commit is contained in:
Tak Hoffman
2026-04-13 14:26:57 -05:00
committed by GitHub
parent 6157933e39
commit 7c09ba70ef
32 changed files with 2081 additions and 101 deletions
Download Patch File Download Diff File Expand all files Collapse all files

33
src/agents/cli-output.test.ts
View File

@@ -123,6 +123,39 @@ describe("parseCliJson", () => {
},
});
});
it("parses nested OpenAI-style cached token details from CLI json payloads", () => {
const result = parseCliJson(
JSON.stringify({
session_id: "openai-session-123",
response: "OpenAI says hello",
usage: {
input_tokens: 15,
output_tokens: 4,
input_tokens_details: {
cached_tokens: 6,
},
},
}),
{
command: "codex",
output: "json",
sessionIdFields: ["session_id"],
},
);
expect(result).toEqual({
text: "OpenAI says hello",
sessionId: "openai-session-123",
usage: {
input: 9,
output: 4,
cacheRead: 6,
cacheWrite: undefined,
total: undefined,
},
});
});
});
describe("parseCliJsonl", () => {

18
src/agents/cli-output.ts
View File

@@ -12,8 +12,10 @@ type CliUsage = {
export type CliOutput = {
text: string;
rawText?: string;
sessionId?: string;
usage?: CliUsage;
finalPromptText?: string;
};
export type CliStreamingDelta = {
@@ -149,18 +151,30 @@ function unwrapCliErrorText(raw: string): string {
}
function toCliUsage(raw: Record<string, unknown>): CliUsage | undefined {
const readNestedCached = (key: "input_tokens_details" | "prompt_tokens_details") => {
const nested = raw[key];
if (!isRecord(nested)) {
return undefined;
}
return typeof nested.cached_tokens === "number" && nested.cached_tokens > 0
? nested.cached_tokens
: undefined;
};
const pick = (key: string) =>
typeof raw[key] === "number" && raw[key] > 0 ? raw[key] : undefined;
const totalInput = pick("input_tokens") ?? pick("inputTokens");
const output = pick("output_tokens") ?? pick("outputTokens");
const nestedCached =
readNestedCached("input_tokens_details") ?? readNestedCached("prompt_tokens_details");
const cacheRead =
pick("cache_read_input_tokens") ??
pick("cached_input_tokens") ??
pick("cacheRead") ??
pick("cached");
pick("cached") ??
nestedCached;
const input =
pick("input") ??
(Object.hasOwn(raw, "cached") && typeof totalInput === "number"
((Object.hasOwn(raw, "cached") || nestedCached !== undefined) && typeof totalInput === "number"
? Math.max(0, totalInput - (cacheRead ?? 0))
: totalInput);
const cacheWrite =

69
src/agents/cli-runner.reliability.test.ts
View File

@@ -33,6 +33,7 @@ function buildPreparedContext(params?: {
prompt: "hi",
provider: "codex-cli",
model: "gpt-5.4",
thinkLevel: "low",
timeoutMs: 1_000,
runId: params?.runId ?? "run-2",
},
@@ -177,6 +178,74 @@ describe("runCliAgent reliability", () => {
expect(supervisorSpawnMock).toHaveBeenCalledTimes(2);
});
it("returns the assembled CLI prompt in meta for raw trace consumers", async () => {
supervisorSpawnMock.mockResolvedValueOnce(
createManagedRun({
reason: "exit",
exitCode: 0,
exitSignal: null,
durationMs: 50,
stdout: "hello from cli",
stderr: "",
timedOut: false,
noOutputTimedOut: false,
}),
);
const result = await runPreparedCliAgent({
...buildPreparedContext(),
bootstrapPromptWarningLines: ["Warning: prompt budget low."],
});
expect(result.meta.finalPromptText).toContain("Warning: prompt budget low.");
expect(result.meta.finalPromptText).toContain("hi");
expect(result.meta.finalAssistantRawText).toBe("hello from cli");
expect(result.meta.executionTrace).toMatchObject({
winnerProvider: "codex-cli",
winnerModel: "gpt-5.4",
fallbackUsed: false,
runner: "cli",
attempts: [{ provider: "codex-cli", model: "gpt-5.4", result: "success" }],
});
expect(result.meta.requestShaping).toMatchObject({
thinking: "low",
});
expect(result.meta.completion).toMatchObject({
finishReason: "stop",
stopReason: "completed",
refusal: false,
});
});
it("keeps raw assistant output separate from transformed visible CLI output", async () => {
supervisorSpawnMock.mockResolvedValueOnce(
createManagedRun({
reason: "exit",
exitCode: 0,
exitSignal: null,
durationMs: 50,
stdout: "hello from cli",
stderr: "",
timedOut: false,
noOutputTimedOut: false,
}),
);
const result = await runPreparedCliAgent({
...buildPreparedContext(),
backendResolved: {
...buildPreparedContext().backendResolved,
textTransforms: {
output: [{ from: "hello", to: "goodbye" }],
},
},
});
expect(result.payloads).toEqual([{ text: "goodbye from cli" }]);
expect(result.meta.finalAssistantVisibleText).toBe("goodbye from cli");
expect(result.meta.finalAssistantRawText).toBe("hello from cli");
});
});
describe("resolveCliNoOutputTimeoutMs", () => {

32
src/agents/cli-runner.ts
View File

@@ -20,13 +20,45 @@ export async function runPreparedCliAgent(
effectiveCliSessionId?: string;
}): EmbeddedPiRunResult => {
const text = resultParams.output.text?.trim();
const rawText = resultParams.output.rawText?.trim();
const payloads = text ? [{ text }] : undefined;
return {
payloads,
meta: {
durationMs: Date.now() - context.started,
...(resultParams.output.finalPromptText
? { finalPromptText: resultParams.output.finalPromptText }
: {}),
...((text || rawText)
? {
...(text ? { finalAssistantVisibleText: text } : {}),
...(rawText ? { finalAssistantRawText: rawText } : {}),
}
: {}),
systemPromptReport: context.systemPromptReport,
executionTrace: {
winnerProvider: params.provider,
winnerModel: context.modelId,
attempts: [
{
provider: params.provider,
model: context.modelId,
result: "success",
},
],
fallbackUsed: false,
runner: "cli",
},
requestShaping: {
...(params.thinkLevel ? { thinking: params.thinkLevel } : {}),
...(params.authProfileId ? { authMode: "auth-profile" } : {}),
},
completion: {
finishReason: "stop",
stopReason: "completed",
refusal: false,
},
agentMeta: {
sessionId: resultParams.effectiveCliSessionId ?? params.sessionId ?? "",
provider: params.provider,

8
src/agents/cli-runner/execute.ts
View File

@@ -462,12 +462,12 @@ export async function executePreparedCliRun(
outputMode: useResume ? (backend.resumeOutput ?? backend.output) : backend.output,
fallbackSessionId: resolvedSessionId,
});
const rawText = parsed.text;
return {
...parsed,
text: applyPluginTextReplacements(
parsed.text,
context.backendResolved.textTransforms?.output,
),
rawText,
finalPromptText: prompt,
text: applyPluginTextReplacements(rawText, context.backendResolved.textTransforms?.output),
};
} finally {
restoreSkillEnv?.();

131
src/agents/pi-embedded-runner/run.ts
View File

@@ -116,6 +116,8 @@ import {
import type {
EmbeddedPiAgentMeta,
EmbeddedPiRunResult,
TraceAttempt,
ToolSummaryTrace,
EmbeddedRunLivenessState,
} from "./types.js";
import { createUsageAccumulator, mergeUsageIntoAccumulator } from "./usage-accumulator.js";
@@ -124,6 +126,30 @@ type ApiKeyInfo = ResolvedProviderAuth;
const MAX_SAME_MODEL_IDLE_TIMEOUT_RETRIES = 1;
function buildTraceToolSummary(params: {
toolMetas: Array<{ toolName: string; meta?: string }>;
hadFailure: boolean;
}): ToolSummaryTrace | undefined {
if (params.toolMetas.length === 0) {
return undefined;
}
const tools: string[] = [];
const seen = new Set<string>();
for (const entry of params.toolMetas) {
const toolName = normalizeOptionalString(entry.toolName);
if (!toolName || seen.has(toolName)) {
continue;
}
seen.add(toolName);
tools.push(toolName);
}
return {
calls: params.toolMetas.length,
tools,
failures: params.hadFailure ? 1 : 0,
};
}
/**
* Best-effort backfill of sessionKey from sessionId when not explicitly provided.
* The return value is normalized: whitespace-only inputs collapse to undefined, and
@@ -337,6 +363,7 @@ export async function runEmbeddedPiAgent(
? profileOrder
: [undefined];
let profileIndex = 0;
const traceAttempts: TraceAttempt[] = [];
const initialThinkLevel = params.thinkLevel ?? "off";
let thinkLevel = initialThinkLevel;
@@ -1149,6 +1176,7 @@ export async function runEmbeddedPiAgent(
lastTurnTotal,
}),
systemPromptReport: attempt.systemPromptReport,
finalPromptText: attempt.finalPromptText,
replayInvalid: resolveReplayInvalidForAttempt(),
livenessState: "blocked",
error: { kind, message: errorText },
@@ -1203,6 +1231,7 @@ export async function runEmbeddedPiAgent(
lastTurnTotal,
}),
systemPromptReport: attempt.systemPromptReport,
finalPromptText: attempt.finalPromptText,
replayInvalid: resolveReplayInvalidForAttempt(),
livenessState: "blocked",
error: { kind: "role_ordering", message: errorText },
@@ -1241,6 +1270,7 @@ export async function runEmbeddedPiAgent(
lastTurnTotal,
}),
systemPromptReport: attempt.systemPromptReport,
finalPromptText: attempt.finalPromptText,
replayInvalid: resolveReplayInvalidForAttempt(),
livenessState: "blocked",
error: { kind: "image_size", message: errorText },
@@ -1294,6 +1324,13 @@ export async function runEmbeddedPiAgent(
promptFailoverDecision.action === "rotate_profile" &&
(await advanceAuthProfile())
) {
traceAttempts.push({
provider,
model: modelId,
result: promptFailoverReason === "timeout" ? "timeout" : "rotate_profile",
...(promptFailoverReason ? { reason: promptFailoverReason } : {}),
stage: "prompt",
});
lastRetryFailoverReason = mergeRetryFailoverReason({
previous: lastRetryFailoverReason,
failoverReason: promptFailoverReason,
@@ -1330,6 +1367,14 @@ export async function runEmbeddedPiAgent(
if (promptFailoverDecision.action === "fallback_model") {
const fallbackReason = promptFailoverDecision.reason ?? "unknown";
const status = resolveFailoverStatus(fallbackReason);
traceAttempts.push({
provider,
model: modelId,
result: promptFailoverReason === "timeout" ? "timeout" : "fallback_model",
reason: fallbackReason,
stage: "prompt",
...(typeof status === "number" ? { status } : {}),
});
logPromptFailoverDecision("fallback_model", { status });
await maybeBackoffBeforeOverloadFailover(promptFailoverReason);
throw (
@@ -1344,6 +1389,13 @@ export async function runEmbeddedPiAgent(
);
}
if (promptFailoverDecision.action === "surface_error") {
traceAttempts.push({
provider,
model: modelId,
result: promptFailoverReason === "timeout" ? "timeout" : "surface_error",
...(promptFailoverReason ? { reason: promptFailoverReason } : {}),
stage: "prompt",
});
logPromptFailoverDecision("surface_error");
}
throw promptError;
@@ -1478,6 +1530,17 @@ export async function runEmbeddedPiAgent(
});
overloadProfileRotations = assistantFailoverOutcome.overloadProfileRotations;
if (assistantFailoverOutcome.action === "retry") {
traceAttempts.push({
provider: activeErrorContext.provider,
model: activeErrorContext.model,
result:
assistantFailoverOutcome.retryKind === "same_model_idle_timeout" ||
assistantFailoverReason === "timeout"
? "timeout"
: "rotate_profile",
...(assistantFailoverReason ? { reason: assistantFailoverReason } : {}),
stage: "assistant",
});
if (assistantFailoverOutcome.retryKind === "same_model_idle_timeout") {
sameModelIdleTimeoutRetries += 1;
}
@@ -1485,6 +1548,21 @@ export async function runEmbeddedPiAgent(
continue;
}
if (assistantFailoverOutcome.action === "throw") {
traceAttempts.push({
provider: activeErrorContext.provider,
model: activeErrorContext.model,
result:
assistantFailoverReason === "timeout"
? "timeout"
: assistantFailoverDecision.action === "fallback_model"
? "fallback_model"
: "error",
...(assistantFailoverReason ? { reason: assistantFailoverReason } : {}),
stage: "assistant",
...(typeof assistantFailoverOutcome.error.status === "number"
? { status: assistantFailoverOutcome.error.status }
: {}),
});
throw assistantFailoverOutcome.error;
}
const usageMeta = buildUsageAgentMetaFields({
@@ -1562,6 +1640,7 @@ export async function runEmbeddedPiAgent(
agentMeta,
aborted,
systemPromptReport: attempt.systemPromptReport,
finalPromptText: attempt.finalPromptText,
finalAssistantVisibleText,
finalAssistantRawText,
replayInvalid,
@@ -1666,6 +1745,7 @@ export async function runEmbeddedPiAgent(
agentMeta,
aborted,
systemPromptReport: attempt.systemPromptReport,
finalPromptText: attempt.finalPromptText,
finalAssistantVisibleText,
finalAssistantRawText,
replayInvalid,
@@ -1719,6 +1799,7 @@ export async function runEmbeddedPiAgent(
agentMeta,
aborted,
systemPromptReport: attempt.systemPromptReport,
finalPromptText: attempt.finalPromptText,
finalAssistantVisibleText,
finalAssistantRawText,
replayInvalid,
@@ -1757,6 +1838,11 @@ export async function runEmbeddedPiAgent(
attempt,
incompleteTurnText: null,
});
const stopReason = attempt.clientToolCall
? "tool_calls"
: attempt.yieldDetected
? "end_turn"
: (sessionLastAssistant?.stopReason as string | undefined);
attempt.setTerminalLifecycleMeta?.({
replayInvalid,
livenessState,
@@ -1768,6 +1854,7 @@ export async function runEmbeddedPiAgent(
agentMeta,
aborted,
systemPromptReport: attempt.systemPromptReport,
finalPromptText: attempt.finalPromptText,
finalAssistantVisibleText,
finalAssistantRawText,
replayInvalid,
@@ -1775,11 +1862,7 @@ export async function runEmbeddedPiAgent(
// Handle client tool calls (OpenResponses hosted tools)
// Propagate the LLM stop reason so callers (lifecycle events,
// ACP bridge) can distinguish end_turn from max_tokens.
stopReason: attempt.clientToolCall
? "tool_calls"
: attempt.yieldDetected
? "end_turn"
: (sessionLastAssistant?.stopReason as string | undefined),
stopReason,
pendingToolCalls: attempt.clientToolCall
? [
{
@@ -1789,6 +1872,44 @@ export async function runEmbeddedPiAgent(
},
]
: undefined,
executionTrace: {
winnerProvider: sessionLastAssistant?.provider ?? provider,
winnerModel: sessionLastAssistant?.model ?? model.id,
attempts:
traceAttempts.length > 0 ||
sessionLastAssistant?.provider ||
sessionLastAssistant?.model
? [
...traceAttempts,
{
provider: sessionLastAssistant?.provider ?? provider,
model: sessionLastAssistant?.model ?? model.id,
result: "success",
stage: "assistant",
},
]
: undefined,
fallbackUsed: traceAttempts.length > 0,
runner: "embedded",
},
requestShaping: {
...(lastProfileId ? { authMode: "auth-profile" } : {}),
...(thinkLevel ? { thinking: thinkLevel } : {}),
...(params.reasoningLevel ? { reasoning: params.reasoningLevel } : {}),
...(params.verboseLevel ? { verbose: params.verboseLevel } : {}),
...(params.blockReplyBreak ? { blockStreaming: params.blockReplyBreak } : {}),
},
toolSummary: buildTraceToolSummary({
toolMetas: attempt.toolMetas,
hadFailure: Boolean(attempt.lastToolError),
}),
completion: {
...(stopReason ? { stopReason } : {}),
...(stopReason ? { finishReason: stopReason } : {}),
...(stopReason?.toLowerCase().includes("refusal") ? { refusal: true } : {}),
},
contextManagement:
autoCompactionCount > 0 ? { lastTurnCompactions: autoCompactionCount } : undefined,
},
didSendViaMessagingTool: attempt.didSendViaMessagingTool,
didSendDeterministicApprovalPrompt: attempt.didSendDeterministicApprovalPrompt,

23
src/agents/pi-embedded-runner/run/attempt.ts
View File

@@ -280,6 +280,16 @@ export {
const MAX_BTW_SNAPSHOT_MESSAGES = 100;
export function resolveUnknownToolGuardThreshold(loopDetection?: {
enabled?: boolean;
unknownToolThreshold?: number;
}): number | undefined {
if (loopDetection?.enabled !== true) {
return undefined;
}
return loopDetection.unknownToolThreshold ?? UNKNOWN_TOOL_THRESHOLD;
}
function summarizeMessagePayload(msg: AgentMessage): { textChars: number; imageBlocks: number } {
const content = (msg as { content?: unknown }).content;
if (typeof content === "string") {
@@ -343,16 +353,6 @@ function summarizeSessionContext(messages: AgentMessage[]): {
};
}
export function resolveUnknownToolGuardThreshold(loopDetection?: {
enabled?: boolean;
unknownToolThreshold?: number;
}): number | undefined {
if (loopDetection?.enabled !== true) {
return undefined;
}
return loopDetection.unknownToolThreshold ?? UNKNOWN_TOOL_THRESHOLD;
}
export async function runEmbeddedAttempt(
params: EmbeddedRunAttemptParams,
): Promise<EmbeddedRunAttemptResult> {
@@ -1548,6 +1548,7 @@ export async function runEmbeddedAttempt(
let attemptUsage: NormalizedUsage | undefined;
let cacheBreak: ReturnType<typeof completePromptCacheObservation> = null;
let promptCache: EmbeddedRunAttemptResult["promptCache"];
let finalPromptText: string | undefined;
if (params.replyOperation) {
params.replyOperation.attachBackend(queueHandle);
}
@@ -1968,6 +1969,7 @@ export async function runEmbeddedAttempt(
}
if (!skipPromptSubmission) {
finalPromptText = effectivePrompt;
const btwSnapshotMessages = activeSession.messages.slice(-MAX_BTW_SNAPSHOT_MESSAGES);
updateActiveEmbeddedRunSnapshot(params.sessionId, {
transcriptLeafId,
@@ -2388,6 +2390,7 @@ export async function runEmbeddedAttempt(
bootstrapPromptWarningSignaturesSeen: bootstrapPromptWarning.warningSignaturesSeen,
bootstrapPromptWarningSignature: bootstrapPromptWarning.signature,
systemPromptReport,
finalPromptText,
messagesSnapshot,
assistantTexts,
toolMetas: toolMetasNormalized,

24
src/agents/pi-embedded-runner/run/helpers.test.ts
View File

@@ -60,34 +60,16 @@ describe("resolveFinalAssistantVisibleText", () => {
expect(resolveFinalAssistantVisibleText(lastAssistant)).toBeUndefined();
});
});
describe("resolveFinalAssistantRawText", () => {
it("preserves commentary and final answer text", () => {
it("preserves raw final answer text without visible-text sanitization", () => {
const lastAssistant = makeAssistantMessage([
{
type: "text",
text: "Working...",
textSignature: JSON.stringify({ v: 1, id: "item_commentary", phase: "commentary" }),
},
{
type: "text",
text: "Section 1\nSection 2",
text: "<final>keep this</final>",
textSignature: JSON.stringify({ v: 1, id: "item_final", phase: "final_answer" }),
},
]);
expect(resolveFinalAssistantRawText(lastAssistant)).toBe("Working...\nSection 1\nSection 2");
});
it("returns undefined when the final raw text is empty", () => {
const lastAssistant = makeAssistantMessage([
{
type: "text",
text: " ",
},
]);
expect(resolveFinalAssistantRawText(lastAssistant)).toBeUndefined();
expect(resolveFinalAssistantRawText(lastAssistant)).toBe("<final>keep this</final>");
});
});

6
src/agents/pi-embedded-runner/run/helpers.ts
View File

@@ -1,7 +1,8 @@
import type { AssistantMessage } from "@mariozechner/pi-ai";
import type { OpenClawConfig } from "../../../config/types.openclaw.js";
import { generateSecureToken } from "../../../infra/secure-random.js";
import { extractAssistantText, extractAssistantVisibleText } from "../../pi-embedded-utils.js";
import { extractAssistantTextForPhase } from "../../../shared/chat-message-content.js";
import { extractAssistantVisibleText } from "../../pi-embedded-utils.js";
import { derivePromptTokens, normalizeUsage } from "../../usage.js";
import type { EmbeddedPiAgentMeta } from "../types.js";
import { toLastCallUsage, toNormalizedUsage, type UsageAccumulator } from "../usage-accumulator.js";
@@ -160,6 +161,7 @@ export function resolveFinalAssistantRawText(
if (!lastAssistant) {
return undefined;
}
const rawText = extractAssistantText(lastAssistant).trim();
const finalAnswerText = extractAssistantTextForPhase(lastAssistant, { phase: "final_answer" });
const rawText = (finalAnswerText ?? extractAssistantTextForPhase(lastAssistant) ?? "").trim();
return rawText || undefined;
}

1
src/agents/pi-embedded-runner/run/types.ts
View File

@@ -73,6 +73,7 @@ export type EmbeddedRunAttemptResult = {
bootstrapPromptWarningSignaturesSeen?: string[];
bootstrapPromptWarningSignature?: string;
systemPromptReport?: SessionSystemPromptReport;
finalPromptText?: string;
messagesSnapshot: AgentMessage[];
assistantTexts: string[];
toolMetas: Array<{ toolName: string; meta?: string }>;

69
src/agents/pi-embedded-runner/types.ts
View File

@@ -31,6 +31,67 @@ export type EmbeddedPiAgentMeta = {
};
};
export type TraceAttempt = {
provider: string;
model: string;
result:
| "success"
| "timeout"
| "surface_error"
| "candidate_failed"
| "rotate_profile"
| "fallback_model"
| "aborted"
| "error";
reason?: string;
stage?: "prompt" | "assistant";
elapsedMs?: number;
status?: number;
};
export type ExecutionTrace = {
winnerProvider?: string;
winnerModel?: string;
attempts?: TraceAttempt[];
fallbackUsed?: boolean;
runner?: "embedded" | "cli";
};
export type RequestShapingTrace = {
authMode?: string;
thinking?: string;
reasoning?: string;
verbose?: string;
trace?: string;
fallbackEligible?: boolean;
blockStreaming?: string;
};
export type PromptSegmentTrace = {
key: string;
chars: number;
};
export type ToolSummaryTrace = {
calls: number;
tools: string[];
failures?: number;
totalToolTimeMs?: number;
};
export type CompletionTrace = {
finishReason?: string;
stopReason?: string;
refusal?: boolean;
};
export type ContextManagementTrace = {
sessionCompactions?: number;
lastTurnCompactions?: number;
preflightCompactionApplied?: boolean;
postCompactionContextInjected?: boolean;
};
export type EmbeddedRunLivenessState = "working" | "paused" | "blocked" | "abandoned";
export type EmbeddedPiRunMeta = {
@@ -38,7 +99,9 @@ export type EmbeddedPiRunMeta = {
agentMeta?: EmbeddedPiAgentMeta;
aborted?: boolean;
systemPromptReport?: SessionSystemPromptReport;
finalPromptText?: string;
finalAssistantVisibleText?: string;
finalAssistantRawText?: string;
replayInvalid?: boolean;
livenessState?: EmbeddedRunLivenessState;
error?: {
@@ -58,6 +121,12 @@ export type EmbeddedPiRunMeta = {
name: string;
arguments: string;
}>;
executionTrace?: ExecutionTrace;
requestShaping?: RequestShapingTrace;
promptSegments?: PromptSegmentTrace[];
toolSummary?: ToolSummaryTrace;
completion?: CompletionTrace;
contextManagement?: ContextManagementTrace;
};
export type EmbeddedPiRunResult = {

2
src/auto-reply/command-status-builders.ts
View File

@@ -63,7 +63,7 @@ export function buildHelpMessage(cfg?: OpenClawConfig): string {
"/model <id>",
"/fast status|on|off",
"/verbose on|off",
"/trace on|off",
"/trace on|off|raw",
];
if (isCommandFlagEnabled(cfg, "config")) {
optionParts.push("/config");

4
src/auto-reply/commands-registry.shared.ts
View File

@@ -680,9 +680,9 @@ export function buildBuiltinChatCommands(): ChatCommandDefinition[] {
args: [
{
name: "mode",
description: "on or off",
description: "on, off, or raw",
type: "string",
choices: ["on", "off"],
choices: ["on", "off", "raw"],
},
],
argsMenu: "auto",

31
src/auto-reply/reply.directive.directive-behavior.shows-current-verbose-level-verbose-has-no.test.ts
View File

@@ -61,6 +61,7 @@ async function runDirectiveStatus(
model: "claude-opus-4-6",
initialModelLabel: "anthropic/claude-opus-4-6",
formatModelSwitchEvent: (label) => `Switched to ${label}`,
senderIsOwner: true,
...restOverrides,
});
return { text: result?.text, sessionEntry: effectiveSessionEntry };
@@ -265,14 +266,40 @@ describe("directive behavior", () => {
expect(currentText).toContain("Current trace level: on");
const enabled = await runDirectiveStatus("/trace on");
expect(enabled.text).toContain("Plugin trace enabled.");
expect(enabled.text).toContain("Trace enabled.");
expect(enabled.text).toContain("may contain sensitive information");
expect(enabled.sessionEntry.traceLevel).toBe("on");
const disabled = await runDirectiveStatus("/trace off", {
sessionEntry: { sessionId: "trace", updatedAt: Date.now(), traceLevel: "on" },
});
expect(disabled.text).toContain("Plugin trace disabled.");
expect(disabled.text).toContain("Trace disabled.");
expect(disabled.text).not.toContain("may contain sensitive information");
expect(disabled.sessionEntry.traceLevel).toBe("off");
const raw = await runDirectiveStatus("/trace raw");
expect(raw.text).toContain("Trace set to raw.");
expect(raw.text).toContain("may contain sensitive information");
expect(raw.sessionEntry.traceLevel).toBe("raw");
expect(runEmbeddedPiAgentMock).not.toHaveBeenCalled();
});
it("blocks /trace for non-owners without delegated gateway scope", async () => {
const denied = await runDirectiveStatus("/trace raw", {
senderIsOwner: false,
gatewayClientScopes: ["operator.write"],
});
expect(denied.text).toContain("/trace is restricted to owners and gateway clients");
expect(denied.sessionEntry.traceLevel).toBeUndefined();
});
it("allows /trace for delegated gateway clients with operator.admin", async () => {
const allowed = await runDirectiveStatus("/trace on", {
senderIsOwner: false,
gatewayClientScopes: ["operator.admin"],
});
expect(allowed.text).toContain("Trace enabled.");
expect(allowed.text).toContain("may contain sensitive information");
expect(allowed.sessionEntry.traceLevel).toBe("on");
});
});

6
src/auto-reply/reply.directive.parse.test.ts
View File

@@ -45,6 +45,12 @@ describe("directive parsing", () => {
expect(res.traceLevel).toBe("on");
});
it("matches raw trace directive", () => {
const res = extractTraceDirective(" please /trace raw now");
expect(res.hasDirective).toBe(true);
expect(res.traceLevel).toBe("raw");
});
it("matches reasoning directive", () => {
const res = extractReasoningDirective("/reasoning on please");
expect(res.hasDirective).toBe(true);

9
src/auto-reply/reply/agent-runner-usage-line.ts
View File

@@ -27,6 +27,8 @@ export const formatResponseUsageLine = (params: {
}
const inputLabel = typeof input === "number" ? formatTokenCount(input) : "?";
const outputLabel = typeof output === "number" ? formatTokenCount(output) : "?";
const cacheRead = typeof usage.cacheRead === "number" ? usage.cacheRead : undefined;
const cacheWrite = typeof usage.cacheWrite === "number" ? usage.cacheWrite : undefined;
const cost =
params.showCost && typeof input === "number" && typeof output === "number"
? estimateUsageCost({
@@ -40,8 +42,13 @@ export const formatResponseUsageLine = (params: {
})
: undefined;
const costLabel = params.showCost ? formatUsd(cost) : undefined;
const cacheSuffix =
(typeof cacheRead === "number" && cacheRead > 0) ||
(typeof cacheWrite === "number" && cacheWrite > 0)
? ` · cache ${formatTokenCount(cacheRead ?? 0)} cached / ${formatTokenCount(cacheWrite ?? 0)} new`
: "";
const suffix = costLabel ? ` · est ${costLabel}` : "";
return `Usage: ${inputLabel} in / ${outputLabel} out${suffix}`;
return `Usage: ${inputLabel} in / ${outputLabel} out${cacheSuffix}${suffix}`;
};
export const appendUsageLine = (payloads: ReplyPayload[], line: string): ReplyPayload[] => {

572
src/auto-reply/reply/agent-runner.misc.runreplyagent.test.ts
View File

@@ -221,6 +221,7 @@ describe("runReplyAgent auto-compaction token update", () => {
provider: "anthropic",
model: "claude",
thinkLevel: "low",
reasoningLevel: "on",
verboseLevel: "off",
elevatedLevel: "off",
bashElevated: { enabled: false, allowed: false, defaultLevel: "off" },
@@ -336,6 +337,7 @@ describe("runReplyAgent block streaming", () => {
provider: "anthropic",
model: "claude",
thinkLevel: "low",
reasoningLevel: "on",
verboseLevel: "off",
elevatedLevel: "off",
bashElevated: {
@@ -438,6 +440,7 @@ describe("runReplyAgent block streaming", () => {
provider: "anthropic",
model: "claude",
thinkLevel: "low",
reasoningLevel: "on",
verboseLevel: "off",
elevatedLevel: "off",
bashElevated: {
@@ -515,7 +518,7 @@ describe("runReplyAgent Active Memory inline debug", () => {
{
pluginId: "active-memory",
lines: [
"🧩 Active Memory: ok 842ms recent 34 chars",
"🧩 Active Memory: status=ok elapsed=842ms query=recent summary=34 chars",
"🔎 Active Memory Debug: Lemon pepper wings with blue cheese.",
],
},
@@ -549,6 +552,7 @@ describe("runReplyAgent Active Memory inline debug", () => {
workspaceDir: "/tmp",
config: {},
skillsSnapshot: {},
traceAuthorized: true,
provider: "anthropic",
model: "claude",
thinkLevel: "low",
@@ -591,7 +595,7 @@ describe("runReplyAgent Active Memory inline debug", () => {
expect(Array.isArray(result)).toBe(true);
expect((result as { text?: string }[]).map((payload) => payload.text)).toEqual([
"Normal reply",
"🧩 Active Memory: ok 842ms recent 34 chars",
"🧩 Active Memory: status=ok elapsed=842ms query=recent summary=34 chars",
]);
});
@@ -626,7 +630,7 @@ describe("runReplyAgent Active Memory inline debug", () => {
{
pluginId: "active-memory",
lines: [
"🧩 Active Memory: ok 842ms recent 34 chars",
"🧩 Active Memory: status=ok elapsed=842ms query=recent summary=34 chars",
"🔎 Active Memory Debug: Lemon pepper wings with blue cheese.",
],
},
@@ -660,6 +664,7 @@ describe("runReplyAgent Active Memory inline debug", () => {
workspaceDir: "/tmp",
config: {},
skillsSnapshot: {},
traceAuthorized: true,
provider: "anthropic",
model: "claude",
thinkLevel: "low",
@@ -702,7 +707,7 @@ describe("runReplyAgent Active Memory inline debug", () => {
expect(Array.isArray(result)).toBe(true);
expect((result as { text?: string }[]).map((payload) => payload.text)).toEqual([
"Normal reply",
"🧩 Active Memory: ok 842ms recent 34 chars\n🔎 Active Memory Debug: Lemon pepper wings with blue cheese.",
"🧩 Active Memory: status=ok elapsed=842ms query=recent summary=34 chars\n🔎 Active Memory Debug: Lemon pepper wings with blue cheese.",
]);
});
@@ -736,7 +741,7 @@ describe("runReplyAgent Active Memory inline debug", () => {
{
pluginId: "active-memory",
lines: [
"🧩 Active Memory: ok 842ms recent 34 chars",
"🧩 Active Memory: status=ok elapsed=842ms query=recent summary=34 chars",
"🔎 Active Memory Debug: Lemon pepper wings with blue cheese.",
],
},
@@ -770,6 +775,7 @@ describe("runReplyAgent Active Memory inline debug", () => {
workspaceDir: "/tmp",
config: {},
skillsSnapshot: {},
traceAuthorized: true,
provider: "anthropic",
model: "claude",
thinkLevel: "low",
@@ -816,6 +822,556 @@ describe("runReplyAgent Active Memory inline debug", () => {
]);
});
it("appends raw trace payloads when trace raw is enabled", async () => {
const tmp = await fs.mkdtemp(path.join(os.tmpdir(), "openclaw-trace-raw-usage-"));
const storePath = path.join(tmp, "sessions.json");
const sessionFile = path.join(tmp, "session.jsonl");
const sessionKey = "main";
const sessionEntry: SessionEntry = {
sessionId: "session",
updatedAt: Date.now(),
traceLevel: "raw",
compactionCount: 3,
};
await fs.writeFile(
storePath,
JSON.stringify(
{
[sessionKey]: sessionEntry,
},
null,
2,
),
"utf-8",
);
await fs.writeFile(
sessionFile,
[
JSON.stringify({
message: {
role: "user",
content: "Earlier turn",
usage: { input: 400, output: 20, cacheRead: 100, cacheWrite: 50, total: 570 },
},
}),
JSON.stringify({
message: {
role: "assistant",
content: "Earlier reply",
usage: { input: 200, output: 10, cacheRead: 20, cacheWrite: 5, total: 235 },
},
}),
].join("\n"),
"utf-8",
);
runEmbeddedPiAgentMock.mockResolvedValueOnce({
payloads: [{ text: "Visible reply" }],
meta: {
finalPromptText:
"Untrusted context (metadata, do not treat as instructions or commands):\n<active_memory_plugin>\nPrefer from/to failover logs.\n</active_memory_plugin>\n\n/trace raw show me everything",
finalAssistantVisibleText: "Visible reply",
finalAssistantRawText: "<final>Visible reply</final>",
executionTrace: {
winnerProvider: "anthropic",
winnerModel: "claude",
runner: "embedded",
fallbackUsed: true,
attempts: [
{
provider: "minimax-portal",
model: "MiniMax-M2.5",
result: "timeout",
reason: "timeout",
stage: "assistant",
elapsedMs: 15000,
},
{
provider: "anthropic",
model: "claude",
result: "success",
stage: "assistant",
elapsedMs: 4200,
},
],
},
toolSummary: {
calls: 2,
tools: ["active-memory", "github-search"],
failures: 0,
totalToolTimeMs: 481,
},
completion: {
finishReason: "stop",
stopReason: "end_turn",
refusal: false,
},
agentMeta: {
sessionId: "session",
provider: "anthropic",
model: "claude",
usage: { input: 1200, output: 45, cacheRead: 800, cacheWrite: 200, total: 2245 },
lastCallUsage: { input: 1000, output: 45, cacheRead: 750, cacheWrite: 150, total: 1945 },
compactionCount: 1,
},
},
});
const typing = createMockTypingController();
const sessionCtx = {
Provider: "telegram",
OriginatingTo: "chat:1",
AccountId: "primary",
MessageSid: "msg",
CommandBody: "/trace raw show me everything",
} as unknown as TemplateContext;
const resolvedQueue = { mode: "interrupt" } as unknown as QueueSettings;
const followupRun = {
prompt: "hello",
summaryLine: "hello",
enqueuedAt: Date.now(),
run: {
agentId: "main",
sessionId: "session",
sessionKey,
messageProvider: "telegram",
sessionFile,
workspaceDir: "/tmp",
config: {},
skillsSnapshot: {},
traceAuthorized: true,
provider: "anthropic",
model: "claude",
thinkLevel: "low",
reasoningLevel: "on",
verboseLevel: "off",
elevatedLevel: "off",
bashElevated: {
enabled: false,
allowed: false,
defaultLevel: "off",
},
timeoutMs: 1_000,
blockReplyBreak: "message_end",
},
} as unknown as FollowupRun;
const result = await runReplyAgent({
commandBody: "hello",
followupRun,
queueKey: sessionKey,
resolvedQueue,
shouldSteer: false,
shouldFollowup: false,
isActive: false,
isStreaming: false,
typing,
sessionCtx,
sessionEntry,
sessionStore: { [sessionKey]: sessionEntry },
sessionKey,
storePath,
defaultModel: "anthropic/claude-opus-4-6",
resolvedVerboseLevel: "off",
isNewSession: false,
blockStreamingEnabled: false,
resolvedBlockStreamingBreak: "message_end",
shouldInjectGroupIntro: false,
typingMode: "instant",
});
expect(Array.isArray(result)).toBe(true);
expect((result as { text?: string }[])[0]?.text).toBe("Visible reply");
const traceText = (result as { text?: string }[])[1]?.text ?? "";
expect(traceText).toContain("🔎 Usage (Session Total):");
expect(traceText).toContain("🔎 Usage (Last Turn Total):");
expect(traceText).toContain("🔎 Context Window (Last Model Request):");
expect(traceText).toContain("🔎 Execution Result:");
expect(traceText).toContain("winner=anthropic/claude");
expect(traceText).toContain("fallbackUsed=yes");
expect(traceText).toContain("attempts=2");
expect(traceText).toContain("runner=embedded");
expect(traceText).toContain("🔎 Fallback Chain:");
expect(traceText).toContain("1. minimax-portal/MiniMax-M2.5");
expect(traceText).toContain("result=timeout");
expect(traceText).toContain("elapsed=15.0s");
expect(traceText).toContain("2. anthropic/claude");
expect(traceText).toContain("result=success");
expect(traceText).toContain("🔎 Request Shaping:");
expect(traceText).toContain("provider=anthropic");
expect(traceText).toContain("model=claude");
expect(traceText).toContain("thinking=low");
expect(traceText).toContain("reasoning=on");
expect(traceText).toContain("verbose=off");
expect(traceText).toContain("trace=raw");
expect(traceText).toContain("blockStreaming=message_end");
expect(traceText).toContain("🔎 Prompt Segments:");
expect(traceText).toContain("active_memory_plugin=");
expect(traceText).toContain("user_message=");
expect(traceText).toContain("totalPromptText=");
expect(traceText).toContain("🔎 Tool Summary:");
expect(traceText).toContain("calls=2");
expect(traceText).toContain("tools=active-memory, github-search");
expect(traceText).toContain("failures=0");
expect(traceText).toContain("totalToolTimeMs=481");
expect(traceText).toContain("🔎 Completion:");
expect(traceText).toContain("finishReason=stop");
expect(traceText).toContain("stopReason=end_turn");
expect(traceText).toContain("refusal=no");
expect(traceText).toContain("🔎 Context Management:");
expect(traceText).toContain("sessionCompactions=4");
expect(traceText).toContain("lastTurnCompactions=1");
expect(traceText).toContain("🔎 Model Input (User Role):");
expect(traceText).toContain("🔎 Model Output (Assistant Role):");
expect(traceText).toContain(
"Summary: winner=claude 🧠 low fallback=yes attempts=2 stop=end_turn prompt=1.9k/200k ⬇️ 1.2k ⬆️ 45 ♻️ 800 🆕 200 🔢 2.2k tools=2 compactions=1",
);
expect(traceText.indexOf("🔎 Execution Result:")).toBeGreaterThan(
traceText.indexOf("🔎 Context Window (Last Model Request):"),
);
expect(traceText.indexOf("🔎 Fallback Chain:")).toBeGreaterThan(
traceText.indexOf("🔎 Execution Result:"),
);
expect(traceText.indexOf("🔎 Request Shaping:")).toBeGreaterThan(
traceText.indexOf("🔎 Fallback Chain:"),
);
expect(traceText.indexOf("🔎 Prompt Segments:")).toBeGreaterThan(
traceText.indexOf("🔎 Request Shaping:"),
);
expect(traceText.indexOf("🔎 Tool Summary:")).toBeGreaterThan(
traceText.indexOf("🔎 Prompt Segments:"),
);
expect(traceText.indexOf("🔎 Completion:")).toBeGreaterThan(
traceText.indexOf("🔎 Tool Summary:"),
);
expect(traceText.indexOf("🔎 Context Management:")).toBeGreaterThan(
traceText.indexOf("🔎 Completion:"),
);
expect(traceText.indexOf("🔎 Model Input (User Role):")).toBeGreaterThan(
traceText.indexOf("🔎 Context Management:"),
);
expect(traceText.indexOf("🔎 Model Output (Assistant Role):")).toBeGreaterThan(
traceText.indexOf("🔎 Model Input (User Role):"),
);
expect(traceText.indexOf("Summary: winner=claude 🧠 low")).toBeGreaterThan(
traceText.indexOf("🔎 Model Output (Assistant Role):"),
);
});
it("does not emit persisted trace output to an unauthorized sender", async () => {
const tmp = await fs.mkdtemp(path.join(os.tmpdir(), "openclaw-trace-raw-unauthorized-"));
const storePath = path.join(tmp, "sessions.json");
const sessionFile = path.join(tmp, "session.jsonl");
const sessionKey = "main";
const sessionEntry: SessionEntry = {
sessionId: "session",
updatedAt: Date.now(),
traceLevel: "raw",
};
await fs.writeFile(storePath, JSON.stringify({ [sessionKey]: sessionEntry }, null, 2), "utf-8");
await fs.writeFile(sessionFile, "", "utf-8");
runEmbeddedPiAgentMock.mockResolvedValueOnce({
payloads: [{ text: "Visible reply" }],
meta: {
finalPromptText: "secret prompt context",
finalAssistantVisibleText: "Visible reply",
finalAssistantRawText: "secret raw output",
agentMeta: {
sessionId: "session",
provider: "anthropic",
model: "claude",
usage: { input: 12, output: 3, total: 15 },
},
},
});
const typing = createMockTypingController();
const sessionCtx = {
Provider: "telegram",
OriginatingTo: "chat:1",
AccountId: "primary",
MessageSid: "msg",
CommandBody: "show me the answer",
} as unknown as TemplateContext;
const resolvedQueue = { mode: "interrupt" } as unknown as QueueSettings;
const followupRun = {
prompt: "hello",
summaryLine: "hello",
enqueuedAt: Date.now(),
run: {
agentId: "main",
sessionId: "session",
sessionKey,
messageProvider: "telegram",
sessionFile,
workspaceDir: "/tmp",
config: {},
skillsSnapshot: {},
senderIsOwner: false,
traceAuthorized: false,
provider: "anthropic",
model: "claude",
thinkLevel: "low",
verboseLevel: "off",
elevatedLevel: "off",
bashElevated: {
enabled: false,
allowed: false,
defaultLevel: "off",
},
timeoutMs: 1_000,
blockReplyBreak: "message_end",
},
} as unknown as FollowupRun;
const result = await runReplyAgent({
commandBody: "hello",
followupRun,
queueKey: sessionKey,
resolvedQueue,
shouldSteer: false,
shouldFollowup: false,
isActive: false,
isStreaming: false,
typing,
sessionCtx,
sessionEntry,
sessionStore: { [sessionKey]: sessionEntry },
sessionKey,
storePath,
defaultModel: "anthropic/claude-opus-4-6",
resolvedVerboseLevel: "off",
isNewSession: false,
blockStreamingEnabled: false,
resolvedBlockStreamingBreak: "message_end",
shouldInjectGroupIntro: false,
typingMode: "instant",
});
expect(result).toMatchObject({ text: "Visible reply" });
expect(Array.isArray(result)).toBe(false);
});
it("shows session and last-turn usage totals without per-call usage blocks", async () => {
const tmp = await fs.mkdtemp(path.join(os.tmpdir(), "openclaw-trace-raw-usage-"));
const storePath = path.join(tmp, "sessions.json");
const sessionFile = path.join(tmp, "session.jsonl");
const sessionKey = "main";
const sessionEntry: SessionEntry = {
sessionId: "session",
updatedAt: Date.now(),
traceLevel: "raw",
};
await fs.writeFile(
storePath,
JSON.stringify(
{
[sessionKey]: sessionEntry,
},
null,
2,
),
"utf-8",
);
await fs.writeFile(
sessionFile,
`${JSON.stringify({
message: {
role: "assistant",
content: "Earlier reply",
usage: { input: 20, output: 5, cacheRead: 3, total: 28 },
},
})}\n`,
"utf-8",
);
runEmbeddedPiAgentMock.mockResolvedValueOnce({
payloads: [{ text: "Visible reply" }],
meta: {
finalPromptText: "/trace raw",
finalAssistantVisibleText: "Visible reply",
finalAssistantRawText: "Visible reply",
agentMeta: {
sessionId: "session",
provider: "anthropic",
model: "claude",
usage: { input: 34834, output: 49, cacheRead: 64, total: 34947 },
lastCallUsage: { input: 34834, output: 49, cacheRead: 64, cacheWrite: 0, total: 34947 },
},
},
});
const typing = createMockTypingController();
const sessionCtx = {
Provider: "telegram",
OriginatingTo: "chat:1",
AccountId: "primary",
MessageSid: "msg",
CommandBody: "/trace raw",
} as unknown as TemplateContext;
const resolvedQueue = { mode: "interrupt" } as unknown as QueueSettings;
const followupRun = {
prompt: "hello",
summaryLine: "hello",
enqueuedAt: Date.now(),
run: {
agentId: "main",
sessionId: "session",
sessionKey,
messageProvider: "telegram",
sessionFile,
workspaceDir: "/tmp",
config: {},
skillsSnapshot: {},
traceAuthorized: true,
provider: "anthropic",
model: "claude",
thinkLevel: "low",
verboseLevel: "off",
elevatedLevel: "off",
bashElevated: {
enabled: false,
allowed: false,
defaultLevel: "off",
},
timeoutMs: 1_000,
blockReplyBreak: "message_end",
},
} as unknown as FollowupRun;
const result = await runReplyAgent({
commandBody: "hello",
followupRun,
queueKey: sessionKey,
resolvedQueue,
shouldSteer: false,
shouldFollowup: false,
isActive: false,
isStreaming: false,
typing,
sessionCtx,
sessionEntry,
sessionStore: { [sessionKey]: sessionEntry },
sessionKey,
storePath,
defaultModel: "anthropic/claude-opus-4-6",
agentCfgContextTokens: 200_000,
resolvedVerboseLevel: "off",
isNewSession: false,
blockStreamingEnabled: false,
resolvedBlockStreamingBreak: "message_end",
shouldInjectGroupIntro: false,
typingMode: "instant",
});
const traceText = (Array.isArray(result) ? result[1] : result)?.text ?? "";
expect(traceText).toContain("🔎 Usage (Session Total):");
expect(traceText).toContain("🔎 Usage (Last Turn Total):");
expect(traceText).not.toContain("🔎 Provider Usage (Turn Total):");
expect(traceText).not.toContain("🔎 Provider Usage (Last Provider Call):");
});
it("escapes markdown fence delimiters inside raw trace blocks", async () => {
const tmp = await fs.mkdtemp(path.join(os.tmpdir(), "openclaw-trace-raw-fence-"));
const storePath = path.join(tmp, "sessions.json");
const sessionFile = path.join(tmp, "session.jsonl");
const sessionKey = "main";
const sessionEntry: SessionEntry = {
sessionId: "session",
updatedAt: Date.now(),
traceLevel: "raw",
};
await fs.writeFile(storePath, JSON.stringify({ [sessionKey]: sessionEntry }, null, 2), "utf-8");
await fs.writeFile(sessionFile, "", "utf-8");
runEmbeddedPiAgentMock.mockResolvedValueOnce({
payloads: [{ text: "Visible reply" }],
meta: {
finalPromptText: "show me\n~~~\nnot a fence",
finalAssistantVisibleText: "Visible reply",
finalAssistantRawText: "assistant\n~~~\nresponse",
agentMeta: {
sessionId: "session",
provider: "anthropic",
model: "claude",
usage: { input: 10, output: 2, total: 12 },
},
},
});
const typing = createMockTypingController();
const sessionCtx = {
Provider: "telegram",
OriginatingTo: "chat:1",
AccountId: "primary",
MessageSid: "msg",
CommandBody: "/trace raw",
} as unknown as TemplateContext;
const resolvedQueue = { mode: "interrupt" } as unknown as QueueSettings;
const followupRun = {
prompt: "hello",
summaryLine: "hello",
enqueuedAt: Date.now(),
run: {
agentId: "main",
sessionId: "session",
sessionKey,
messageProvider: "telegram",
sessionFile,
workspaceDir: "/tmp",
config: {},
skillsSnapshot: {},
traceAuthorized: true,
provider: "anthropic",
model: "claude",
thinkLevel: "off",
reasoningLevel: "off",
verboseLevel: "off",
elevatedLevel: "off",
bashElevated: {
enabled: false,
allowed: false,
defaultLevel: "off",
},
timeoutMs: 1_000,
blockReplyBreak: "message_end",
},
} as unknown as FollowupRun;
const result = await runReplyAgent({
commandBody: "hello",
followupRun,
queueKey: sessionKey,
resolvedQueue,
shouldSteer: false,
shouldFollowup: false,
isActive: false,
isStreaming: false,
typing,
sessionCtx,
sessionEntry,
sessionStore: { [sessionKey]: sessionEntry },
sessionKey,
storePath,
defaultModel: "anthropic/claude-opus-4-6",
resolvedVerboseLevel: "off",
isNewSession: false,
blockStreamingEnabled: false,
resolvedBlockStreamingBreak: "message_end",
shouldInjectGroupIntro: false,
typingMode: "instant",
});
const traceText = (result as { text?: string }[])[1]?.text ?? "";
expect(traceText).toContain("show me\n\\~~~\nnot a fence");
expect(traceText).toContain("assistant\n\\~~~\nresponse");
});
it("does not reload the session store when verbose is disabled", async () => {
const tmp = await fs.mkdtemp(path.join(os.tmpdir(), "openclaw-active-memory-inline-"));
const storePath = path.join(tmp, "sessions.json");
@@ -1527,7 +2083,7 @@ describe("runReplyAgent response usage footer", () => {
agentMeta: {
provider: "anthropic",
model: "claude",
usage: { input: 12, output: 3 },
usage: { input: 12, output: 3, cacheRead: 4, cacheWrite: 2 },
},
},
});
@@ -1537,6 +2093,7 @@ describe("runReplyAgent response usage footer", () => {
const payload = Array.isArray(res) ? res[0] : res;
const text = payload?.text ?? "";
expect(text).toContain("Usage:");
expect(text).toContain("cache 4 cached / 2 new");
expect(text).toContain(`· session \`${sessionKey}\``);
});
@@ -1547,7 +2104,7 @@ describe("runReplyAgent response usage footer", () => {
agentMeta: {
provider: "anthropic",
model: "claude",
usage: { input: 12, output: 3 },
usage: { input: 12, output: 3, cacheRead: 4, cacheWrite: 2 },
},
},
});
@@ -1557,6 +2114,7 @@ describe("runReplyAgent response usage footer", () => {
const payload = Array.isArray(res) ? res[0] : res;
const text = payload?.text ?? "";
expect(text).toContain("Usage:");
expect(text).toContain("cache 4 cached / 2 new");
expect(text).not.toContain("· session ");
});
});

892
src/auto-reply/reply/agent-runner.ts
View File

@@ -1,9 +1,11 @@
import fs from "node:fs/promises";
import { hasConfiguredModelFallbacks } from "../../agents/agent-scope.js";
import { resolveContextTokensForModel } from "../../agents/context.js";
import { DEFAULT_CONTEXT_TOKENS } from "../../agents/defaults.js";
import { resolveModelAuthMode } from "../../agents/model-auth.js";
import { isCliProvider } from "../../agents/model-selection.js";
import { queueEmbeddedPiMessage } from "../../agents/pi-embedded-runner/runs.js";
import { hasNonzeroUsage } from "../../agents/usage.js";
import { hasNonzeroUsage, normalizeUsage } from "../../agents/usage.js";
import {
loadSessionStore,
resolveSessionPluginStatusLines,
@@ -12,12 +14,17 @@ import {
updateSessionStoreEntry,
} from "../../config/sessions.js";
import type { TypingMode } from "../../config/types.js";
import { resolveSessionTranscriptCandidates } from "../../gateway/session-utils.fs.js";
import { emitAgentEvent } from "../../infra/agent-events.js";
import { emitDiagnosticEvent, isDiagnosticsEnabled } from "../../infra/diagnostic-events.js";
import { enqueueSystemEvent } from "../../infra/system-events.js";
import { CommandLaneClearedError, GatewayDrainingError } from "../../process/command-queue.js";
import { normalizeOptionalString } from "../../shared/string-coerce.js";
import { estimateUsageCost, resolveModelCostConfig } from "../../utils/usage-format.js";
import {
estimateUsageCost,
formatTokenCount,
resolveModelCostConfig,
} from "../../utils/usage-format.js";
import {
buildFallbackClearedNotice,
buildFallbackNotice,
@@ -71,12 +78,19 @@ import type { TypingController } from "./typing.js";
const BLOCK_REPLY_SEND_TIMEOUT_MS = 15_000;
function buildInlinePluginStatusPayload(entry: SessionEntry | undefined): ReplyPayload | undefined {
function buildInlinePluginStatusPayload(params: {
entry: SessionEntry | undefined;
includeTraceLines: boolean;
}): ReplyPayload | undefined {
const statusLines =
entry?.verboseLevel && entry.verboseLevel !== "off"
? resolveSessionPluginStatusLines(entry)
params.entry?.verboseLevel && params.entry.verboseLevel !== "off"
? resolveSessionPluginStatusLines(params.entry)
: [];
const traceLines =
params.includeTraceLines &&
(params.entry?.traceLevel === "on" || params.entry?.traceLevel === "raw")
? resolveSessionPluginTraceLines(params.entry)
: [];
const traceLines = entry?.traceLevel === "on" ? resolveSessionPluginTraceLines(entry) : [];
const lines = [...statusLines, ...traceLines];
if (lines.length === 0) {
return undefined;
@@ -84,6 +98,737 @@ function buildInlinePluginStatusPayload(entry: SessionEntry | undefined): ReplyP
return { text: lines.join("\n") };
}
function formatRawTraceBlock(title: string, value: string | undefined): string {
const body = value?.trim() ? escapeTraceFence(value) : "<empty>";
return `🔎 ${title}:\n~~~text\n${body}\n~~~`;
}
function escapeTraceFence(value: string): string {
return value.replace(/^~~~/gm, "\\~~~");
}
function hasTraceUsageFields(
usage:
| {
input?: number;
output?: number;
cacheRead?: number;
cacheWrite?: number;
total?: number;
}
| undefined,
): boolean {
if (!usage) {
return false;
}
return ["input", "output", "cacheRead", "cacheWrite", "total"].some((key) => {
const value = usage[key as keyof typeof usage];
return typeof value === "number" && Number.isFinite(value);
});
}
function formatTraceUsageLine(label: string, value: number | undefined): string {
return `${label}=${typeof value === "number" && Number.isFinite(value) ? `${value.toLocaleString()} tok (${formatTokenCount(value)})` : "n/a"}`;
}
function formatUsageTraceBlock(
title: string,
usage:
| {
input?: number;
output?: number;
cacheRead?: number;
cacheWrite?: number;
total?: number;
}
| undefined,
): string | undefined {
if (!hasTraceUsageFields(usage)) {
return undefined;
}
return `🔎 ${title}:\n~~~text\n${[
formatTraceUsageLine("input", usage?.input),
formatTraceUsageLine("output", usage?.output),
formatTraceUsageLine("cacheRead", usage?.cacheRead),
formatTraceUsageLine("cacheWrite", usage?.cacheWrite),
formatTraceUsageLine("total", usage?.total),
].join("\n")}\n~~~`;
}
type TraceAttemptView = {
provider: string;
model: string;
result: string;
reason?: string;
stage?: string;
elapsedMs?: number;
status?: number;
};
type TraceExecutionView = {
winnerProvider?: string;
winnerModel?: string;
attempts?: TraceAttemptView[];
fallbackUsed?: boolean;
runner?: "embedded" | "cli";
};
type TracePromptSegmentView = {
key: string;
chars: number;
};
type TraceToolSummaryView = {
calls: number;
tools: string[];
failures?: number;
totalToolTimeMs?: number;
};
type TraceCompletionView = {
finishReason?: string;
stopReason?: string;
refusal?: boolean;
};
type TraceContextManagementView = {
sessionCompactions?: number;
lastTurnCompactions?: number;
preflightCompactionApplied?: boolean;
postCompactionContextInjected?: boolean;
};
function formatTraceScalar(value: string | number | boolean | undefined): string | undefined {
if (typeof value === "boolean") {
return value ? "yes" : "no";
}
if (typeof value === "number") {
return Number.isFinite(value) ? value.toLocaleString() : undefined;
}
const trimmed = normalizeOptionalString(value);
return trimmed ?? undefined;
}
function formatKeyValueTraceBlock(
title: string,
fields: Array<[string, string | number | boolean | undefined]>,
): string | undefined {
const lines = fields.flatMap(([key, rawValue]) => {
const value = formatTraceScalar(rawValue);
return value ? [`${key}=${value}`] : [];
});
if (lines.length === 0) {
return undefined;
}
return `🔎 ${title}:\n~~~text\n${lines.join("\n")}\n~~~`;
}
function inferFallbackAttemptResult(attempt: { reason?: string; status?: number }): string {
if (attempt.reason === "timeout") {
return "timeout";
}
return "candidate_failed";
}
function mergeExecutionTrace(params: {
fallbackAttempts?: Array<{
provider: string;
model: string;
reason?: string;
status?: number;
}>;
executionTrace?: {
winnerProvider?: string;
winnerModel?: string;
attempts?: TraceAttemptView[];
fallbackUsed?: boolean;
runner?: "embedded" | "cli";
};
provider?: string;
model?: string;
runner: "embedded" | "cli";
}): TraceExecutionView | undefined {
const attempts: TraceAttemptView[] = [
...(params.fallbackAttempts ?? []).map((attempt) => ({
provider: attempt.provider,
model: attempt.model,
result: inferFallbackAttemptResult(attempt),
...(attempt.reason ? { reason: attempt.reason } : {}),
...(typeof attempt.status === "number" ? { status: attempt.status } : {}),
})),
...(params.executionTrace?.attempts ?? []),
];
const winnerProvider =
params.executionTrace?.winnerProvider ?? normalizeOptionalString(params.provider);
const winnerModel = params.executionTrace?.winnerModel ?? normalizeOptionalString(params.model);
if (
winnerProvider &&
winnerModel &&
!attempts.some(
(attempt) =>
attempt.provider === winnerProvider &&
attempt.model === winnerModel &&
attempt.result === "success",
)
) {
attempts.push({
provider: winnerProvider,
model: winnerModel,
result: "success",
});
}
if (!winnerProvider && !winnerModel && attempts.length === 0) {
return undefined;
}
return {
winnerProvider,
winnerModel,
attempts: attempts.length > 0 ? attempts : undefined,
fallbackUsed: params.executionTrace?.fallbackUsed ?? attempts.length > 1,
runner: params.executionTrace?.runner ?? params.runner,
};
}
function formatExecutionResultTraceBlock(
executionTrace: TraceExecutionView | undefined,
): string | undefined {
if (!executionTrace?.winnerProvider && !executionTrace?.winnerModel) {
return undefined;
}
return formatKeyValueTraceBlock("Execution Result", [
[
"winner",
executionTrace.winnerProvider && executionTrace.winnerModel
? `${executionTrace.winnerProvider}/${executionTrace.winnerModel}`
: undefined,
],
["fallbackUsed", executionTrace.fallbackUsed],
["attempts", executionTrace.attempts?.length],
["runner", executionTrace.runner],
]);
}
function formatFallbackChainTraceBlock(
executionTrace: TraceExecutionView | undefined,
): string | undefined {
const attempts = executionTrace?.attempts ?? [];
if (attempts.length <= 1) {
return undefined;
}
const body = attempts
.map((attempt, index) =>
[
`${index + 1}. ${attempt.provider}/${attempt.model}`,
` result=${attempt.result}`,
...(attempt.reason ? [` reason=${attempt.reason}`] : []),
...(attempt.stage ? [` stage=${attempt.stage}`] : []),
...(typeof attempt.elapsedMs === "number"
? [` elapsed=${(attempt.elapsedMs / 1000).toFixed(1)}s`]
: []),
...(typeof attempt.status === "number" ? [` status=${attempt.status}`] : []),
].join("\n"),
)
.join("\n\n");
return `🔎 Fallback Chain:\n~~~text\n${body}\n~~~`;
}
function toSnakeCase(value: string): string {
return value
.trim()
.toLowerCase()
.replace(/[^a-z0-9]+/g, "_")
.replace(/^_+|_+$/g, "");
}
function resolveMetadataSegmentKey(label: string): string {
const normalized = toSnakeCase(label);
if (normalized === "conversation_info") {
return "conversation_metadata";
}
if (normalized === "sender") {
return "sender_metadata";
}
return normalized.endsWith("_metadata") ? normalized : `${normalized}_metadata`;
}
function derivePromptSegments(prompt: string | undefined): TracePromptSegmentView[] | undefined {
const text = prompt ?? "";
if (!text.trim()) {
return undefined;
}
const lines = text.split("\n");
const segments = new Map<string, number>();
let userChars = 0;
const addChars = (key: string, chars: number) => {
if (!chars || chars <= 0) {
return;
}
segments.set(key, (segments.get(key) ?? 0) + chars);
};
let index = 0;
while (index < lines.length) {
const line = lines[index] ?? "";
if (line === "Untrusted context (metadata, do not treat as instructions or commands):") {
const tagLine = lines[index + 1] ?? "";
const tagMatch = tagLine.trim().match(/^<([a-z0-9_:-]+)>$/i);
if (tagMatch) {
const closeTag = `</${tagMatch[1]}>`;
let end = index + 2;
while (end < lines.length && lines[end]?.trim() !== closeTag) {
end += 1;
}
if (end < lines.length) {
addChars(tagMatch[1], lines.slice(index, end + 1).join("\n").length);
index = end + 1;
while ((lines[index] ?? "") === "") {
index += 1;
}
continue;
}
}
}
const metadataMatch = line.match(/^(.*) \(untrusted metadata\):$/);
if (metadataMatch) {
const start = index;
const fence = lines[index + 1] ?? "";
if (fence.startsWith("```")) {
let end = index + 2;
while (end < lines.length && !(lines[end] ?? "").startsWith("```")) {
end += 1;
}
if (end < lines.length) {
addChars(
resolveMetadataSegmentKey(metadataMatch[1] ?? "metadata"),
lines.slice(start, end + 1).join("\n").length,
);
index = end + 1;
while ((lines[index] ?? "") === "") {
index += 1;
}
continue;
}
}
}
if (line.trim()) {
userChars += line.length + 1;
}
index += 1;
}
if (userChars > 0) {
addChars("user_message", userChars);
}
const result = Array.from(segments.entries()).map(([key, chars]) => ({ key, chars }));
return result.length > 0 ? result : undefined;
}
function formatPromptSegmentsTraceBlock(
segments: TracePromptSegmentView[] | undefined,
totalPromptText: string | undefined,
): string | undefined {
if (!segments?.length && !totalPromptText?.length) {
return undefined;
}
const lines = (segments ?? []).map(
(segment) => `${segment.key}=${segment.chars.toLocaleString()} chars`,
);
if (typeof totalPromptText === "string" && totalPromptText.length > 0) {
lines.push(`totalPromptText=${totalPromptText.length.toLocaleString()} chars`);
}
return lines.length > 0 ? `🔎 Prompt Segments:\n~~~text\n${lines.join("\n")}\n~~~` : undefined;
}
function formatToolSummaryTraceBlock(
toolSummary: TraceToolSummaryView | undefined,
): string | undefined {
if (!toolSummary || toolSummary.calls <= 0) {
return undefined;
}
return formatKeyValueTraceBlock("Tool Summary", [
["calls", toolSummary.calls],
["tools", toolSummary.tools.length > 0 ? toolSummary.tools.join(", ") : undefined],
["failures", toolSummary.failures],
["totalToolTimeMs", toolSummary.totalToolTimeMs],
]);
}
function formatCompletionTraceBlock(
completion: TraceCompletionView | undefined,
): string | undefined {
if (!completion) {
return undefined;
}
return formatKeyValueTraceBlock("Completion", [
["finishReason", completion.finishReason],
["stopReason", completion.stopReason],
["refusal", completion.refusal],
]);
}
function formatContextManagementTraceBlock(
contextManagement: TraceContextManagementView | undefined,
): string | undefined {
if (!contextManagement) {
return undefined;
}
return formatKeyValueTraceBlock("Context Management", [
["sessionCompactions", contextManagement.sessionCompactions],
["lastTurnCompactions", contextManagement.lastTurnCompactions],
["preflightCompactionApplied", contextManagement.preflightCompactionApplied],
["postCompactionContextInjected", contextManagement.postCompactionContextInjected],
]);
}
async function accumulateSessionUsageFromTranscript(params: {
sessionId?: string;
storePath?: string;
sessionFile?: string;
}): Promise<
| {
input?: number;
output?: number;
cacheRead?: number;
cacheWrite?: number;
total?: number;
}
| undefined
> {
const sessionId = normalizeOptionalString(params.sessionId);
if (!sessionId) {
return undefined;
}
try {
const candidates = resolveSessionTranscriptCandidates(
sessionId,
params.storePath,
params.sessionFile,
);
let transcriptText: string | undefined;
for (const candidate of candidates) {
try {
transcriptText = await fs.readFile(candidate, "utf-8");
break;
} catch {
continue;
}
}
if (!transcriptText) {
return undefined;
}
let input = 0;
let output = 0;
let cacheRead = 0;
let cacheWrite = 0;
let sawUsage = false;
for (const line of transcriptText.split(/\r?\n/)) {
if (!line.trim()) {
continue;
}
let parsed: { message?: { usage?: unknown } } | undefined;
try {
parsed = JSON.parse(line) as { message?: { usage?: unknown } };
} catch {
continue;
}
const message = parsed?.message;
if (!message) {
continue;
}
const usage = normalizeUsage(message?.usage as Parameters<typeof normalizeUsage>[0]);
if (!hasNonzeroUsage(usage)) {
continue;
}
sawUsage = true;
input += usage.input ?? 0;
output += usage.output ?? 0;
cacheRead += usage.cacheRead ?? 0;
cacheWrite += usage.cacheWrite ?? 0;
}
if (!sawUsage) {
return undefined;
}
const total = input + output + cacheRead + cacheWrite;
return {
input: input || undefined,
output: output || undefined,
cacheRead: cacheRead || undefined,
cacheWrite: cacheWrite || undefined,
total: total || undefined,
};
} catch {
return undefined;
}
}
function resolveRequestPromptTokens(params: {
lastCallUsage?: {
input?: number;
output?: number;
cacheRead?: number;
cacheWrite?: number;
total?: number;
};
promptTokens?: number;
usage?: {
input?: number;
output?: number;
cacheRead?: number;
cacheWrite?: number;
total?: number;
};
}): number | undefined {
const lastCall = params.lastCallUsage;
if (lastCall) {
const input = lastCall.input ?? 0;
const cacheRead = lastCall.cacheRead ?? 0;
const cacheWrite = lastCall.cacheWrite ?? 0;
const sum = input + cacheRead + cacheWrite;
if (sum > 0) {
return sum;
}
}
if (
typeof params.promptTokens === "number" &&
Number.isFinite(params.promptTokens) &&
params.promptTokens > 0
) {
return params.promptTokens;
}
const usage = params.usage;
if (usage) {
const input = usage.input ?? 0;
const cacheRead = usage.cacheRead ?? 0;
const cacheWrite = usage.cacheWrite ?? 0;
const sum = input + cacheRead + cacheWrite;
if (sum > 0) {
return sum;
}
}
return undefined;
}
function formatRequestContextTraceBlock(params: {
provider?: string;
model?: string;
contextLimit?: number;
promptTokens?: number;
}): string | undefined {
const limit = params.contextLimit;
const used = params.promptTokens;
if (
(typeof limit !== "number" || !Number.isFinite(limit) || limit <= 0) &&
(typeof used !== "number" || !Number.isFinite(used) || used <= 0) &&
!params.provider &&
!params.model
) {
return undefined;
}
const headroom =
typeof limit === "number" &&
Number.isFinite(limit) &&
typeof used === "number" &&
Number.isFinite(used)
? Math.max(0, limit - used)
: undefined;
const percent =
typeof limit === "number" &&
Number.isFinite(limit) &&
limit > 0 &&
typeof used === "number" &&
Number.isFinite(used)
? Math.round((used / limit) * 100)
: undefined;
return `🔎 Context Window (Last Model Request):\n~~~text\n${[
`provider=${params.provider ?? "n/a"}`,
`model=${params.model ?? "n/a"}`,
`used=${typeof used === "number" && Number.isFinite(used) ? `${used.toLocaleString()} tok (${formatTokenCount(used)})` : "n/a"}`,
`limit=${typeof limit === "number" && Number.isFinite(limit) ? `${limit.toLocaleString()} tok (${formatTokenCount(limit)})` : "n/a"}`,
`headroom=${typeof headroom === "number" ? `${headroom.toLocaleString()} tok (${formatTokenCount(headroom)})` : "n/a"}`,
`usage=${typeof percent === "number" ? `${percent}%` : "n/a"}`,
].join("\n")}\n~~~`;
}
function formatSummaryPromptValue(params: {
contextLimit?: number;
promptTokens?: number;
}): string | undefined {
const used = params.promptTokens;
const limit = params.contextLimit;
if (
typeof used !== "number" ||
!Number.isFinite(used) ||
used <= 0 ||
typeof limit !== "number" ||
!Number.isFinite(limit) ||
limit <= 0
) {
return undefined;
}
return `${formatTokenCount(used)}/${formatTokenCount(limit)}`;
}
function formatRawTraceSummaryLine(params: {
executionTrace?: TraceExecutionView;
completion?: TraceCompletionView;
contextLimit?: number;
promptTokens?: number;
usage?: {
input?: number;
output?: number;
cacheRead?: number;
cacheWrite?: number;
total?: number;
};
toolSummary?: TraceToolSummaryView;
contextManagement?: TraceContextManagementView;
requestShaping?: {
thinking?: string;
};
}): string | undefined {
const thinking = normalizeOptionalString(params.requestShaping?.thinking);
const fields = [
params.executionTrace?.winnerModel
? `winner=${params.executionTrace.winnerModel}${thinking ? ` 🧠 ${thinking}` : ""}`
: undefined,
typeof params.executionTrace?.fallbackUsed === "boolean"
? `fallback=${params.executionTrace.fallbackUsed ? "yes" : "no"}`
: undefined,
typeof params.executionTrace?.attempts?.length === "number"
? `attempts=${params.executionTrace.attempts.length.toLocaleString()}`
: undefined,
params.completion?.stopReason ? `stop=${params.completion.stopReason}` : undefined,
(() => {
const prompt = formatSummaryPromptValue({
contextLimit: params.contextLimit,
promptTokens: params.promptTokens,
});
return prompt ? `prompt=${prompt}` : undefined;
})(),
typeof params.usage?.input === "number" && params.usage.input > 0
? `⬇️ ${formatTokenCount(params.usage.input)}`
: undefined,
typeof params.usage?.output === "number" && params.usage.output > 0
? `⬆️ ${formatTokenCount(params.usage.output)}`
: undefined,
typeof params.usage?.cacheRead === "number" && params.usage.cacheRead > 0
? `♻️ ${formatTokenCount(params.usage.cacheRead)}`
: undefined,
typeof params.usage?.cacheWrite === "number" && params.usage.cacheWrite > 0
? `🆕 ${formatTokenCount(params.usage.cacheWrite)}`
: undefined,
typeof params.usage?.total === "number" && params.usage.total > 0
? `🔢 ${formatTokenCount(params.usage.total)}`
: undefined,
typeof params.toolSummary?.calls === "number" && params.toolSummary.calls > 0
? `tools=${params.toolSummary.calls.toLocaleString()}`
: undefined,
typeof params.contextManagement?.lastTurnCompactions === "number" &&
params.contextManagement.lastTurnCompactions > 0
? `compactions=${params.contextManagement.lastTurnCompactions.toLocaleString()}`
: undefined,
].filter((value): value is string => Boolean(value));
return fields.length > 0 ? `Summary: ${fields.join(" ")}` : undefined;
}
function buildInlineRawTracePayload(params: {
entry: SessionEntry | undefined;
rawUserText?: string;
rawAssistantText?: string;
sessionUsage?: {
input?: number;
output?: number;
cacheRead?: number;
cacheWrite?: number;
total?: number;
};
usage?: {
input?: number;
output?: number;
cacheRead?: number;
cacheWrite?: number;
total?: number;
};
lastCallUsage?: {
input?: number;
output?: number;
cacheRead?: number;
cacheWrite?: number;
total?: number;
};
provider?: string;
model?: string;
contextLimit?: number;
promptTokens?: number;
executionTrace?: TraceExecutionView;
requestShaping?: {
authMode?: string;
thinking?: string;
reasoning?: string;
verbose?: string;
trace?: string;
fallbackEligible?: boolean;
blockStreaming?: string;
};
promptSegments?: TracePromptSegmentView[];
toolSummary?: TraceToolSummaryView;
completion?: TraceCompletionView;
contextManagement?: TraceContextManagementView;
}): ReplyPayload | undefined {
if (params.entry?.traceLevel !== "raw") {
return undefined;
}
const resolvedPromptTokens = resolveRequestPromptTokens({
lastCallUsage: params.lastCallUsage,
promptTokens: params.promptTokens,
usage: params.usage,
});
const requestContextBlock = formatRequestContextTraceBlock({
provider: params.provider,
model: params.model,
contextLimit: params.contextLimit,
promptTokens: resolvedPromptTokens,
});
const usageBlocks = [
formatUsageTraceBlock("Usage (Session Total)", params.sessionUsage),
formatUsageTraceBlock("Usage (Last Turn Total)", params.usage),
requestContextBlock,
formatExecutionResultTraceBlock(params.executionTrace),
formatFallbackChainTraceBlock(params.executionTrace),
formatKeyValueTraceBlock("Request Shaping", [
["provider", params.provider],
["model", params.model],
["auth", params.requestShaping?.authMode],
["thinking", params.requestShaping?.thinking],
["reasoning", params.requestShaping?.reasoning],
["verbose", params.requestShaping?.verbose],
["trace", params.requestShaping?.trace],
["fallbackEligible", params.requestShaping?.fallbackEligible],
["blockStreaming", params.requestShaping?.blockStreaming],
]),
formatPromptSegmentsTraceBlock(params.promptSegments, params.rawUserText),
formatToolSummaryTraceBlock(params.toolSummary),
formatCompletionTraceBlock(params.completion),
formatContextManagementTraceBlock(params.contextManagement),
].filter((value): value is string => Boolean(value));
return {
text: [
...usageBlocks,
formatRawTraceBlock("Model Input (User Role)", params.rawUserText),
formatRawTraceBlock("Model Output (Assistant Role)", params.rawAssistantText),
formatRawTraceSummaryLine({
executionTrace: params.executionTrace,
completion: params.completion,
contextLimit: params.contextLimit,
promptTokens: resolvedPromptTokens,
usage: params.usage,
toolSummary: params.toolSummary,
contextManagement: params.contextManagement,
requestShaping: params.requestShaping,
}),
].join("\n\n\n"),
};
}
function refreshSessionEntryFromStore(params: {
storePath?: string;
sessionKey?: string;
@@ -327,6 +1072,8 @@ export async function runReplyAgent(params: {
throw error;
}
let runFollowupTurn = queuedRunFollowupTurn;
const prePreflightCompactionCount = activeSessionEntry?.compactionCount ?? 0;
let preflightCompactionApplied = false;
try {
await typingSignals.signalRunStart();
@@ -344,6 +1091,8 @@ export async function runReplyAgent(params: {
isHeartbeat,
replyOperation,
});
preflightCompactionApplied =
(activeSessionEntry?.compactionCount ?? 0) > prePreflightCompactionCount;
activeSessionEntry = await runMemoryFlushIfNeeded({
cfg,
@@ -812,12 +1561,133 @@ export async function runReplyAgent(params: {
}
}
const prefixPayloads = [...verboseNotices];
const rawUserText =
runResult.meta?.finalPromptText ??
sessionCtx.CommandBody ??
sessionCtx.RawBody ??
sessionCtx.BodyForAgent ??
sessionCtx.Body;
const rawAssistantText =
runResult.meta?.finalAssistantRawText ?? runResult.meta?.finalAssistantVisibleText;
const traceAuthorized = followupRun.run.traceAuthorized === true;
const executionTrace = mergeExecutionTrace({
fallbackAttempts,
executionTrace: runResult.meta?.executionTrace as TraceExecutionView | undefined,
provider: providerUsed,
model: modelUsed,
runner: isCliProvider(providerUsed, cfg) ? "cli" : "embedded",
});
const requestShaping = {
authMode:
runResult.meta?.requestShaping?.authMode ??
(cfg?.models?.providers && providerUsed in cfg.models.providers
? (resolveModelAuthMode(providerUsed, cfg) ?? undefined)
: undefined),
thinking:
runResult.meta?.requestShaping?.thinking ??
normalizeOptionalString(followupRun.run.thinkLevel),
reasoning:
runResult.meta?.requestShaping?.reasoning ??
normalizeOptionalString(followupRun.run.reasoningLevel),
verbose:
runResult.meta?.requestShaping?.verbose ?? normalizeOptionalString(resolvedVerboseLevel),
trace:
runResult.meta?.requestShaping?.trace ??
normalizeOptionalString(activeSessionEntry?.traceLevel),
fallbackEligible:
runResult.meta?.requestShaping?.fallbackEligible ??
hasConfiguredModelFallbacks({
cfg,
agentId: followupRun.run.agentId,
sessionKey: followupRun.run.sessionKey,
}),
blockStreaming:
runResult.meta?.requestShaping?.blockStreaming ??
normalizeOptionalString(resolvedBlockStreamingBreak),
};
const promptSegments =
(runResult.meta?.promptSegments as TracePromptSegmentView[] | undefined) ??
derivePromptSegments(rawUserText);
const toolSummary = runResult.meta?.toolSummary as TraceToolSummaryView | undefined;
const completion =
(runResult.meta?.completion as TraceCompletionView | undefined) ??
(runResult.meta?.stopReason
? {
stopReason: runResult.meta.stopReason,
finishReason: runResult.meta.stopReason,
...(runResult.meta.stopReason.toLowerCase().includes("refusal")
? { refusal: true }
: {}),
}
: undefined);
const contextManagement = {
...(typeof activeSessionEntry?.compactionCount === "number"
? { sessionCompactions: activeSessionEntry.compactionCount }
: {}),
...(typeof runResult.meta?.contextManagement?.lastTurnCompactions === "number"
? { lastTurnCompactions: runResult.meta.contextManagement.lastTurnCompactions }
: typeof runResult.meta?.agentMeta?.compactionCount === "number"
? { lastTurnCompactions: runResult.meta.agentMeta.compactionCount }
: {}),
...(runResult.meta?.contextManagement &&
typeof runResult.meta.contextManagement.preflightCompactionApplied === "boolean"
? {
preflightCompactionApplied: runResult.meta.contextManagement.preflightCompactionApplied,
}
: preflightCompactionApplied
? { preflightCompactionApplied }
: {}),
...(runResult.meta?.contextManagement &&
typeof runResult.meta.contextManagement.postCompactionContextInjected === "boolean"
? {
postCompactionContextInjected:
runResult.meta.contextManagement.postCompactionContextInjected,
}
: {}),
} satisfies TraceContextManagementView;
const sessionUsage =
traceAuthorized && activeSessionEntry?.traceLevel === "raw"
? await accumulateSessionUsageFromTranscript({
sessionId: runResult.meta?.agentMeta?.sessionId ?? followupRun.run.sessionId,
storePath,
sessionFile: followupRun.run.sessionFile,
})
: undefined;
const traceEnabledForSender =
traceAuthorized &&
(activeSessionEntry?.traceLevel === "on" || activeSessionEntry?.traceLevel === "raw");
const shouldAppendTracePayload = verboseEnabled || traceEnabledForSender;
let trailingPluginStatusPayload: ReplyPayload | undefined;
if (verboseEnabled) {
const pluginStatusPayload = buildInlinePluginStatusPayload(activeSessionEntry);
if (pluginStatusPayload) {
trailingPluginStatusPayload = pluginStatusPayload;
}
if (shouldAppendTracePayload) {
const pluginStatusPayload = buildInlinePluginStatusPayload({
entry: activeSessionEntry,
includeTraceLines: traceEnabledForSender,
});
const rawTracePayload =
traceAuthorized && activeSessionEntry?.traceLevel === "raw"
? buildInlineRawTracePayload({
entry: activeSessionEntry,
rawUserText,
rawAssistantText,
sessionUsage,
usage: runResult.meta?.agentMeta?.usage,
lastCallUsage: runResult.meta?.agentMeta?.lastCallUsage,
provider: providerUsed,
model: modelUsed,
contextLimit: contextTokensUsed,
promptTokens,
executionTrace,
requestShaping,
promptSegments,
toolSummary,
completion,
contextManagement,
})
: undefined;
trailingPluginStatusPayload =
pluginStatusPayload && rawTracePayload
? { text: `${pluginStatusPayload.text}\n\n${rawTracePayload.text}` }
: (pluginStatusPayload ?? rawTracePayload);
}
if (prefixPayloads.length > 0) {
finalPayloads = [...prefixPayloads, ...finalPayloads];

1
src/auto-reply/reply/directive-handling.fast-lane.ts
View File

@@ -90,6 +90,7 @@ export async function applyInlineDirectivesFastLane(
currentElevatedLevel,
surface: ctx.Surface,
gatewayClientScopes: ctx.GatewayClientScopes,
senderIsOwner: params.senderIsOwner,
});
if (sessionEntry?.providerOverride) {

22
src/auto-reply/reply/directive-handling.impl.ts
View File

@@ -56,6 +56,12 @@ export async function handleDirectiveOnly(
currentReasoningLevel,
currentElevatedLevel,
} = params;
const delegatedTraceAllowed = (params.gatewayClientScopes ?? []).includes("operator.admin");
if (directives.hasTraceDirective && !params.senderIsOwner && !delegatedTraceAllowed) {
return {
text: "❌ /trace is restricted to owners and gateway clients with operator.admin scope.",
};
}
const activeAgentId = resolveSessionAgentId({
sessionKey: params.sessionKey,
config: params.cfg,
@@ -154,13 +160,13 @@ export async function handleDirectiveOnly(
}
if (directives.hasTraceDirective && !directives.traceLevel) {
if (!directives.rawTraceLevel) {
const level = (sessionEntry.traceLevel as "on" | "off" | undefined) ?? "off";
const level = (sessionEntry.traceLevel as "on" | "off" | "raw" | undefined) ?? "off";
return {
text: withOptions(`Current trace level: ${level}.`, "on, off"),
text: withOptions(`Current trace level: ${level}.`, "on, off, raw"),
};
}
return {
text: `Unrecognized trace level "${directives.rawTraceLevel}". Valid levels: off, on.`,
text: `Unrecognized trace level "${directives.rawTraceLevel}". Valid levels: off, on, raw.`,
};
}
if (directives.hasFastDirective && directives.fastMode === undefined) {
@@ -473,8 +479,14 @@ export async function handleDirectiveOnly(
if (directives.hasTraceDirective && directives.traceLevel) {
parts.push(
directives.traceLevel === "off"
? formatDirectiveAck("Plugin trace disabled.")
: formatDirectiveAck("Plugin trace enabled."),
? formatDirectiveAck("Trace disabled.")
: directives.traceLevel === "raw"
? formatDirectiveAck(
"Trace set to raw. Warning: trace output may contain sensitive information.",
)
: formatDirectiveAck(
"Trace enabled. Warning: trace output may contain sensitive information.",
),
);
}
if (

33
src/auto-reply/reply/directive-handling.mixed-inline.test.ts
View File

@@ -189,4 +189,37 @@ describe("mixed inline directives", () => {
expect(sessionEntry.reasoningLevel).toBe("off");
});
it("does not persist trace directives for unauthorized mixed messages", async () => {
const directives = parseInlineDirectives("please reply\n/trace raw");
const cfg = createConfig();
const sessionEntry = createSessionEntry({ traceLevel: "off" as const });
const sessionStore = { "agent:main:telegram:user": sessionEntry };
await persistInlineDirectives({
directives,
cfg,
sessionEntry,
sessionStore,
sessionKey: "agent:main:telegram:user",
storePath: undefined,
elevatedEnabled: false,
elevatedAllowed: false,
defaultProvider: "anthropic",
defaultModel: "claude-opus-4-6",
aliasIndex: { byAlias: new Map(), byKey: new Map() },
allowedModelKeys: new Set(),
provider: "anthropic",
model: "claude-opus-4-6",
initialModelLabel: "anthropic/claude-opus-4-6",
formatModelSwitchEvent: (label) => label,
agentCfg: cfg.agents?.defaults,
messageProvider: "telegram",
surface: "telegram",
gatewayClientScopes: [],
senderIsOwner: false,
});
expect(sessionEntry.traceLevel).toBe("off");
});
});

2
src/auto-reply/reply/directive-handling.params.ts
View File

@@ -39,10 +39,12 @@ export type HandleDirectiveOnlyParams = HandleDirectiveOnlyCoreParams & {
currentElevatedLevel?: ElevatedLevel;
surface?: string;
gatewayClientScopes?: string[];
senderIsOwner?: boolean;
};
export type ApplyInlineDirectivesFastLaneParams = HandleDirectiveOnlyCoreParams & {
commandAuthorized: boolean;
senderIsOwner: boolean;
ctx: MsgContext;
agentId?: string;
isGroup: boolean;

8
src/auto-reply/reply/directive-handling.persist.ts
View File

@@ -44,6 +44,7 @@ export async function persistInlineDirectives(params: {
messageProvider?: string;
surface?: string;
gatewayClientScopes?: string[];
senderIsOwner?: boolean;
}): Promise<{ provider: string; model: string; contextTokens: number }> {
const {
directives,
@@ -73,6 +74,7 @@ export async function persistInlineDirectives(params: {
surface: params.surface,
gatewayClientScopes: params.gatewayClientScopes,
});
const delegatedTraceAllowed = (params.gatewayClientScopes ?? []).includes("operator.admin");
const activeAgentId = sessionKey
? resolveSessionAgentId({ sessionKey, config: cfg })
: resolveDefaultAgentId(cfg);
@@ -105,7 +107,11 @@ export async function persistInlineDirectives(params: {
applyVerboseOverride(sessionEntry, directives.verboseLevel);
updated = true;
}
if (directives.hasTraceDirective && directives.traceLevel) {
if (
directives.hasTraceDirective &&
directives.traceLevel &&
(params.senderIsOwner || delegatedTraceAllowed)
) {
applyTraceOverride(sessionEntry, directives.traceLevel);
updated = true;
}

4
src/auto-reply/reply/get-reply-directives-apply.ts
View File

@@ -179,6 +179,7 @@ export async function applyInlineDirectiveOverrides(params: {
directives.hasThinkDirective ||
directives.hasFastDirective ||
directives.hasVerboseDirective ||
directives.hasTraceDirective ||
directives.hasReasoningDirective ||
directives.hasElevatedDirective ||
directives.hasExecDirective ||
@@ -237,6 +238,7 @@ export async function applyInlineDirectiveOverrides(params: {
messageProvider: ctx.Provider,
surface: ctx.Surface,
gatewayClientScopes: ctx.GatewayClientScopes,
senderIsOwner: command.senderIsOwner,
});
let statusReply: ReplyPayload | undefined;
if (directives.hasStatusDirective && allowTextCommands && command.isAuthorizedSender) {
@@ -279,6 +281,7 @@ export async function applyInlineDirectiveOverrides(params: {
).applyInlineDirectivesFastLane({
directives,
commandAuthorized: command.isAuthorizedSender,
senderIsOwner: command.senderIsOwner,
ctx,
cfg,
agentId,
@@ -335,6 +338,7 @@ export async function applyInlineDirectiveOverrides(params: {
messageProvider: ctx.Provider,
surface: ctx.Surface,
gatewayClientScopes: ctx.GatewayClientScopes,
senderIsOwner: command.senderIsOwner,
});
provider = persisted.provider;
model = persisted.model;

132
src/auto-reply/reply/get-reply-directives.target-session.test.ts
View File

@@ -69,27 +69,59 @@ async function loadResolveReplyDirectivesForTest() {
})),
}));
vi.doMock("./directive-handling.parse.js", () => ({
parseInlineDirectives: vi.fn((body: string) => ({
cleaned: body,
hasThinkDirective: false,
hasVerboseDirective: false,
hasFastDirective: false,
hasReasoningDirective: false,
hasElevatedDirective: false,
hasExecDirective: false,
hasModelDirective: false,
hasQueueDirective: false,
hasStatusDirective: false,
queueReset: false,
thinkLevel: undefined,
verboseLevel: undefined,
fastMode: undefined,
reasoningLevel: undefined,
elevatedLevel: undefined,
rawElevatedLevel: undefined,
rawModelDirective: undefined,
execSecurity: undefined,
})),
parseInlineDirectives: vi.fn((body: string) => {
const normalized = body.trim();
if (normalized === "/trace on") {
return {
cleaned: "",
hasThinkDirective: false,
hasVerboseDirective: false,
hasTraceDirective: true,
traceLevel: "on",
rawTraceLevel: "on",
hasFastDirective: false,
hasReasoningDirective: false,
hasElevatedDirective: false,
hasExecDirective: false,
hasModelDirective: false,
hasQueueDirective: false,
hasStatusDirective: false,
queueReset: false,
thinkLevel: undefined,
verboseLevel: undefined,
fastMode: undefined,
reasoningLevel: undefined,
elevatedLevel: undefined,
rawElevatedLevel: undefined,
rawModelDirective: undefined,
execSecurity: undefined,
};
}
return {
cleaned: body,
hasThinkDirective: false,
hasVerboseDirective: false,
hasTraceDirective: false,
traceLevel: undefined,
rawTraceLevel: undefined,
hasFastDirective: false,
hasReasoningDirective: false,
hasElevatedDirective: false,
hasExecDirective: false,
hasModelDirective: false,
hasQueueDirective: false,
hasStatusDirective: false,
queueReset: false,
thinkLevel: undefined,
verboseLevel: undefined,
fastMode: undefined,
reasoningLevel: undefined,
elevatedLevel: undefined,
rawElevatedLevel: undefined,
rawModelDirective: undefined,
execSecurity: undefined,
};
}),
}));
vi.doMock("./get-reply-directive-aliases.js", () => ({
reserveSkillCommandNames: vi.fn(),
@@ -258,6 +290,64 @@ describe("resolveReplyDirectives", () => {
});
});
it("returns a directive-only ack for trace commands instead of continuing into the agent path", async () => {
mocks.applyInlineDirectiveOverrides.mockResolvedValueOnce({
kind: "reply",
reply: {
text: "⚙️ Trace enabled. Warning: trace output may contain sensitive information.",
},
});
const { resolveReplyDirectives } = await loadResolveReplyDirectivesForTest();
const result = await resolveReplyDirectives({
ctx: buildTestCtx({
Body: "/trace on",
CommandBody: "/trace on",
CommandAuthorized: true,
}),
cfg: {},
agentId: "main",
agentDir: "/tmp/main-agent",
workspaceDir: "/tmp",
agentCfg: {},
sessionCtx: {
Body: "/trace on",
BodyStripped: "/trace on",
BodyForAgent: "/trace on",
CommandBody: "/trace on",
Provider: "telegram",
Surface: "telegram",
} as TemplateContext,
sessionEntry: makeSessionEntry(),
sessionStore: {
"agent:main:telegram:+2000": makeSessionEntry(),
},
sessionKey: "agent:main:telegram:+2000",
storePath: "/tmp/sessions.json",
sessionScope: "per-sender",
groupResolution: undefined,
isGroup: false,
triggerBodyNormalized: "/trace on",
commandAuthorized: true,
defaultProvider: "openai",
defaultModel: "gpt-4o-mini",
aliasIndex: { byAlias: new Map(), byKey: new Map() },
provider: "openai",
model: "gpt-4o-mini",
hasResolvedHeartbeatModelOverride: false,
typing: makeTypingController(),
opts: undefined,
skillFilter: undefined,
});
expect(result).toEqual({
kind: "reply",
reply: {
text: "⚙️ Trace enabled. Warning: trace output may contain sensitive information.",
},
});
});
it("uses the model reasoning default when thinking is off", async () => {
const resolveDefaultThinkingLevel = vi.fn(async () => "off");
const resolveDefaultReasoningLevel = vi.fn(async () => "on");

1
src/auto-reply/reply/get-reply-directives.ts
View File

@@ -265,6 +265,7 @@ export async function resolveReplyDirectives(params: {
const hasInlineDirective =
parsedDirectives.hasThinkDirective ||
parsedDirectives.hasVerboseDirective ||
parsedDirectives.hasTraceDirective ||
parsedDirectives.hasFastDirective ||
parsedDirectives.hasReasoningDirective ||
parsedDirectives.hasElevatedDirective ||

3
src/auto-reply/reply/get-reply-run.ts
View File

@@ -634,6 +634,9 @@ export async function runPreparedReply(
senderUsername: normalizeOptionalString(sessionCtx.SenderUsername),
senderE164: normalizeOptionalString(sessionCtx.SenderE164),
senderIsOwner: forceSenderIsOwnerFalseFromSystemEvents ? false : command.senderIsOwner,
traceAuthorized:
(forceSenderIsOwnerFalseFromSystemEvents ? false : command.senderIsOwner) ||
(ctx.GatewayClientScopes ?? []).includes("operator.admin"),
sessionFile: preparedSessionState.sessionFile,
workspaceDir,
config: cfg,

1
src/auto-reply/reply/queue/types.ts
View File

@@ -57,6 +57,7 @@ export type FollowupRun = {
senderUsername?: string;
senderE164?: string;
senderIsOwner?: boolean;
traceAuthorized?: boolean;
sessionFile: string;
workspaceDir: string;
config: OpenClawConfig;

28
src/auto-reply/status.test.ts
View File

@@ -227,6 +227,30 @@ describe("buildStatusMessage", () => {
expect(visible).toContain("trace");
});
it("shows raw trace mode and plugin trace lines in status", () => {
const visible = normalizeTestText(
buildStatusMessage({
agent: {
model: "anthropic/pi:opus",
},
sessionEntry: {
sessionId: "abc",
updatedAt: 0,
verboseLevel: "off",
traceLevel: "raw",
pluginDebugEntries: [
{ pluginId: "active-memory", lines: ["🔎 Active Memory Debug: spicy ramen; tacos"] },
],
},
sessionKey: "agent:main:main",
queue: { mode: "collect", depth: 0 },
}),
);
expect(visible).toContain("Active Memory Debug: spicy ramen; tacos");
expect(visible).toContain("trace:raw");
});
it("shows fast mode when enabled", () => {
const text = buildStatusMessage({
agent: {
@@ -1684,6 +1708,10 @@ describe("buildHelpMessage", () => {
it("includes /fast in help output", () => {
expect(buildHelpMessage()).toContain("/fast status|on|off");
});
it("includes raw trace mode in help output", () => {
expect(buildHelpMessage()).toContain("/trace on|off|raw");
});
});
describe("buildCommandsMessagePaginated", () => {

8
src/auto-reply/status.ts
View File

@@ -682,10 +682,12 @@ export function buildStatusMessage(args: StatusArgs): string {
const queueDetails = formatQueueDetails(args.queue);
const verboseLabel =
verboseLevel === "full" ? "verbose:full" : verboseLevel === "on" ? "verbose" : null;
const traceLevel = entry?.traceLevel === "on" ? "on" : "off";
const traceLabel = traceLevel === "on" ? "trace" : null;
const traceLevel = entry?.traceLevel === "raw" ? "raw" : entry?.traceLevel === "on" ? "on" : "off";
const traceLabel =
traceLevel === "raw" ? "trace:raw" : traceLevel === "on" ? "trace" : null;
const pluginStatusLines = verboseLevel !== "off" ? resolveSessionPluginStatusLines(entry) : [];
const pluginTraceLines = traceLevel === "on" ? resolveSessionPluginTraceLines(entry) : [];
const pluginTraceLines =
traceLevel === "on" || traceLevel === "raw" ? resolveSessionPluginTraceLines(entry) : [];
const pluginStatusLine =
pluginStatusLines.length > 0 || pluginTraceLines.length > 0
? [...pluginStatusLines, ...pluginTraceLines].join(" · ")

5
src/auto-reply/thinking.shared.ts
View File

@@ -5,7 +5,7 @@ import {
export type ThinkLevel = "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "adaptive";
export type VerboseLevel = "off" | "on" | "full";
export type TraceLevel = "off" | "on";
export type TraceLevel = "off" | "on" | "raw";
export type NoticeLevel = "off" | "on" | "full";
export type ElevatedLevel = "off" | "on" | "ask" | "full";
export type ElevatedMode = "off" | "ask" | "full";
@@ -147,6 +147,9 @@ export function normalizeTraceLevel(raw?: string | null): TraceLevel | undefined
if (["on", "true", "yes", "1"].includes(key)) {
return "on";
}
if (["raw", "unfiltered"].includes(key)) {
return "raw";
}
return undefined;
}

4
src/sessions/level-overrides.ts
View File

@@ -46,11 +46,11 @@ export function parseTraceOverride(
return { ok: true, value: undefined };
}
if (typeof raw !== "string") {
return { ok: false, error: 'invalid traceLevel (use "on"|"off")' };
return { ok: false, error: 'invalid traceLevel (use "on"|"off"|"raw")' };
}
const normalized = normalizeTraceLevel(raw);
if (!normalized) {
return { ok: false, error: 'invalid traceLevel (use "on"|"off")' };
return { ok: false, error: 'invalid traceLevel (use "on"|"off"|"raw")' };
}
return { ok: true, value: normalized };
}