niahere 0.5.1 → 0.5.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "niahere",
-  "version": "0.5.1",
+  "version": "0.5.3",
   "description": "A personal AI assistant daemon — chat, scheduled jobs, persona system, extensible via skills.",
   "type": "module",
   "scripts": {
@@ -44,9 +44,9 @@
   "license": "MIT",
   "private": false,
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "^0.3.190",
-    "@anthropic-ai/sdk": "^0.105.0",
-    "@modelcontextprotocol/sdk": "^1.29.0",
+    "@anthropic-ai/claude-agent-sdk": "0.3.220",
+    "@anthropic-ai/sdk": "0.115.0",
+    "@modelcontextprotocol/sdk": "1.30.0",
     "@slack/bolt": "^4.6.0",
     "cron-parser": "^5.5.0",
     "grammy": "^1.41.1",

package/src/agent/backends/claude-normalize.ts

@@ -1,6 +1,36 @@
 import type { AgentEvent, Normalizer } from "../types";
 import { truncate } from "../../utils/format-activity";
 import { isRetryable, scopeOf, parseFailure } from "../failure";
+import type { FailoverScope } from "../types";
+
+/**
+ * Terminal reasons that mean the turn died. The SDK used to report several of
+ * these as `completed`, so a dead turn landed in the audit as a successful run.
+ * The value is how far the chain should skip; undefined means stop.
+ */
+const DEAD_TURNS: Record<string, FailoverScope | undefined> = {
+  api_error: "provider",
+  budget_exhausted: undefined,
+  malformed_tool_use_exhausted: undefined,
+  structured_output_retry_exhausted: undefined,
+  tool_deferred_unavailable: undefined,
+  turn_setup_failed: undefined,
+};
+
+/**
+ * Stamp the chain's provider over the SDK's own, which names the deployment
+ * target (firstParty/bedrock/vertex) — a different axis from which backend ran
+ * the turn, and the one `providers_used` has to answer.
+ */
+function attribute(modelUsage: unknown): Record<string, unknown> | undefined {
+  if (!modelUsage || typeof modelUsage !== "object") return undefined;
+  return Object.fromEntries(
+    Object.entries(modelUsage as Record<string, unknown>).map(([model, usage]) => [
+      model,
+      { ...(usage as object), provider: "claude" },
+    ]),
+  );
+}
 
 /**
  * Pure reducer: Claude Agent SDK messages → normalized `AgentEvent`s.
@@ -41,6 +71,17 @@ export class SdkNormalizer implements Normalizer {
       return [];
     }
 
+    if (msg.type === "system" && msg.subtype === "compact_boundary") {
+      // Long sessions compact silently; surface it so the transcript records
+      // that history was summarized and how much was dropped.
+      const meta = msg.compact_metadata ?? {};
+      const trigger = meta.trigger === "manual" ? "manual" : "auto";
+      const pre = meta.pre_tokens ?? 0;
+      const post = meta.post_tokens;
+      const shrink = post !== undefined ? `${pre} → ${post} tokens` : `${pre} tokens`;
+      return [{ type: "thinking", delta: `context compacted (${trigger}, ${shrink})` }];
+    }
+
     if (msg.type === "system") {
       // Subagent/task lifecycle (subtype init handled above).
       if (msg.subtype === "task_started" && msg.description) {
@@ -98,6 +139,16 @@ export class SdkNormalizer implements Normalizer {
   }
 
   private consumeResult(msg: any): AgentEvent {
+    const deadTurn = msg.terminal_reason as string | undefined;
+    if (!msg.is_error && deadTurn && deadTurn in DEAD_TURNS) {
+      return {
+        type: "error",
+        message: (msg.errors?.join(", ") as string) || `turn ended: ${deadTurn}`,
+        retryable: false,
+        failover: DEAD_TURNS[deadTurn],
+        terminalReason: deadTurn,
+      };
+    }
     if (!msg.is_error) {
       return {
         type: "result",
@@ -115,7 +166,7 @@ export class SdkNormalizer implements Normalizer {
           session_id: msg.session_id,
           subtype: msg.subtype,
           usage: msg.usage,
-          model_usage: msg.modelUsage,
+          model_usage: attribute(msg.modelUsage),
         },
       };
     }
@@ -126,7 +177,11 @@ export class SdkNormalizer implements Normalizer {
       type: "error",
       message: raw,
       retryable: isRetryable(raw),
-      failover: scopeOf(parseFailure(raw), "provider"),
+      // api_error_status is the reliable signal; prose is the fallback.
+      failover: scopeOf(
+        { ...parseFailure(raw), status: typeof msg.api_error_status === "number" ? msg.api_error_status : undefined },
+        "provider",
+      ),
       terminalReason: msg.terminal_reason,
     };
   }

package/src/agent/backends/codex-normalize.ts

@@ -14,6 +14,10 @@ import { scopeOf, parseFailure } from "../failure";
  * skill budget) and are dropped.
  */
 export class CodexNormalizer implements Normalizer {
+  /** The model this run was launched on, for usage attribution — codex's own
+   *  events don't name it. */
+  constructor(private readonly model?: string) {}
+
   private threadId = "";
   private agentText = "";
   private failed = false;
@@ -35,20 +39,37 @@ export class CodexNormalizer implements Normalizer {
         return this.fail(typeof e.message === "string" ? e.message : "");
       case "turn.failed":
         return this.fail(typeof e.error?.message === "string" ? e.error.message : "");
-      case "turn.completed":
+      case "turn.completed": {
+        // Codex counts like OpenAI: `input_tokens` is the whole prompt with
+        // `cached_input_tokens` a slice of it. Claude reports the two as
+        // siblings and one accumulator sums both, so the slice comes out here.
+        const cacheRead = e.usage?.cached_input_tokens ?? 0;
+        const input = Math.max(0, (e.usage?.input_tokens ?? 0) - cacheRead);
+        const output = e.usage?.output_tokens ?? 0;
         return [
           {
             type: "result",
             text: this.agentText,
-            usage: {
-              tokens: {
-                input: e.usage?.input_tokens ?? 0,
-                output: e.usage?.output_tokens ?? 0,
+            usage: { tokens: { input, output } },
+            backendSessionId: this.threadId,
+            // Same shape the Claude path emits, so one accumulator serves both
+            // and a failed-over turn is attributable to the provider that ran it.
+            // No cost: codex reports none, and an invented zero would read as a
+            // free turn.
+            metadata: {
+              model_usage: {
+                [this.model || "default"]: {
+                  provider: "codex",
+                  inputTokens: input,
+                  outputTokens: output,
+                  cacheReadInputTokens: cacheRead,
+                  cacheCreationInputTokens: e.usage?.cache_write_input_tokens ?? 0,
+                },
               },
             },
-            backendSessionId: this.threadId,
           },
         ];
+      }
       default:
         return [];
     }

package/src/agent/backends/codex.ts

@@ -201,7 +201,7 @@ class CodexSession implements AgentSession {
     // Started now, not after exit: an undrained pipe blocks the child.
     const stderr = drainStderr(proc.stderr);
 
-    const normalizer = new CodexNormalizer();
+    const normalizer = new CodexNormalizer(this.ctx.model);
     const stdout = proc.stdout.getReader();
     const lines = readLines(stdout)[Symbol.asyncIterator]();
     let sawTerminal = false;

package/src/agent/failure.ts

@@ -82,8 +82,10 @@ function scopeOfStatus(status: number, message: string): FailoverScope | undefin
  */
 export function scopeOf(failure: Failure, blank?: FailoverScope): FailoverScope | undefined {
   const t = failure.message.trim();
-  if (!t || t.toLowerCase() === "unknown error") return blank;
+  // A status is authoritative even when the message is empty — the prose that
+  // accompanies a 429 or 529 is routinely unhelpful.
   if (failure.status !== undefined) return scopeOfStatus(failure.status, t);
+  if (!t || t.toLowerCase() === "unknown error") return blank;
   if (MODEL_SCOPED.some((p) => p.test(t))) return "model";
   if (PROVIDER_SCOPED.some((p) => p.test(t))) return "provider";
   return undefined;

package/src/chat/engine.ts

@@ -323,7 +323,11 @@ export async function createChatEngine(opts: EngineOptions): Promise<ChatEngine>
                   };
                   try {
                     messageId = await Message.save(saveParams);
-                  } catch {
+                  } catch (e) {
+                    // Saving the reply matters more than saving its usage, but a
+                    // silent drop cost eight days of the ledger before anyone
+                    // looked.
+                    log.error({ room, error: errMsg(e) }, "dropping turn metadata; message saved without it");
                     messageId = await Message.save({ ...saveParams, metadata: undefined });
                   }
                   await Session.touch(sessionId);

package/src/cli/index.ts

@@ -203,6 +203,12 @@ switch (command) {
     break;
   }
 
+  case "usage": {
+    const { usageCommand } = await import("./usage");
+    await usageCommand(process.argv.slice(3));
+    break;
+  }
+
   case "seed": {
     await import("../db/seed");
     break;
@@ -337,6 +343,7 @@ Daemon:
   model [name]                    Show or set global Claude model
   health                          Check daemon, db, channels, config
   logs [-f] [--channel ch]        Daemon logs (filter by channel)
+  usage [--days N --by dim --room R --json]  Tokens and cost per day/model/provider/room
 
 Chat:
   chat [-c] [-r] [--employee|--agent|--job name]  Interactive chat

package/src/cli/usage.ts

@@ -0,0 +1,189 @@
+import { withDb } from "../db/with-db";
+import { queryUsage, type UsageRow } from "../db/models/usage";
+import { getConfig } from "../utils/config";
+import { BOLD, DIM, RESET, fail } from "../utils/cli";
+import { errMsg } from "../utils/errors";
+
+export type Dimension = "day" | "model" | "provider" | "room";
+
+const DIMENSIONS: Dimension[] = ["day", "model", "provider", "room"];
+
+export interface UsageOptions {
+  days: number;
+  by: Dimension;
+  room?: string;
+  json: boolean;
+}
+
+export interface UsageBucket {
+  key: string;
+  inputTokens: number;
+  outputTokens: number;
+  cacheReadTokens: number;
+  cacheWriteTokens: number;
+  /** null when nothing in the bucket carried a cost. */
+  costUsd: number | null;
+  turns: number;
+  unpricedTurns: number;
+}
+
+export function parseUsageArgs(argv: string[]): UsageOptions {
+  const opts: UsageOptions = { days: 7, by: "day", json: false };
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i]!;
+    const value = argv[i + 1];
+    if (arg === "--json") {
+      opts.json = true;
+    } else if (arg === "--days" && value) {
+      const parsed = Number.parseInt(value, 10);
+      if (Number.isInteger(parsed) && parsed > 0) opts.days = parsed;
+      i += 1;
+    } else if (arg === "--by" && value) {
+      if (!DIMENSIONS.includes(value as Dimension)) throw new Error(`--by must be one of: ${DIMENSIONS.join(", ")}`);
+      opts.by = value as Dimension;
+      i += 1;
+    } else if (arg === "--room" && value) {
+      opts.room = value;
+      i += 1;
+    }
+  }
+  return opts;
+}
+
+export function rollup(rows: UsageRow[], by: Dimension): UsageBucket[] {
+  const byKey = new Map<string, UsageBucket>();
+  for (const row of rows) {
+    const key = row[by];
+    const seen = byKey.get(key);
+    if (!seen) {
+      byKey.set(key, {
+        key,
+        inputTokens: row.inputTokens,
+        outputTokens: row.outputTokens,
+        cacheReadTokens: row.cacheReadTokens,
+        cacheWriteTokens: row.cacheWriteTokens,
+        costUsd: row.costUsd,
+        turns: row.turns,
+        unpricedTurns: row.unpricedTurns,
+      });
+      continue;
+    }
+    seen.inputTokens += row.inputTokens;
+    seen.outputTokens += row.outputTokens;
+    seen.cacheReadTokens += row.cacheReadTokens;
+    seen.cacheWriteTokens += row.cacheWriteTokens;
+    seen.turns += row.turns;
+    seen.unpricedTurns += row.unpricedTurns;
+    // A known cost survives an unknown one beside it; only an all-unknown
+    // bucket reports nothing.
+    seen.costUsd = seen.costUsd === null && row.costUsd === null ? null : (seen.costUsd ?? 0) + (row.costUsd ?? 0);
+  }
+
+  const buckets = [...byKey.values()];
+  return by === "day"
+    ? buckets.sort((a, b) => a.key.localeCompare(b.key))
+    : buckets.sort((a, b) => (b.costUsd ?? 0) - (a.costUsd ?? 0) || b.turns - a.turns);
+}
+
+export function compactTokens(n: number): string {
+  if (n >= 1_000_000) return `${round(n / 1_000_000)}M`;
+  if (n >= 1_000) return `${round(n / 1_000)}K`;
+  return String(n);
+}
+
+function round(n: number): string {
+  return n.toFixed(1).replace(/\.0$/, "");
+}
+
+export function formatCost(cost: number | null): string {
+  if (cost === null) return "—";
+  // Sub-cent turns are common; rounding them to $0.00 hides real spend.
+  return cost > 0 && cost < 0.01 ? `$${cost.toFixed(4)}` : `$${cost.toFixed(2)}`;
+}
+
+const COLUMNS: [string, (b: UsageBucket) => string][] = [
+  ["Turns", (b) => String(b.turns)],
+  ["Input", (b) => compactTokens(b.inputTokens)],
+  ["Output", (b) => compactTokens(b.outputTokens)],
+  ["Cache rd", (b) => compactTokens(b.cacheReadTokens)],
+  ["Cache wr", (b) => compactTokens(b.cacheWriteTokens)],
+  ["Cost", (b) => formatCost(b.costUsd)],
+];
+
+export function renderTable(buckets: UsageBucket[], label: string): string[] {
+  const header = [label, ...COLUMNS.map(([name]) => name)];
+  const body = buckets.map((b) => [b.key, ...COLUMNS.map(([, read]) => read(b))]);
+  const total = buckets.reduce<UsageBucket>((sum, b) => {
+    sum.inputTokens += b.inputTokens;
+    sum.outputTokens += b.outputTokens;
+    sum.cacheReadTokens += b.cacheReadTokens;
+    sum.cacheWriteTokens += b.cacheWriteTokens;
+    sum.turns += b.turns;
+    sum.unpricedTurns += b.unpricedTurns;
+    sum.costUsd = sum.costUsd === null && b.costUsd === null ? null : (sum.costUsd ?? 0) + (b.costUsd ?? 0);
+    return sum;
+  }, emptyBucket("Total"));
+
+  const rows = [header, ...body, [total.key, ...COLUMNS.map(([, read]) => read(total))]];
+  const widths = header.map((_, col) => Math.max(...rows.map((r) => r[col]!.length)));
+  const line = (cells: string[]) =>
+    cells.map((cell, col) => (col === 0 ? cell.padEnd(widths[col]!) : cell.padStart(widths[col]!))).join("  ");
+
+  const out = [`${BOLD}${line(header)}${RESET}`, ...body.map(line), `${BOLD}${line(rows.at(-1)!)}${RESET}`];
+  if (total.unpricedTurns > 0) {
+    out.push(`${DIM}${total.unpricedTurns} of ${total.turns} turns report no cost (codex bills no per-token price)${RESET}`);
+  }
+  return out;
+}
+
+function emptyBucket(key: string): UsageBucket {
+  return {
+    key,
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheReadTokens: 0,
+    cacheWriteTokens: 0,
+    costUsd: null,
+    turns: 0,
+    unpricedTurns: 0,
+  };
+}
+
+export async function usageCommand(argv: string[]): Promise<void> {
+  let opts: UsageOptions;
+  try {
+    opts = parseUsageArgs(argv);
+  } catch (e) {
+    fail(errMsg(e));
+  }
+  const since = new Date(Date.now() - opts.days * 24 * 60 * 60 * 1000);
+  const timezone = getConfig().timezone || "UTC";
+
+  const rows = await withDb(() =>
+    queryUsage({ since, ...(opts.room !== undefined ? { room: opts.room } : {}), timezone }),
+  );
+
+  if (opts.json) {
+    console.log(JSON.stringify({ since: since.toISOString(), timezone, rows }, null, 2));
+    return;
+  }
+
+  if (rows.length === 0) {
+    console.log(`No recorded usage in the last ${opts.days} days${opts.room ? ` for ${opts.room}` : ""}.`);
+    return;
+  }
+
+  const scope = opts.room ? ` · ${opts.room}` : "";
+  console.log(`\nUsage — last ${opts.days} days${scope} (${timezone})\n`);
+  for (const line of renderTable(rollup(rows, opts.by), title(opts.by))) console.log(line);
+
+  if (opts.by === "day") {
+    console.log("\nBy model");
+    for (const line of renderTable(rollup(rows, "model"), "Model")) console.log(`  ${line}`);
+  }
+  console.log();
+}
+
+function title(by: Dimension): string {
+  return by === "day" ? "Day" : by[0]!.toUpperCase() + by.slice(1);
+}

package/src/db/models/session.ts

@@ -122,30 +122,74 @@ export async function getRecentSummaries(
   }));
 }
 
+export interface UsageTotals {
+  inputTokens: number;
+  outputTokens: number;
+  cacheReadTokens: number;
+  cacheCreationTokens: number;
+  models: string[];
+  providers: string[];
+}
+
+const num = (v: unknown): number => (typeof v === "number" && Number.isFinite(v) ? v : 0);
+const str = (v: unknown): string | null => (typeof v === "string" && v ? v : null);
+
+/**
+ * Fold a result's per-model usage into totals. `provider` matters because a
+ * chain that fails over makes the model name alone ambiguous about who served
+ * the turn.
+ */
+export function summarizeModelUsage(modelUsage: unknown): UsageTotals {
+  const totals: UsageTotals = {
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheReadTokens: 0,
+    cacheCreationTokens: 0,
+    models: [],
+    providers: [],
+  };
+  if (!modelUsage || typeof modelUsage !== "object") return totals;
+
+  const models = new Set<string>();
+  const providers = new Set<string>();
+  for (const [key, raw] of Object.entries(modelUsage as Record<string, unknown>)) {
+    const usage = (raw && typeof raw === "object" ? raw : {}) as Record<string, unknown>;
+    models.add(str(usage.canonicalModel) ?? key);
+    const provider = str(usage.provider);
+    if (provider) providers.add(provider);
+    totals.inputTokens += num(usage.inputTokens);
+    totals.outputTokens += num(usage.outputTokens);
+    totals.cacheReadTokens += num(usage.cacheReadInputTokens);
+    totals.cacheCreationTokens += num(usage.cacheCreationInputTokens);
+  }
+  totals.models = [...models];
+  totals.providers = [...providers];
+  return totals;
+}
+
 export async function accumulateMetadata(id: string, resultMeta: Record<string, unknown>): Promise<void> {
   const sql = getSql();
 
-  const modelUsage = resultMeta.model_usage as Record<string, Record<string, number>> | undefined;
-  let inputTokens = 0;
-  let outputTokens = 0;
-  let cacheReadTokens = 0;
-  let cacheCreationTokens = 0;
-  const newModels: string[] = [];
-  if (modelUsage) {
-    for (const [model, usage] of Object.entries(modelUsage)) {
-      newModels.push(model);
-      inputTokens += usage.inputTokens || 0;
-      outputTokens += usage.outputTokens || 0;
-      cacheReadTokens += usage.cacheReadInputTokens || 0;
-      cacheCreationTokens += usage.cacheCreationInputTokens || 0;
-    }
-  }
+  const {
+    inputTokens,
+    outputTokens,
+    cacheReadTokens,
+    cacheCreationTokens,
+    models: newModels,
+    providers: newProviders,
+  } = summarizeModelUsage(resultMeta.model_usage);
 
   // Bind deltas as jsonb via sql.json — pre-stringifying would store a
   // double-encoded string scalar, making every `->>` extraction return NULL
   // and silently zeroing all accumulated totals.
+  // Codex reports tokens but no cost. Folding that in as $0 would make a
+  // session that failed over look cheaper than one that never left Claude, so
+  // the unknown is counted rather than absorbed.
+  const priced = typeof resultMeta.cost_usd === "number";
+
   const delta = sql.json({
     total_cost_usd: (resultMeta.cost_usd as number) || 0,
+    unpriced_turns: priced ? 0 : 1,
     total_turns: (resultMeta.turns as number) || 0,
     total_duration_ms: (resultMeta.duration_ms as number) || 0,
     total_duration_api_ms: (resultMeta.duration_api_ms as number) || 0,
@@ -155,14 +199,17 @@ export async function accumulateMetadata(id: string, resultMeta: Record<string,
     total_cache_creation_tokens: cacheCreationTokens,
     message_count: 1,
     models_used: newModels,
+    providers_used: newProviders,
     channel: (resultMeta.channel as string) || null,
   });
   const modelsDelta = sql.json(newModels);
+  const providersDelta = sql.json(newProviders);
 
   // Atomic accumulate — no read-then-write race
   await sql`
     UPDATE sessions SET metadata = jsonb_build_object(
       'total_cost_usd',              COALESCE((metadata->>'total_cost_usd')::real, 0)              + (${delta}->>'total_cost_usd')::real,
+      'unpriced_turns',               COALESCE((metadata->>'unpriced_turns')::int, 0)               + (${delta}->>'unpriced_turns')::int,
       'total_turns',                  COALESCE((metadata->>'total_turns')::int, 0)                  + (${delta}->>'total_turns')::int,
       'total_duration_ms',            COALESCE((metadata->>'total_duration_ms')::real, 0)            + (${delta}->>'total_duration_ms')::real,
       'total_duration_api_ms',        COALESCE((metadata->>'total_duration_api_ms')::real, 0)        + (${delta}->>'total_duration_api_ms')::real,
@@ -173,6 +220,8 @@ export async function accumulateMetadata(id: string, resultMeta: Record<string,
       'message_count',                COALESCE((metadata->>'message_count')::int, 0)                 + 1,
       'models_used',                  (SELECT COALESCE(jsonb_agg(DISTINCT e), '[]'::jsonb)
                                          FROM jsonb_array_elements(COALESCE(metadata->'models_used', '[]'::jsonb) || ${modelsDelta}) AS e),
+      'providers_used',               (SELECT COALESCE(jsonb_agg(DISTINCT e), '[]'::jsonb)
+                                         FROM jsonb_array_elements(COALESCE(metadata->'providers_used', '[]'::jsonb) || ${providersDelta}) AS e),
       'channel',                      COALESCE(metadata->>'channel', ${(resultMeta.channel as string) || null})
     )
     WHERE id = ${id}