Merge branch 'main' into commands-list-clean

2026-01-08 21:47:09 -05:00
parent c678216ac2 0cbc5fea93
commit e52a2888cc
45 changed files with 1265 additions and 268 deletions
--- a/src/auto-reply/reply/agent-runner.ts
+++ b/src/auto-reply/reply/agent-runner.ts
@@ -2,12 +2,13 @@ import crypto from "node:crypto";
 import fs from "node:fs";
 import { lookupContextTokens } from "../../agents/context.js";
 import { DEFAULT_CONTEXT_TOKENS } from "../../agents/defaults.js";
+import { resolveModelAuthMode } from "../../agents/model-auth.js";
 import { runWithModelFallback } from "../../agents/model-fallback.js";
 import {
  queueEmbeddedPiMessage,
  runEmbeddedPiAgent,
 } from "../../agents/pi-embedded.js";
-import { hasNonzeroUsage } from "../../agents/usage.js";
+import { hasNonzeroUsage, type NormalizedUsage } from "../../agents/usage.js";
 import {
  loadSessionStore,
  resolveSessionTranscriptPath,
@@ -18,6 +19,12 @@ import type { TypingMode } from "../../config/types.js";
 import { logVerbose } from "../../globals.js";
 import { registerAgentRunContext } from "../../infra/agent-events.js";
 import { defaultRuntime } from "../../runtime.js";
+import {
+  estimateUsageCost,
+  formatTokenCount,
+  formatUsd,
+  resolveModelCostConfig,
+} from "../../utils/usage-format.js";
 import { stripHeartbeatToken } from "../heartbeat.js";
 import type { OriginatingChannelType, TemplateContext } from "../templating.js";
 import { normalizeVerboseLevel, type VerboseLevel } from "../thinking.js";
@@ -62,6 +69,65 @@ const formatBunFetchSocketError = (message: string) => {
  ].join("\n");
 };

+const formatResponseUsageLine = (params: {
+  usage?: NormalizedUsage;
+  showCost: boolean;
+  costConfig?: {
+    input: number;
+    output: number;
+    cacheRead: number;
+    cacheWrite: number;
+  };
+}): string | null => {
+  const usage = params.usage;
+  if (!usage) return null;
+  const input = usage.input;
+  const output = usage.output;
+  if (typeof input !== "number" && typeof output !== "number") return null;
+  const inputLabel = typeof input === "number" ? formatTokenCount(input) : "?";
+  const outputLabel =
+    typeof output === "number" ? formatTokenCount(output) : "?";
+  const cost =
+    params.showCost && typeof input === "number" && typeof output === "number"
+      ? estimateUsageCost({
+          usage: {
+            input,
+            output,
+            cacheRead: usage.cacheRead,
+            cacheWrite: usage.cacheWrite,
+          },
+          cost: params.costConfig,
+        })
+      : undefined;
+  const costLabel = params.showCost ? formatUsd(cost) : undefined;
+  const suffix = costLabel ? ` · est ${costLabel}` : "";
+  return `Usage: ${inputLabel} in / ${outputLabel} out${suffix}`;
+};
+
+const appendUsageLine = (
+  payloads: ReplyPayload[],
+  line: string,
+): ReplyPayload[] => {
+  let index = -1;
+  for (let i = payloads.length - 1; i >= 0; i -= 1) {
+    if (payloads[i]?.text) {
+      index = i;
+      break;
+    }
+  }
+  if (index === -1) return [...payloads, { text: line }];
+  const existing = payloads[index];
+  const existingText = existing.text ?? "";
+  const separator = existingText.endsWith("\n") ? "" : "\n";
+  const next = {
+    ...existing,
+    text: `${existingText}${separator}${line}`,
+  };
+  const updated = payloads.slice();
+  updated[index] = next;
+  return updated;
+};
+
 const withTimeout = async <T>(
  promise: Promise<T>,
  timeoutMs: number,
@@ -191,6 +257,7 @@ export async function runReplyAgent(params: {
    replyToChannel,
  );
  const applyReplyToMode = createReplyToModeFilter(replyToMode);
+  const cfg = followupRun.run.config;

  if (shouldSteer && isStreaming) {
    const steered = queueEmbeddedPiMessage(
@@ -242,6 +309,7 @@ export async function runReplyAgent(params: {

  let didLogHeartbeatStrip = false;
  let autoCompactionCompleted = false;
+  let responseUsageLine: string | undefined;
  try {
    const runId = crypto.randomUUID();
    if (sessionKey) {
@@ -641,20 +709,20 @@ export async function runReplyAgent(params: {
      await typingSignals.signalRunStart();
    }

-    if (sessionStore && sessionKey) {
-      const usage = runResult.meta.agentMeta?.usage;
-      const modelUsed =
-        runResult.meta.agentMeta?.model ?? fallbackModel ?? defaultModel;
-      const providerUsed =
-        runResult.meta.agentMeta?.provider ??
-        fallbackProvider ??
-        followupRun.run.provider;
-      const contextTokensUsed =
-        agentCfgContextTokens ??
-        lookupContextTokens(modelUsed) ??
-        sessionEntry?.contextTokens ??
-        DEFAULT_CONTEXT_TOKENS;
+    const usage = runResult.meta.agentMeta?.usage;
+    const modelUsed =
+      runResult.meta.agentMeta?.model ?? fallbackModel ?? defaultModel;
+    const providerUsed =
+      runResult.meta.agentMeta?.provider ??
+      fallbackProvider ??
+      followupRun.run.provider;
+    const contextTokensUsed =
+      agentCfgContextTokens ??
+      lookupContextTokens(modelUsed) ??
+      sessionEntry?.contextTokens ??
+      DEFAULT_CONTEXT_TOKENS;

+    if (sessionStore && sessionKey) {
      if (hasNonzeroUsage(usage)) {
        const entry = sessionEntry ?? sessionStore[sessionKey];
        if (entry) {
@@ -694,6 +762,29 @@ export async function runReplyAgent(params: {
      }
    }

+    const responseUsageEnabled =
+      (sessionEntry?.responseUsage ??
+        (sessionKey
+          ? sessionStore?.[sessionKey]?.responseUsage
+          : undefined)) === "on";
+    if (responseUsageEnabled && hasNonzeroUsage(usage)) {
+      const authMode = resolveModelAuthMode(providerUsed, cfg);
+      const showCost = authMode === "api-key";
+      const costConfig = showCost
+        ? resolveModelCostConfig({
+            provider: providerUsed,
+            model: modelUsed,
+            config: cfg,
+          })
+        : undefined;
+      const formatted = formatResponseUsageLine({
+        usage,
+        showCost,
+        costConfig,
+      });
+      if (formatted) responseUsageLine = formatted;
+    }
+
    // If verbose is enabled and this is a new session, prepend a session hint.
    let finalPayloads = replyPayloads;
    if (autoCompactionCompleted) {
@@ -717,6 +808,9 @@ export async function runReplyAgent(params: {
        ...finalPayloads,
      ];
    }
+    if (responseUsageLine) {
+      finalPayloads = appendUsageLine(finalPayloads, responseUsageLine);
+    }

    return finalizeWithFollowup(
      finalPayloads.length === 1 ? finalPayloads[0] : finalPayloads,
--- a/src/auto-reply/reply/commands.ts
+++ b/src/auto-reply/reply/commands.ts
@@ -1,11 +1,13 @@
 import {
  ensureAuthProfileStore,
-  listProfilesForProvider,
+  resolveAuthProfileDisplayLabel,
+  resolveAuthProfileOrder,
 } from "../../agents/auth-profiles.js";
 import {
  getCustomProviderApiKey,
  resolveEnvApiKey,
 } from "../../agents/model-auth.js";
+import { normalizeProviderId } from "../../agents/model-selection.js";
 import {
  abortEmbeddedPiRun,
  compactEmbeddedPiSession,
@@ -23,6 +25,7 @@ import { logVerbose } from "../../globals.js";
 import {
  formatUsageSummaryLine,
  loadProviderUsageSummary,
+  resolveUsageProviderId,
 } from "../../infra/provider-usage.js";
 import {
  scheduleGatewaySigusr1Restart,
@@ -92,32 +95,166 @@ export type CommandContext = {
  to?: string;
 };

+export async function buildStatusReply(params: {
+  cfg: ClawdbotConfig;
+  command: CommandContext;
+  sessionEntry?: SessionEntry;
+  sessionKey?: string;
+  sessionScope?: SessionScope;
+  provider: string;
+  model: string;
+  contextTokens: number;
+  resolvedThinkLevel?: ThinkLevel;
+  resolvedVerboseLevel: VerboseLevel;
+  resolvedReasoningLevel: ReasoningLevel;
+  resolvedElevatedLevel?: ElevatedLevel;
+  resolveDefaultThinkingLevel: () => Promise<ThinkLevel | undefined>;
+  isGroup: boolean;
+  defaultGroupActivation: () => "always" | "mention";
+}): Promise<ReplyPayload | undefined> {
+  const {
+    cfg,
+    command,
+    sessionEntry,
+    sessionKey,
+    sessionScope,
+    provider,
+    model,
+    contextTokens,
+    resolvedThinkLevel,
+    resolvedVerboseLevel,
+    resolvedReasoningLevel,
+    resolvedElevatedLevel,
+    resolveDefaultThinkingLevel,
+    isGroup,
+    defaultGroupActivation,
+  } = params;
+  if (!command.isAuthorizedSender) {
+    logVerbose(
+      `Ignoring /status from unauthorized sender: ${command.senderE164 || "<unknown>"}`,
+    );
+    return undefined;
+  }
+  let usageLine: string | null = null;
+  try {
+    const usageProvider = resolveUsageProviderId(provider);
+    if (usageProvider) {
+      const usageSummary = await loadProviderUsageSummary({
+        timeoutMs: 3500,
+        providers: [usageProvider],
+      });
+      usageLine = formatUsageSummaryLine(usageSummary, { now: Date.now() });
+    }
+  } catch {
+    usageLine = null;
+  }
+  const queueSettings = resolveQueueSettings({
+    cfg,
+    provider: command.provider,
+    sessionEntry,
+  });
+  const queueKey = sessionKey ?? sessionEntry?.sessionId;
+  const queueDepth = queueKey ? getFollowupQueueDepth(queueKey) : 0;
+  const queueOverrides = Boolean(
+    sessionEntry?.queueDebounceMs ??
+      sessionEntry?.queueCap ??
+      sessionEntry?.queueDrop,
+  );
+  const groupActivation = isGroup
+    ? (normalizeGroupActivation(sessionEntry?.groupActivation) ??
+      defaultGroupActivation())
+    : undefined;
+  const statusText = buildStatusMessage({
+    agent: {
+      ...cfg.agent,
+      model: {
+        ...cfg.agent?.model,
+        primary: `${provider}/${model}`,
+      },
+      contextTokens,
+      thinkingDefault: cfg.agent?.thinkingDefault,
+      verboseDefault: cfg.agent?.verboseDefault,
+      elevatedDefault: cfg.agent?.elevatedDefault,
+    },
+    sessionEntry,
+    sessionKey,
+    sessionScope,
+    groupActivation,
+    resolvedThink: resolvedThinkLevel ?? (await resolveDefaultThinkingLevel()),
+    resolvedVerbose: resolvedVerboseLevel,
+    resolvedReasoning: resolvedReasoningLevel,
+    resolvedElevated: resolvedElevatedLevel,
+    modelAuth: resolveModelAuthLabel(provider, cfg, sessionEntry),
+    usageLine: usageLine ?? undefined,
+    queue: {
+      mode: queueSettings.mode,
+      depth: queueDepth,
+      debounceMs: queueSettings.debounceMs,
+      cap: queueSettings.cap,
+      dropPolicy: queueSettings.dropPolicy,
+      showDetails: queueOverrides,
+    },
+    includeTranscriptUsage: false,
+  });
+  return { text: statusText };
+}
+
+function formatApiKeySnippet(apiKey: string): string {
+  const compact = apiKey.replace(/\s+/g, "");
+  if (!compact) return "unknown";
+  const edge = compact.length >= 12 ? 6 : 4;
+  const head = compact.slice(0, edge);
+  const tail = compact.slice(-edge);
+  return `${head}…${tail}`;
+}
+
 function resolveModelAuthLabel(
  provider?: string,
  cfg?: ClawdbotConfig,
+  sessionEntry?: SessionEntry,
 ): string | undefined {
  const resolved = provider?.trim();
  if (!resolved) return undefined;

+  const providerKey = normalizeProviderId(resolved);
  const store = ensureAuthProfileStore();
-  const profiles = listProfilesForProvider(store, resolved);
-  if (profiles.length > 0) {
-    const modes = new Set(
-      profiles
-        .map((id) => store.profiles[id]?.type)
-        .filter((mode): mode is "api_key" | "oauth" => Boolean(mode)),
-    );
-    if (modes.has("oauth") && modes.has("api_key")) return "mixed";
-    if (modes.has("oauth")) return "oauth";
-    if (modes.has("api_key")) return "api-key";
+  const profileOverride = sessionEntry?.authProfileOverride?.trim();
+  const lastGood = store.lastGood?.[providerKey] ?? store.lastGood?.[resolved];
+  const order = resolveAuthProfileOrder({
+    cfg,
+    store,
+    provider: providerKey,
+    preferredProfile: profileOverride,
+  });
+  const candidates = [profileOverride, lastGood, ...order].filter(
+    Boolean,
+  ) as string[];
+
+  for (const profileId of candidates) {
+    const profile = store.profiles[profileId];
+    if (!profile || normalizeProviderId(profile.provider) !== providerKey) {
+      continue;
+    }
+    const label = resolveAuthProfileDisplayLabel({ cfg, store, profileId });
+    if (profile.type === "oauth") {
+      return `oauth${label ? ` (${label})` : ""}`;
+    }
+    const snippet = formatApiKeySnippet(profile.key);
+    return `api-key ${snippet}${label ? ` (${label})` : ""}`;
  }

-  const envKey = resolveEnvApiKey(resolved);
+  const envKey = resolveEnvApiKey(providerKey);
  if (envKey?.apiKey) {
-    return envKey.source.includes("OAUTH_TOKEN") ? "oauth" : "api-key";
+    if (envKey.source.includes("OAUTH_TOKEN")) {
+      return `oauth (${envKey.source})`;
+    }
+    return `api-key ${formatApiKeySnippet(envKey.apiKey)} (${envKey.source})`;
  }

-  if (getCustomProviderApiKey(cfg, resolved)) return "api-key";
+  const customKey = getCustomProviderApiKey(cfg, providerKey);
+  if (customKey) {
+    return `api-key ${formatApiKeySnippet(customKey)} (models.json)`;
+  }

  return "unknown";
 }
@@ -426,71 +563,24 @@ export async function handleCommands(params: {
    directives.hasStatusDirective ||
    command.commandBodyNormalized === "/status";
  if (allowTextCommands && statusRequested) {
-    if (!command.isAuthorizedSender) {
-      logVerbose(
-        `Ignoring /status from unauthorized sender: ${command.senderE164 || "<unknown>"}`,
-      );
-      return { shouldContinue: false };
-    }
-    let usageLine: string | null = null;
-    try {
-      const usageSummary = await loadProviderUsageSummary({
-        timeoutMs: 3500,
-      });
-      usageLine = formatUsageSummaryLine(usageSummary, { now: Date.now() });
-    } catch {
-      usageLine = null;
-    }
-    const queueSettings = resolveQueueSettings({
+    const reply = await buildStatusReply({
      cfg,
-      provider: command.provider,
-      sessionEntry,
-    });
-    const queueKey = sessionKey ?? sessionEntry?.sessionId;
-    const queueDepth = queueKey ? getFollowupQueueDepth(queueKey) : 0;
-    const queueOverrides = Boolean(
-      sessionEntry?.queueDebounceMs ??
-        sessionEntry?.queueCap ??
-        sessionEntry?.queueDrop,
-    );
-    const groupActivation = isGroup
-      ? (normalizeGroupActivation(sessionEntry?.groupActivation) ??
-        defaultGroupActivation())
-      : undefined;
-    const statusText = buildStatusMessage({
-      agent: {
-        ...cfg.agent,
-        model: {
-          ...cfg.agent?.model,
-          primary: `${provider}/${model}`,
-        },
-        contextTokens,
-        thinkingDefault: cfg.agent?.thinkingDefault,
-        verboseDefault: cfg.agent?.verboseDefault,
-        elevatedDefault: cfg.agent?.elevatedDefault,
-      },
+      command,
      sessionEntry,
      sessionKey,
      sessionScope,
-      groupActivation,
-      resolvedThink:
-        resolvedThinkLevel ?? (await resolveDefaultThinkingLevel()),
-      resolvedVerbose: resolvedVerboseLevel,
-      resolvedReasoning: resolvedReasoningLevel,
-      resolvedElevated: resolvedElevatedLevel,
-      modelAuth: resolveModelAuthLabel(provider, cfg),
-      usageLine: usageLine ?? undefined,
-      queue: {
-        mode: queueSettings.mode,
-        depth: queueDepth,
-        debounceMs: queueSettings.debounceMs,
-        cap: queueSettings.cap,
-        dropPolicy: queueSettings.dropPolicy,
-        showDetails: queueOverrides,
-      },
-      includeTranscriptUsage: false,
+      provider,
+      model,
+      contextTokens,
+      resolvedThinkLevel,
+      resolvedVerboseLevel,
+      resolvedReasoningLevel,
+      resolvedElevatedLevel,
+      resolveDefaultThinkingLevel,
+      isGroup,
+      defaultGroupActivation,
    });
-    return { shouldContinue: false, reply: { text: statusText } };
+    return { shouldContinue: false, reply };
  }

  const stopRequested = command.commandBodyNormalized === "/stop";
--- a/src/auto-reply/reply/directive-handling.ts
+++ b/src/auto-reply/reply/directive-handling.ts
@@ -24,7 +24,12 @@ import {
  resolveModelRefFromString,
 } from "../../agents/model-selection.js";
 import type { ClawdbotConfig } from "../../config/config.js";
-import { type SessionEntry, saveSessionStore } from "../../config/sessions.js";
+import {
+  resolveAgentIdFromSessionKey,
+  resolveAgentMainSessionKey,
+  type SessionEntry,
+  saveSessionStore,
+} from "../../config/sessions.js";
 import { enqueueSystemEvent } from "../../infra/system-events.js";
 import { shortenHomePath } from "../../utils.js";
 import { extractModelDirective } from "../model.js";
@@ -57,6 +62,8 @@ const SYSTEM_MARK = "⚙️";
 const formatOptionsLine = (options: string) => `Options: ${options}.`;
 const withOptions = (line: string, options: string) =>
  `${line}\n${formatOptionsLine(options)}`;
+const formatElevatedRuntimeHint = () =>
+  `${SYSTEM_MARK} Runtime is direct; sandboxing does not apply.`;

 const maskApiKey = (value: string): string => {
  const trimmed = value.trim();
@@ -350,6 +357,21 @@ export async function handleDirectiveOnly(params: {
    currentReasoningLevel,
    currentElevatedLevel,
  } = params;
+  const runtimeIsSandboxed = (() => {
+    const sandboxMode = params.cfg.agent?.sandbox?.mode ?? "off";
+    if (sandboxMode === "off") return false;
+    const sessionKey = params.sessionKey?.trim();
+    if (!sessionKey) return false;
+    const agentId = resolveAgentIdFromSessionKey(sessionKey);
+    const mainKey = resolveAgentMainSessionKey({
+      cfg: params.cfg,
+      agentId,
+    });
+    if (sandboxMode === "all") return true;
+    return sessionKey !== mainKey;
+  })();
+  const shouldHintDirectRuntime =
+    directives.hasElevatedDirective && !runtimeIsSandboxed;

  if (directives.hasModelDirective) {
    const modelDirective = directives.rawModelDirective?.trim().toLowerCase();
@@ -463,7 +485,12 @@ export async function handleDirectiveOnly(params: {
      }
      const level = currentElevatedLevel ?? "off";
      return {
-        text: withOptions(`Current elevated level: ${level}.`, "on, off"),
+        text: [
+          withOptions(`Current elevated level: ${level}.`, "on, off"),
+          shouldHintDirectRuntime ? formatElevatedRuntimeHint() : null,
+        ]
+          .filter(Boolean)
+          .join("\n"),
      };
    }
    return {
@@ -681,6 +708,7 @@ export async function handleDirectiveOnly(params: {
        ? `${SYSTEM_MARK} Elevated mode disabled.`
        : `${SYSTEM_MARK} Elevated mode enabled.`,
    );
+    if (shouldHintDirectRuntime) parts.push(formatElevatedRuntimeHint());
  }
  if (modelSelection) {
    const label = `${modelSelection.provider}/${modelSelection.model}`;
@@ -716,6 +744,7 @@ export async function handleDirectiveOnly(params: {
    parts.push(`${SYSTEM_MARK} Queue drop set to ${directives.dropPolicy}.`);
  }
  const ack = parts.join(" ").trim();
+  if (!ack && directives.hasStatusDirective) return undefined;
  return { text: ack || "OK." };
 }

--- a/src/auto-reply/reply/session.ts
+++ b/src/auto-reply/reply/session.ts
@@ -194,6 +194,7 @@ export async function initSessionState(params: {
    // Persist previously stored thinking/verbose levels when present.
    thinkingLevel: persistedThinking ?? baseEntry?.thinkingLevel,
    verboseLevel: persistedVerbose ?? baseEntry?.verboseLevel,
+    responseUsage: baseEntry?.responseUsage,
    modelOverride: persistedModelOverride ?? baseEntry?.modelOverride,
    providerOverride: persistedProviderOverride ?? baseEntry?.providerOverride,
    sendPolicy: baseEntry?.sendPolicy,