niahere 0.4.6 → 0.5.1

package/src/db/models/message.ts

@@ -46,6 +46,16 @@ export async function getRecent(limit = 20, room?: string): Promise<RecentMessag
   }));
 }
 
+/** When the room last saw any message. Null for a room with no history. */
+export async function getLastAt(room: string): Promise<Date | null> {
+  const sql = getSql();
+  const rows = await sql`
+    SELECT created_at FROM messages WHERE room = ${room}
+    ORDER BY created_at DESC LIMIT 1
+  `;
+  return rows.length > 0 ? new Date(rows[0].created_at) : null;
+}
+
 export async function search(query: string, limit = 20, room?: string): Promise<SearchResult[]> {
   const sql = getSql();
   const pattern = `%${query}%`;

package/src/db/models/session.ts

@@ -192,3 +192,15 @@ export async function getLatestRoomIndex(prefix: string): Promise<number> {
   }
   return max;
 }
+
+/** How many messages of this session the consolidator has already read. */
+export async function getConsolidatedCount(sessionId: string): Promise<number> {
+  const sql = getSql();
+  const rows = await sql`SELECT consolidated_count FROM sessions WHERE id = ${sessionId}`;
+  return rows.length > 0 ? Number(rows[0].consolidated_count ?? 0) : 0;
+}
+
+export async function setConsolidatedCount(sessionId: string, count: number): Promise<void> {
+  const sql = getSql();
+  await sql`UPDATE sessions SET consolidated_count = ${count} WHERE id = ${sessionId}`;
+}

package/src/mcp/gate.ts

@@ -0,0 +1,46 @@
+import type { NiaTool } from "./tools/types";
+import { log } from "../utils/log";
+
+/**
+ * Per-run budget for tools with real-world consequences.
+ *
+ * The CLI backends run with their own approvals bypassed, and that flag governs
+ * only their built-ins (shell, file writes) — nothing upstream of Nia limits how
+ * often an agent may dial a phone or message the owner. Wrapping the table at
+ * the point each per-run server is built puts one cap in front of every
+ * backend, in-process Claude included.
+ *
+ * These are runaway stops, not permission checks: a looping agent burns its
+ * budget and is told no, while a run doing the job it was asked to do never
+ * reaches them.
+ */
+export const SIDE_EFFECT_LIMITS: Record<string, number> = {
+  place_call: 3,
+  send_message: 25,
+};
+
+/**
+ * Wrap side-effect tools with a budget. Call once per run — the counters live in
+ * the returned closures, so two concurrent runs cannot spend each other's.
+ */
+export function gateSideEffects(tools: NiaTool[]): NiaTool[] {
+  const used = new Map<string, number>();
+
+  return tools.map((t) => {
+    const limit = SIDE_EFFECT_LIMITS[t.name];
+    if (limit === undefined) return t;
+
+    return {
+      ...t,
+      handler: async (args: any, ctx) => {
+        const spent = used.get(t.name) ?? 0;
+        if (spent >= limit) {
+          log.warn({ tool: t.name, limit }, "side-effect tool budget exhausted for this run");
+          return `Refused: ${t.name} has already run ${limit} times in this run, which is its limit. Ask the owner if you genuinely need more.`;
+        }
+        used.set(t.name, spent + 1);
+        return t.handler(args, ctx);
+      },
+    };
+  });
+}

package/src/mcp/server.ts

@@ -1,5 +1,6 @@
 import { createSdkMcpServer, tool } from "@anthropic-ai/claude-agent-sdk";
 import { NIA_TOOLS } from "./tools/table";
+import { gateSideEffects } from "./gate";
 import type { McpSourceContext } from "./index";
 
 /**
@@ -11,7 +12,7 @@ export function createNiaMcpServer(sourceCtx?: McpSourceContext) {
   return createSdkMcpServer({
     name: "nia",
     version: "0.1.0",
-    tools: NIA_TOOLS.map((t) =>
+    tools: gateSideEffects(NIA_TOOLS).map((t) =>
       tool(t.name, t.description, t.schema, async (args: unknown) => ({
         content: [{ type: "text" as const, text: await t.handler(args, sourceCtx) }],
       })),

package/src/mcp/tools/misc.ts

@@ -1,4 +1,5 @@
 import { appendFileSync } from "fs";
+import { errMsg } from "../../utils/errors";
 import { join } from "path";
 import { getPaths } from "../../utils/paths";
 import { scanAgents } from "../../core/agents";
@@ -58,6 +59,6 @@ export async function placeCall(args: {
     });
     return `Call placed. callSid=${result.callSid} status=${result.status}. Transcript will land in messages once the call completes.`;
   } catch (err) {
-    return `place_call failed: ${err instanceof Error ? err.message : String(err)}`;
+    return `place_call failed: ${errMsg(err)}`;
   }
 }

package/src/mcp/tools/send.ts

@@ -5,6 +5,7 @@ import { Message, Session } from "../../db/models";
 import { getConfig } from "../../utils/config";
 import { getChannel } from "../../channels/registry";
 import { log } from "../../utils/log";
+import { errMsg, ignore } from "../../utils/errors";
 import type { Recipient } from "../../types";
 import type { McpSourceContext } from "../index";
 
@@ -168,7 +169,7 @@ export async function sendMessage(
     let media: { data: Uint8Array; mimeType: string; filename: string } | undefined;
     if (mediaPath) {
       if (!existsSync(mediaPath)) {
-        if (messageId) await Message.updateDeliveryStatus(messageId, "failed").catch(() => {});
+        if (messageId) await ignore(Message.updateDeliveryStatus(messageId, "failed"), "record failed delivery status");
         return `Failed to send: file not found: ${mediaPath}`;
       }
       const buf = readFileSync(mediaPath);
@@ -190,13 +191,13 @@ export async function sendMessage(
 
     // Mark as sent
     if (messageId) {
-      await Message.updateDeliveryStatus(messageId, "sent").catch(() => {});
+      await ignore(Message.updateDeliveryStatus(messageId, "sent"), "record sent delivery status");
     }
 
     return mediaPath ? "Message with media sent." : "Message sent.";
   } catch (err) {
-    if (messageId) await Message.updateDeliveryStatus(messageId, "failed").catch(() => {});
-    const errText = err instanceof Error ? err.message : String(err);
+    if (messageId) await ignore(Message.updateDeliveryStatus(messageId, "failed"), "record failed delivery status");
+    const errText = errMsg(err);
     return `Failed to send: ${errText}`;
   }
 }

package/src/types/config.ts

@@ -103,11 +103,11 @@ export interface SessionFinalizationConfig {
 export type BackendName = "claude" | "codex" | "gemini";
 
 export interface Config {
+  /** The primary model. Its provider is derived from the name — config never
+   *  names a backend directly. */
   model: string;
-  /** The primary backend for jobs and chat. */
-  runner: BackendName;
-  /** Ordered fallback backends, tried when the primary is provider-down. */
-  fallback: BackendName[];
+  /** Ordered fallback models, tried when the one before them cannot serve. */
+  fallback_models: string[];
   timezone: string;
   activeHours: { start: string; end: string };
   database_url: string;

package/src/utils/config.ts

@@ -10,8 +10,7 @@ const TIME_RE = /^\d{2}:\d{2}$/;
 
 const DEFAULTS: Config = {
   model: "default",
-  runner: "claude",
-  fallback: [],
+  fallback_models: [],
   timezone: process.env.TZ || Intl.DateTimeFormat().resolvedOptions().timeZone,
   activeHours: { start: "00:00", end: "23:59" },
   database_url: DEFAULT_DATABASE_URL,
@@ -96,10 +95,10 @@ export function loadConfig(): Config {
   // Model
   const model = typeof raw.model === "string" ? raw.model : DEFAULTS.model;
 
-  // Backends — primary "runner" + ordered "fallback" chain for provider-down failover.
-  const isBackend = (v: unknown): v is Config["runner"] => v === "claude" || v === "codex" || v === "gemini";
-  const runner: Config["runner"] = isBackend(raw.runner) ? raw.runner : DEFAULTS.runner;
-  const fallback: Config["fallback"] = Array.isArray(raw.fallback) ? raw.fallback.filter(isBackend) : DEFAULTS.fallback;
+  // Ordered fallback models; each one's provider is derived from its name.
+  const fallback_models = Array.isArray(raw.fallback_models)
+    ? raw.fallback_models.filter((m): m is string => typeof m === "string" && m.trim().length > 0)
+    : DEFAULTS.fallback_models;
 
   // Timezone
   let timezone = DEFAULTS.timezone;
@@ -252,8 +251,7 @@ export function loadConfig(): Config {
 
   return {
     model,
-    runner,
-    fallback,
+    fallback_models,
     timezone,
     activeHours: { start, end },
     database_url,

package/src/utils/errors.ts

@@ -1,4 +1,30 @@
+import { log } from "./log";
+
 /** Extract a human-readable message from an unknown error value. */
 export function errMsg(err: unknown): string {
   return err instanceof Error ? err.message : String(err);
 }
+
+/** Normalize an unknown to an Error, keeping the original when it already is one
+ *  so its stack survives a rethrow. */
+export function asError(err: unknown): Error {
+  return err instanceof Error ? err : new Error(errMsg(err));
+}
+
+type Report = (context: string, err: string) => void;
+
+const report: Report = (context, err) => log.debug({ err }, `ignored failure: ${context}`);
+
+/**
+ * Await best-effort work whose failure must not stop the caller — cleanup,
+ * bookkeeping, teardown. Use instead of `.catch(() => {})`: the outcome is the
+ * same, but a failure leaves a trace rather than vanishing, so a persistent one
+ * is discoverable instead of silent.
+ */
+export async function ignore(work: Promise<unknown>, context: string, onError: Report = report): Promise<void> {
+  try {
+    await work;
+  } catch (err) {
+    onError(context, errMsg(err));
+  }
+}

package/src/utils/retry.ts

@@ -14,51 +14,6 @@ export async function withRetry<T>(fn: () => Promise<T>, retries = 3): Promise<T
   throw new Error("unreachable"); // satisfies TS return type
 }
 
-const RETRYABLE_PATTERNS = [/\b500\b/i, /internal server error/i, /overloaded/i, /529/, /rate limit/i];
-
-/** Check if an error string from the Claude API looks transient/retryable. */
-export function isRetryableApiError(error: string): boolean {
-  return RETRYABLE_PATTERNS.some((p) => p.test(error));
-}
-
-/**
- * A blank or opaque ("unknown error") failure means the provider is down rather
- * than a specific, surfaceable error — the signal that should trigger failover.
- * Distinct from `isRetryableApiError` (a transient error worth an in-backend retry).
- */
-export function isProviderDownError(error: string | null | undefined): boolean {
-  const trimmed = error?.trim();
-  return !trimmed || trimmed.toLowerCase() === "unknown error";
-}
-
-const CLI_PROVIDER_DOWN_PATTERNS = [
-  /authenticat/i,
-  /unauthoriz/i,
-  /\b(401|403)\b/,
-  /not logged in/i,
-  /\blogin\b/i,
-  /\bcredentials?\b/i,
-  /\bapi key\b/i,
-  /(session|token) expired/i,
-  /\b(econnrefused|enotfound|etimedout|econnreset)\b/i,
-  /connection (refused|reset|timed out)/i,
-  /network (error|unreachable)/i,
-  /failed to refresh available models/i,
-];
-
-/**
- * Provider-down classification for CLI-subprocess backends (codex), whose
- * failures surface as free-form stderr rather than the Claude SDK's structured
- * error. Matches the ways a CLI reports "I could not reach or authenticate with
- * the provider" — as opposed to a task that ran and genuinely failed, which must
- * stay a real error so the chain does not burn a second backend replaying it.
- */
-export function isCliProviderDownError(stderr: string | null | undefined): boolean {
-  const trimmed = stderr?.trim();
-  if (!trimmed) return true;
-  return CLI_PROVIDER_DOWN_PATTERNS.some((p) => p.test(trimmed));
-}
-
 /** Sleep for ms milliseconds. */
 export function sleep(ms: number): Promise<void> {
   return new Promise((r) => setTimeout(r, ms));