@johpaz/hive-agents 0.0.35 → 0.0.36

package/packages/core/src/agent/tracer.ts

@@ -0,0 +1,100 @@
+/**
+ * Tracer — ACE Generator output.
+ *
+ * Records every agent execution to the `traces` table.
+ * Fire-and-forget (non-blocking). Also updates playbook helpful/harmful counts
+ * based on execution outcome.
+ */
+
+import { logger } from "../utils/logger"
+
+const log = logger.child("tracer")
+
+export interface TraceInput {
+  threadId: string
+  agentId: string
+  agentName: string
+  toolUsed?: string | null
+  inputSummary: string
+  outputSummary: string
+  success: boolean
+  errorMessage?: string | null
+  durationMs?: number
+  tokensUsed?: number
+}
+
+/**
+ * Save a trace record. Non-blocking — errors are swallowed so they never
+ * affect the main agent loop.
+ */
+export function saveTrace(trace: TraceInput): void {
+  // Run asynchronously so it never blocks the caller
+  Promise.resolve().then(async () => {
+    try {
+      const { getDb } = await import("../storage/sqlite")
+      const db = getDb()
+
+      db.query(`
+        INSERT INTO traces
+          (thread_id, agent_id, agent_name, tool_used, input_summary,
+           output_summary, success, error_message, duration_ms, tokens_used)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(
+        trace.threadId,
+        trace.agentId,
+        trace.agentName,
+        trace.toolUsed ?? null,
+        trace.inputSummary.substring(0, 500),
+        trace.outputSummary.substring(0, 500),
+        trace.success ? 1 : 0,
+        trace.errorMessage ?? null,
+        trace.durationMs ?? null,
+        trace.tokensUsed ?? null,
+      )
+
+      // Trigger reflector check in background
+      checkReflectorTrigger().catch(() => { /* ignore */ })
+    } catch (err) {
+      log.warn("[tracer] Failed to save trace:", err)
+    }
+  })
+}
+
+// ─── Reflector trigger ────────────────────────────────────────────────────────
+
+const REFLECTOR_TRACE_THRESHOLD = 20  // run reflector after N new traces
+
+let _tracesSinceLastReflection = 0
+
+async function checkReflectorTrigger(): Promise<void> {
+  _tracesSinceLastReflection++
+  if (_tracesSinceLastReflection < REFLECTOR_TRACE_THRESHOLD) return
+  _tracesSinceLastReflection = 0
+
+  // Lazy import to avoid circular deps
+  const { runReflector } = await import("./reflector")
+  runReflector().catch((err) => {
+    log.warn("[tracer] Reflector run failed:", err)
+  })
+}
+
+// ─── Usage recording ──────────────────────────────────────────────────────────
+
+export function recordLLMUsage(opts: {
+  provider: string
+  model: string
+  inputTokens: number
+  outputTokens: number
+}): void {
+  Promise.resolve().then(async () => {
+    try {
+      const { recordUsage } = await import("../storage/usage")
+      recordUsage({
+        provider: opts.provider,
+        model: opts.model,
+        inputTokens: opts.inputTokens,
+        outputTokens: opts.outputTokens,
+      })
+    } catch { /* ignore */ }
+  })
+}

package/packages/core/src/auth/auth.ts

@@ -0,0 +1,108 @@
+import jwt from "jsonwebtoken";
+import { hashString } from "../utils/crypto.ts";
+import { getDb } from "../storage/sqlite.ts";
+
+const JWT_SECRET = process.env.JWT_SECRET || "hive-default-jwt-secret-change-in-production";
+const ACCESS_TOKEN_EXPIRY = "15m";
+const REFRESH_TOKEN_EXPIRY = "7d";
+const REFRESH_TOKEN_EXPIRY_SECONDS = 7 * 24 * 60 * 60;
+
+interface AuthTokens {
+  accessToken: string;
+  refreshToken: string;
+  expiresIn: number;
+  tokenType: "Bearer";
+}
+
+interface JwtPayload {
+  userId: string;
+  type: "access" | "refresh";
+}
+
+export async function generateTokens(userId: string): Promise<AuthTokens> {
+  const accessToken = jwt.sign({ userId, type: "access" } satisfies JwtPayload, JWT_SECRET, {
+    expiresIn: ACCESS_TOKEN_EXPIRY,
+  });
+
+  const refreshToken = jwt.sign({ userId, type: "refresh" } satisfies JwtPayload, JWT_SECRET, {
+    expiresIn: REFRESH_TOKEN_EXPIRY,
+  });
+
+  const refreshTokenHash = hashString(refreshToken);
+  const expiresAt = Math.floor(Date.now() / 1000) + REFRESH_TOKEN_EXPIRY_SECONDS;
+
+  const db = getDb();
+  db.run(
+    `INSERT INTO refresh_tokens (user_id, token_hash, expires_at, revoked) 
+     VALUES (?, ?, ?, 0)`,
+    [userId, refreshTokenHash, expiresAt]
+  );
+
+  return {
+    accessToken,
+    refreshToken,
+    expiresIn: 15 * 60,
+    tokenType: "Bearer",
+  };
+}
+
+export async function refreshAccessToken(refreshToken: string): Promise<AuthTokens> {
+  let payload: JwtPayload;
+  try {
+    payload = jwt.verify(refreshToken, JWT_SECRET) as JwtPayload;
+  } catch {
+    throw new Error("Invalid or expired refresh token");
+  }
+
+  if (payload.type !== "refresh") {
+    throw new Error("Invalid token type");
+  }
+
+  const refreshTokenHash = hashString(refreshToken);
+  const db = getDb();
+  const tokenRow = db
+    .query(
+      `SELECT user_id, expires_at, revoked FROM refresh_tokens WHERE token_hash = ?`
+    )
+    .get(refreshTokenHash) as { user_id: string; expires_at: number; revoked: number } | undefined;
+
+  if (!tokenRow) {
+    throw new Error("Refresh token not found");
+  }
+
+  if (tokenRow.revoked === 1) {
+    throw new Error("Refresh token has been revoked");
+  }
+
+  if (tokenRow.expires_at < Math.floor(Date.now() / 1000)) {
+    db.run(`DELETE FROM refresh_tokens WHERE token_hash = ?`, [refreshTokenHash]);
+    throw new Error("Refresh token has expired");
+  }
+
+  db.run(`DELETE FROM refresh_tokens WHERE token_hash = ?`, [refreshTokenHash]);
+
+  return generateTokens(payload.userId);
+}
+
+export async function validateAccessToken(token: string): Promise<{ userId: string } | null> {
+  try {
+    const payload = jwt.verify(token, JWT_SECRET) as JwtPayload;
+    if (payload.type !== "access") {
+      return null;
+    }
+    return { userId: payload.userId };
+  } catch {
+    return null;
+  }
+}
+
+export async function revokeRefreshToken(refreshToken: string): Promise<void> {
+  const refreshTokenHash = hashString(refreshToken);
+  const db = getDb();
+  db.run(`UPDATE refresh_tokens SET revoked = 1 WHERE token_hash = ?`, [refreshTokenHash]);
+}
+
+export async function revokeAllUserTokens(userId: string): Promise<void> {
+  const db = getDb();
+  db.run(`UPDATE refresh_tokens SET revoked = 1 WHERE user_id = ?`, [userId]);
+}

package/packages/core/src/auth/index.ts

@@ -0,0 +1 @@
+export * from "./auth.ts";

package/packages/core/src/canvas/a2ui-tools.ts

@@ -0,0 +1,255 @@
+import type { Tool } from "../agent/native-tools.ts";
+import type { Config } from "../config/loader.ts";
+import { canvasManager } from "./canvas-manager.ts";
+import { logger } from "../utils/logger.ts";
+
+export function createA2UISurfaceTool(_config: Config): Tool {
+  const log = logger.child("a2ui-surface");
+
+  return {
+    name: "a2ui_create_surface",
+    description: "Create an A2UI v0.9 surface on the user's canvas for rendering rich interactive UIs",
+    parameters: {
+      type: "object",
+      properties: {
+        sessionId: {
+          type: "string",
+          description: "Session ID to render to (auto-resolved from user context if omitted)",
+        },
+        surfaceId: {
+          type: "string",
+          description: "Unique identifier for the UI surface (e.g. 'booking_form', 'user_profile'). Must be unique within the session.",
+        },
+        catalogId: {
+          type: "string",
+          description: "Catalog ID for the component set. Use 'https://a2ui.org/specification/v0_9/basic_catalog.json' for the standard catalog.",
+        },
+        theme: {
+          type: "object",
+          description: "Theme configuration for the surface",
+          properties: {
+            primaryColor: {
+              type: "string",
+              description: "Primary color in hex format (e.g. '#3B82F6')",
+            },
+            iconUrl: {
+              type: "string",
+              description: "URL for an icon/logo image",
+            },
+            agentDisplayName: {
+              type: "string",
+              description: "Display name for the agent that created this surface",
+            },
+          },
+        },
+        sendDataModel: {
+          type: "boolean",
+          description: "If true, the client will send the full data model with every action. Default: false.",
+        },
+      },
+      required: ["surfaceId", "catalogId"],
+    },
+    execute: async (params: Record<string, unknown>, config?: any) => {
+      const userId = config?.configurable?.user_id;
+      const rawSessionId = params.sessionId as string;
+      const sessionId = rawSessionId
+        ? (rawSessionId.startsWith("canvas:") ? rawSessionId : `canvas:${rawSessionId}`)
+        : (userId ? `canvas:${userId}` : (() => { throw new Error("No session or user ID provided"); })());
+
+      if (!canvasManager.isSessionConnected(sessionId)) {
+        const connected = canvasManager.getConnectedSessions();
+        log.warn(`No canvas sessions connected. Rendering to ${sessionId} anyway. Available: ${connected.join(", ")}`);
+      }
+
+      await canvasManager.sendA2UIMessage(sessionId, "a2ui:createSurface", {
+        surfaceId: params.surfaceId as string,
+        catalogId: params.catalogId as string,
+        theme: params.theme as Record<string, unknown> ?? {},
+        sendDataModel: params.sendDataModel as boolean ?? false,
+      });
+
+      log.info(`Created A2UI surface '${params.surfaceId}' on session ${sessionId}`);
+      return JSON.stringify({
+        status: "created",
+        surfaceId: params.surfaceId,
+        sessionId,
+      });
+    },
+  };
+}
+
+export function createA2UIUpdateComponentsTool(_config: Config): Tool {
+  const log = logger.child("a2ui-components");
+
+  return {
+    name: "a2ui_update_components",
+    description: `Send A2UI v0.9 components to an existing surface. Components are a FLAT list with ID references (adjacency list).
+
+CHILDREN (spec oficial A2UI v0.9):
+  Static: "children": ["id1", "id2"]  ← array crudo, formato oficial
+  Template: "children": {"path": "/items", "componentId": "item_tmpl"}  ← formato oficial
+  Single child (Card/Modal): "child": "child_id"
+
+COMPONENT PROPS (nombres oficiales del spec):
+  Text: text (string|{path}), variant ("h1"|"h2"|"h3"|"h4"|"h5"|"body"|"caption"|"code")
+  Button: child (id del texto), variant ("default"|"primary"|"borderless"), action (required)
+  TextField: label, value: {path:"/..."}, variant ("shortText"|"longText"|"number"|"obscured"), validationRegexp, action
+    - action fires on blur or Enter key
+  ChoicePicker: options [{label, value}], value: {path:"/..."}, variant ("mutuallyExclusive"|"multipleSelection"), displayStyle ("checkbox"|"chips"), filterable, action
+    - value es DynamicStringList; two-way binding con value; action fires inmediatamente
+  Slider: label, value: {path:"/..."}, min, max, step, action (fires on release)
+  CheckBox: label, value: {path:"/..."} (DynamicBoolean, two-way binding)
+  DateTimeInput: value: {path:"/..."}, enableDate, enableTime, min, max, label
+  Tabs: tabs: [{title: "string plano", child: "id"}]  ← title es string, NO {literalString:...}
+  Modal: trigger (id del botón), content (id del dialog)
+  Card: child (único hijo), weight
+  Row: children, justify ("start"|"center"|"end"|"spaceBetween"|"spaceAround"|"spaceEvenly"), align ("start"|"center"|"end"|"stretch"), weight
+  Column: children, justify, align, weight
+  List: children (con template path), direction ("vertical"|"horizontal"), align, weight
+  Image: url, description, fit ("contain"|"cover"|"fill"|"none"|"scaleDown"), variant ("icon"|"avatar"|"smallFeature"|"mediumFeature"|"largeFeature"|"header")
+  Divider: axis ("horizontal"|"vertical")
+
+ACTION FORMAT (oficial: con wrapper event):
+  {event: {name: "action_name", context: {key: {path: "/data/key"}}}}
+
+DATA BINDING: "prop": "literal" | {path: "/json/pointer"} | {call: "fn", args: {...}}
+
+Root component: usar id="root" explícito.`,
+    parameters: {
+      type: "object",
+      properties: {
+        sessionId: {
+          type: "string",
+          description: "Session ID to render to",
+        },
+        surfaceId: {
+          type: "string",
+          description: "The surface ID to update",
+        },
+        components: {
+          type: "array",
+          description: "Flat list of A2UI component definitions.",
+          items: {
+            type: "object",
+            properties: {
+              id: { type: "string", description: "Unique component ID within the surface" },
+              component: { type: "string", description: "Component type: Text, Button, Row, Column, Card, List, Divider, Image, Icon, Video, AudioPlayer, TextField, CheckBox, ChoicePicker, Slider, DateTimeInput, Tabs, Modal" },
+              weight: { type: "number", description: "Flex weight for proportional sizing inside Row/Column" },
+            },
+          },
+        },
+      },
+      required: ["surfaceId", "components"],
+    },
+    execute: async (params: Record<string, unknown>, config?: any) => {
+      const userId = config?.configurable?.user_id;
+      const rawSessionId = params.sessionId as string;
+      const sessionId = rawSessionId
+        ? (rawSessionId.startsWith("canvas:") ? rawSessionId : `canvas:${rawSessionId}`)
+        : (userId ? `canvas:${userId}` : (() => { throw new Error("No session or user ID provided"); })());
+
+      await canvasManager.sendA2UIMessage(sessionId, "a2ui:updateComponents", {
+        surfaceId: params.surfaceId as string,
+        components: params.components,
+      });
+
+      log.info(`Updated A2UI components on surface '${params.surfaceId}' (${(params.components as any[]).length} components)`);
+      return JSON.stringify({
+        status: "updated",
+        surfaceId: params.surfaceId,
+        componentCount: (params.components as any[]).length,
+      });
+    },
+  };
+}
+
+export function createA2UIUpdateDataModelTool(_config: Config): Tool {
+  const log = logger.child("a2ui-data");
+
+  return {
+    name: "a2ui_update_data_model",
+    description: "Update the data model for an A2UI v0.9 surface. The data model provides dynamic values that components can bind to via paths (e.g. '/user/name').",
+    parameters: {
+      type: "object",
+      properties: {
+        sessionId: {
+          type: "string",
+          description: "Session ID to render to",
+        },
+        surfaceId: {
+          type: "string",
+          description: "The surface ID whose data model to update",
+        },
+        path: {
+          type: "string",
+          description: "JSON Pointer path to update (e.g. '/user/name'). If omitted, replaces the entire data model.",
+        },
+        value: {
+          type: "object",
+          description: "The new value for the specified path. Can be any JSON value.",
+        },
+      },
+      required: ["surfaceId"],
+    },
+    execute: async (params: Record<string, unknown>, config?: any) => {
+      const userId = config?.configurable?.user_id;
+      const rawSessionId = params.sessionId as string;
+      const sessionId = rawSessionId
+        ? (rawSessionId.startsWith("canvas:") ? rawSessionId : `canvas:${rawSessionId}`)
+        : (userId ? `canvas:${userId}` : (() => { throw new Error("No session or user ID provided"); })());
+
+      await canvasManager.sendA2UIMessage(sessionId, "a2ui:updateDataModel", {
+        surfaceId: params.surfaceId as string,
+        path: params.path as string | undefined,
+        value: params.value,
+      });
+
+      log.info(`Updated A2UI data model on surface '${params.surfaceId}' (path: ${params.path ?? "/"})`);
+      return JSON.stringify({
+        status: "updated",
+        surfaceId: params.surfaceId,
+        path: params.path ?? "/",
+      });
+    },
+  };
+}
+
+export function createA2UIDeleteSurfaceTool(_config: Config): Tool {
+  const log = logger.child("a2ui-delete");
+
+  return {
+    name: "a2ui_delete_surface",
+    description: "Delete an A2UI v0.9 surface and remove it from the user's canvas",
+    parameters: {
+      type: "object",
+      properties: {
+        sessionId: {
+          type: "string",
+          description: "Session ID",
+        },
+        surfaceId: {
+          type: "string",
+          description: "The surface ID to delete",
+        },
+      },
+      required: ["surfaceId"],
+    },
+    execute: async (params: Record<string, unknown>, config?: any) => {
+      const userId = config?.configurable?.user_id;
+      const rawSessionId = params.sessionId as string;
+      const sessionId = rawSessionId
+        ? (rawSessionId.startsWith("canvas:") ? rawSessionId : `canvas:${rawSessionId}`)
+        : (userId ? `canvas:${userId}` : (() => { throw new Error("No session or user ID provided"); })());
+
+      await canvasManager.sendA2UIMessage(sessionId, "a2ui:deleteSurface", {
+        surfaceId: params.surfaceId as string,
+      });
+
+      log.info(`Deleted A2UI surface '${params.surfaceId}'`);
+      return JSON.stringify({
+        status: "deleted",
+        surfaceId: params.surfaceId,
+      });
+    },
+  };
+}