niahere 0.4.1 → 0.4.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "niahere",
-  "version": "0.4.1",
+  "version": "0.4.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.2.126",
-    "@anthropic-ai/sdk": "^0.88.0",
-    "@modelcontextprotocol/sdk": "^1.27.1",
+    "@anthropic-ai/claude-agent-sdk": "^0.3.190",
+    "@anthropic-ai/sdk": "^0.105.0",
+    "@modelcontextprotocol/sdk": "^1.29.0",
     "@slack/bolt": "^4.6.0",
     "cron-parser": "^5.5.0",
     "grammy": "^1.41.1",

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

@@ -1,5 +1,5 @@
 import type { AgentEvent, Normalizer } from "../types";
-import { truncate, formatToolUse } from "../../utils/format-activity";
+import { truncate } from "../../utils/format-activity";
 import { isRetryableApiError, isProviderDownError } from "../../utils/retry";
 
 /**
@@ -30,22 +30,14 @@ export class SdkNormalizer implements Normalizer {
     }
 
     if (msg.type === "tool_use_summary") {
-      return [
-        {
-          type: "tool",
-          name: msg.tool_name || "tool",
-          summary: formatToolUse(msg.tool_name || "tool", msg.tool_input),
-        },
-      ];
+      // The SDK provides a ready-made human-readable summary (e.g. "Read foo.ts").
+      // (Older code read tool_name/tool_input, which this event does not carry.)
+      return msg.summary ? [{ type: "tool", name: "tool", summary: truncate(msg.summary, 70) }] : [];
     }
 
     if (msg.type === "tool_progress") {
-      if (msg.tool_name === "Bash" && msg.content) {
-        return [{ type: "tool", name: "Bash", summary: `$ ${truncate(msg.content, 60)}` }];
-      }
-      if (msg.content) {
-        return [{ type: "tool", name: msg.tool_name || "tool", summary: truncate(msg.content, 70) }];
-      }
+      // Carries only tool_use_id/tool_name/elapsed_time — no displayable content,
+      // and fires repeatedly. tool_use_summary already covers tool activity.
       return [];
     }
 

package/src/agent/backends/claude.ts

@@ -151,8 +151,14 @@ class ClaudeSession implements AgentSession {
             retry = true;
             break;
           }
-          yield ev;
-          if (ev.type === "result" || ev.type === "error") {
+          // A retryable error that survived all our retries means the provider is
+          // effectively down for us — flag it so the consumer can fail over.
+          const out =
+            ev.type === "error" && ev.retryable && this.retryCount >= MAX_SEND_RETRIES
+              ? { ...ev, providerDown: true }
+              : ev;
+          yield out;
+          if (out.type === "result" || out.type === "error") {
             this.retryCount = 0;
             return;
           }

package/src/db/models/message.ts

@@ -4,10 +4,15 @@ import type { SaveMessageParams, RoomStats, RecentMessage, SearchResult, Session
 
 export type DeliveryStatus = "pending" | "sent" | "failed";
 
-export async function save(params: SaveMessageParams & { deliveryStatus?: DeliveryStatus; metadata?: Record<string, unknown> }): Promise<number> {
+export async function save(
+  params: SaveMessageParams & { deliveryStatus?: DeliveryStatus; metadata?: Record<string, unknown> },
+): Promise<number> {
   const sql = getSql();
   const status = params.deliveryStatus || "sent";
-  const meta = params.metadata ? JSON.stringify(params.metadata) : null;
+  // Pass the object straight through: the postgres driver serializes it to a
+  // real jsonb object. Pre-stringifying stores a double-encoded string scalar,
+  // which silently breaks every `metadata->>'key'` filter (e.g. notifications).
+  const meta = params.metadata ? sql.json(params.metadata as Parameters<typeof sql.json>[0]) : null;
   const rows = await sql`
     INSERT INTO messages (session_id, room, sender, content, is_from_agent, delivery_status, metadata)
     VALUES (${params.sessionId}, ${params.room}, ${params.sender}, ${params.content}, ${params.isFromAgent}, ${status}, ${meta})
@@ -21,7 +26,9 @@ export async function updateDeliveryStatus(id: number, status: DeliveryStatus):
   await sql`UPDATE messages SET delivery_status = ${status} WHERE id = ${id}`;
 }
 
-export async function getUndelivered(room?: string): Promise<Array<{ id: number; room: string; content: string; createdAt: string }>> {
+export async function getUndelivered(
+  room?: string,
+): Promise<Array<{ id: number; room: string; content: string; createdAt: string }>> {
   const sql = getSql();
   const rows = room
     ? await sql`

package/src/db/models/session.ts

@@ -141,7 +141,10 @@ export async function accumulateMetadata(id: string, resultMeta: Record<string,
     }
   }
 
-  const delta = JSON.stringify({
+  // 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.
+  const delta = sql.json({
     total_cost_usd: (resultMeta.cost_usd as number) || 0,
     total_turns: (resultMeta.turns as number) || 0,
     total_duration_ms: (resultMeta.duration_ms as number) || 0,
@@ -152,22 +155,23 @@ export async function accumulateMetadata(id: string, resultMeta: Record<string,
     total_cache_creation_tokens: cacheCreationTokens,
     message_count: 1,
     models_used: newModels,
-    channel: resultMeta.channel || null,
+    channel: (resultMeta.channel as string) || null,
   });
+  const modelsDelta = sql.json(newModels);
 
   // 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}::jsonb->>'total_cost_usd')::real,
-      'total_turns',                  COALESCE((metadata->>'total_turns')::int, 0)                  + (${delta}::jsonb->>'total_turns')::int,
-      'total_duration_ms',            COALESCE((metadata->>'total_duration_ms')::real, 0)            + (${delta}::jsonb->>'total_duration_ms')::real,
-      'total_duration_api_ms',        COALESCE((metadata->>'total_duration_api_ms')::real, 0)        + (${delta}::jsonb->>'total_duration_api_ms')::real,
-      'total_input_tokens',           COALESCE((metadata->>'total_input_tokens')::int, 0)            + (${delta}::jsonb->>'total_input_tokens')::int,
-      'total_output_tokens',          COALESCE((metadata->>'total_output_tokens')::int, 0)           + (${delta}::jsonb->>'total_output_tokens')::int,
-      'total_cache_read_tokens',      COALESCE((metadata->>'total_cache_read_tokens')::int, 0)       + (${delta}::jsonb->>'total_cache_read_tokens')::int,
-      'total_cache_creation_tokens',  COALESCE((metadata->>'total_cache_creation_tokens')::int, 0)   + (${delta}::jsonb->>'total_cache_creation_tokens')::int,
+      'total_cost_usd',              COALESCE((metadata->>'total_cost_usd')::real, 0)              + (${delta}->>'total_cost_usd')::real,
+      '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,
+      'total_input_tokens',           COALESCE((metadata->>'total_input_tokens')::int, 0)            + (${delta}->>'total_input_tokens')::int,
+      'total_output_tokens',          COALESCE((metadata->>'total_output_tokens')::int, 0)           + (${delta}->>'total_output_tokens')::int,
+      'total_cache_read_tokens',      COALESCE((metadata->>'total_cache_read_tokens')::int, 0)       + (${delta}->>'total_cache_read_tokens')::int,
+      'total_cache_creation_tokens',  COALESCE((metadata->>'total_cache_creation_tokens')::int, 0)   + (${delta}->>'total_cache_creation_tokens')::int,
       'message_count',                COALESCE((metadata->>'message_count')::int, 0)                 + 1,
-      'models_used',                  COALESCE(metadata->'models_used', '[]'::jsonb) || ${JSON.stringify(newModels)}::jsonb,
+      'models_used',                  COALESCE(metadata->'models_used', '[]'::jsonb) || ${modelsDelta},
       'channel',                      COALESCE(metadata->>'channel', ${(resultMeta.channel as string) || null})
     )
     WHERE id = ${id}