niahere 0.5.1 → 0.5.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "niahere",
-  "version": "0.5.1",
+  "version": "0.5.2",
   "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,21 @@
 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,
+};
 
 /**
  * Pure reducer: Claude Agent SDK messages → normalized `AgentEvent`s.
@@ -41,6 +56,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 +124,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",
@@ -126,7 +162,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,30 @@ 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": {
+        const input = e.usage?.input_tokens ?? 0;
+        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.
+            metadata: {
+              model_usage: {
+                [this.model || "default"]: {
+                  provider: "codex",
+                  inputTokens: input,
+                  outputTokens: output,
+                  cacheReadInputTokens: e.usage?.cached_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/db/models/session.ts

@@ -122,24 +122,62 @@ 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
@@ -155,9 +193,11 @@ 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`
@@ -173,6 +213,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}