@johpaz/hive-sdk 0.4.9 → 0.5.0

package/packages/core/src/storage/seed.ts

@@ -117,6 +117,7 @@ export const SEED_DATA: SeedData = {
     { id: "notify", name: "notify", category: "core", description: "Enviar notificación al usuario. Sinónimos: notificar, enviar notificación, alertar, aviso" },
     { id: "save_note", name: "save_note", category: "core", description: "Guardar nota persistente en el scratchpad. Sinónimos: guardar nota, escribir nota, recordatorio rápido, apuntar" },
     { id: "report_progress", name: "report_progress", category: "core", description: "Reportar progreso actual al usuario. Sinónimos: reportar progreso, informar estado, actualizar progreso, porcentaje" },
+    { id: "conversation_read", name: "conversation_read", category: "core", description: "Recuperar mensajes anteriores de esta conversación por ID o búsqueda de texto. Sinónimos: leer conversación, recuperar contexto, historial omitido" },
 
     // ─────────────────────────────────────────
     // 10. OFFICE — Archivos Office (PDF, DOCX, XLSX, PPTX)
@@ -235,6 +236,9 @@ export const SEED_DATA: SeedData = {
     { id: "kimi-k2.6", providerId: "kimi", name: "Kimi K2.6", modelType: "llm", contextWindow: 262144, capabilities: JSON.stringify(["chat", "vision", "json_mode", "function_calling", "streaming", "code"]), inputPer1M: 0.6, outputPer1M: 3.41 },
 
     // ── OpenRouter (fuente: GET https://openrouter.ai/api/v1/models) ──
+    // Jev: modelo de decisiones (API Decisions, nunca chat). `modelType:
+    // "decision"` lo deja fuera de getDefaultLLM y de get_available_models.
+    { id: "typesafe/jev-1.13", providerId: "openrouter", name: "Jev 1.13 (Decisions)", modelType: "decision", contextWindow: 32000, capabilities: JSON.stringify(["choice", "noul", "score"]), inputPer1M: 0.042, outputPer1M: 0 },
     // Solo modelos vivos con `tools` en supported_parameters y publicados desde
     // 2025-07. contextWindow = context_length reportado por el propio catálogo,
     // y los precios también salen de ahí — son los de la ruta de OpenRouter, no

package/packages/core/src/storage/usage.ts

@@ -154,6 +154,15 @@ export interface UsageRecord {
   created_at: number;
 }
 
+export interface JevUsageSummary {
+  decisions: number;
+  costUsd: number;
+  /** Estimated main-model input tokens avoided; negative when Jev added more than it removed. */
+  savedTokens: number;
+  savedCostUsd: number;
+  byAgent: Record<string, { decisions: number; costUsd: number; savedTokens: number; savedCostUsd: number }>;
+}
+
 export interface UsageSummary {
   totalTokens: number;
   totalInputTokens: number;
@@ -169,6 +178,7 @@ export interface UsageSummary {
   byProvider: Record<string, { tokens: number; costUsd: number; inputTokens: number; outputTokens: number }>;
   byModel: Record<string, { tokens: number; costUsd: number; provider: string; inputTokens: number; outputTokens: number }>;
   recentRecords: UsageRecord[];
+  jev: JevUsageSummary;
 }
 
 export function recordUsage(options: {
@@ -233,13 +243,15 @@ export async function getUsageStats(hours: number = 24): Promise<UsageSummary> {
   const rollupsCol = await col<UsageRollupDoc>("usageRollups");
   const buckets = hourBucketsSince(hours);
   const rollups = (await Promise.all(buckets.map((id) => rollupsCol.get(id))))
-    .map((e) => e?.doc ?? emptyRollup());
+    // A bucket touched only by recordJevDecision lacks the token fields.
+    .map((e) => ({ ...emptyRollup(), ...e?.doc }));
 
   const providerMap: UsageSummary["byProvider"] = {};
   const modelMap: UsageSummary["byModel"] = {};
   let totalInput = 0, totalOutput = 0, totalCost = 0;
   let toonSavedTokens = 0, toonSavedCost = 0, toonSavedBytes = 0;
   let toonJsonTokens = 0, toonToonTokens = 0, toonJsonBytes = 0;
+  const jev: JevUsageSummary = { decisions: 0, costUsd: 0, savedTokens: 0, savedCostUsd: 0, byAgent: {} };
 
   for (const r of rollups) {
     totalInput += r.inputTokens;
@@ -251,6 +263,18 @@ export async function getUsageStats(hours: number = 24): Promise<UsageSummary> {
     toonJsonTokens += r.toonJsonTokens;
     toonToonTokens += r.toonToonTokens;
     toonJsonBytes += r.toonJsonBytes;
+    jev.decisions += r.jevDecisions ?? 0;
+    jev.costUsd += r.jevCostUsd ?? 0;
+    jev.savedTokens += r.jevSavedTokens ?? 0;
+    jev.savedCostUsd += r.jevSavedCostUsd ?? 0;
+    for (const [agentId, a] of Object.entries(r.jevByAgent ?? {})) {
+      const cur = jev.byAgent[agentId] ?? { decisions: 0, costUsd: 0, savedTokens: 0, savedCostUsd: 0 };
+      cur.decisions += a.jevDecisions ?? 0;
+      cur.costUsd += a.jevCostUsd ?? 0;
+      cur.savedTokens += a.jevSavedTokens ?? 0;
+      cur.savedCostUsd += a.jevSavedCostUsd ?? 0;
+      jev.byAgent[agentId] = cur;
+    }
 
     for (const [provider, p] of Object.entries(r.byProvider ?? {})) {
       const cur = providerMap[provider] ?? { tokens: 0, costUsd: 0, inputTokens: 0, outputTokens: 0 };
@@ -301,10 +325,39 @@ export async function getUsageStats(hours: number = 24): Promise<UsageSummary> {
     toonSavingsPercent,
     byProvider: providerMap,
     byModel: modelMap,
-    recentRecords
+    recentRecords,
+    jev,
   };
 }
 
+/**
+ * Persists one Jev decision into the hourly rollup. The avoided tokens are
+ * priced with the advised agent's own model (input rate), through the same
+ * catalog lookup as real usage, so "saved" and "spent" are comparable.
+ */
+export function recordJevDecision(options: {
+  agentId: string;
+  provider: string;
+  model: string;
+  savedTokens: number;
+  costUsd: number;
+}): void {
+  Promise.resolve().then(async () => {
+    try {
+      const unitCost = await calculateCost(options.provider, options.model, Math.abs(options.savedTokens), 0);
+      const savedCostUsd = Math.sign(options.savedTokens) * unitCost;
+      await bumpRollup("usageRollups", hourBucket(Date.now()), {
+        jevDecisions: 1,
+        jevCostUsd: options.costUsd,
+        jevSavedTokens: options.savedTokens,
+        jevSavedCostUsd: savedCostUsd,
+      }, { field: "jevByAgent", key: options.agentId });
+    } catch (error) {
+      log.warn(`[JEV] Failed to record decision:`, error);
+    }
+  });
+}
+
 /**
  * Record TOON savings for metrics tracking
  * This updates the usage_records table with complete TOON compression metrics

package/packages/core/src/swarm/RoleSwarm.ts

@@ -21,6 +21,7 @@
  */
 
 import { runAgentIsolated } from "../agent/agent-loop.ts"
+import type { JevOption } from "../agent/jev-decisions.ts"
 import type { ProviderCredentials } from "../agent/llm-client.ts"
 import { logger } from "../utils/logger.ts"
 
@@ -50,6 +51,7 @@ export type AgentInvoker = (input: {
   threadId: string
   channel?: string
   credentials?: ProviderCredentials
+  jev?: JevOption
   signal?: AbortSignal
 }) => Promise<string>
 
@@ -60,6 +62,7 @@ export const defaultInvoker: AgentInvoker = async (input) =>
     threadId: input.threadId,
     channel: input.channel,
     credentials: input.credentials,
+    jev: input.jev,
     signal: input.signal,
   })
 
@@ -83,6 +86,8 @@ export interface RoleSwarmOptions {
   maxDelegations?: number
   /** Credenciales del inquilino, propagadas a cada agente. */
   credentials?: ProviderCredentials
+  /** Jev del inquilino, propagado a cada agente igual que `credentials`. */
+  jev?: JevOption
   signal?: AbortSignal
   /** Se llama en cada paso; acá persiste el consumidor si quiere. */
   onMessage?: (message: SwarmMessage) => void | Promise<void>
@@ -129,6 +134,7 @@ export async function runRoleSwarm(opts: RoleSwarmOptions): Promise<RoleSwarmRes
       threadId,
       channel: opts.channel,
       credentials: opts.credentials,
+      jev: opts.jev,
       signal: opts.signal,
     })
   }

package/packages/core/src/tool-runtime/index.ts

@@ -47,6 +47,8 @@ export type ExecuteToolBatchOptions = {
   }
   hiveConfig?: Config
   workerPool?: ToolRuntimeConfig
+  /** Per-batch decision (Jev). Undefined preserves the configured behavior. */
+  parallelToolCalls?: boolean
   mainThreadToolNames?: string[]
   signal?: AbortSignal
 }
@@ -199,6 +201,7 @@ const DEFAULT_MAIN_THREAD_TOOL_NAMES = new Set([
   // These tools depend on process-local singleton state (HiveDB handle, live
   // channel senders, schedulers, browser sessions, or in-memory services).
   "search_knowledge",
+  "conversation_read",
   "save_note",
   "memory_write",
   "memory_read",
@@ -670,6 +673,7 @@ export async function executeToolBatch(options: ExecuteToolBatchOptions): Promis
 
 async function executeToolBatchInner(options: ExecuteToolBatchOptions): Promise<ToolBatchResult[]> {
   const runtimeConfig = resolveRuntimeConfig(options.workerPool)
+  const parallelToolCalls = options.parallelToolCalls ?? runtimeConfig.parallelToolCalls
   const hiveConfig = options.hiveConfig ?? loadConfig()
   const mainThreadToolNames = [
     ...DEFAULT_MAIN_THREAD_TOOL_NAMES,
@@ -690,11 +694,26 @@ async function executeToolBatchInner(options: ExecuteToolBatchOptions): Promise<
 
   // A null pool means workers are disabled, unnecessary (single call), or
   // unavailable in this build — all three degrade to the main thread.
-  const pool = runtimeConfig.enabled && runtimeConfig.parallelToolCalls && options.toolCalls.length > 1
+  const pool = runtimeConfig.enabled && parallelToolCalls && options.toolCalls.length > 1
     ? getPool(runtimeConfig.maxWorkers)
     : null
 
   if (!pool) {
+    // Jev judged the batch independent: run it concurrently even without workers.
+    if (options.parallelToolCalls === true && options.toolCalls.length > 1) {
+      return Promise.all(options.toolCalls.map(async (toolCall) => {
+        const startedAt = performance.now()
+        const effectiveTimeout = resolveToolTimeout(toolCall.function.name, options.allTools, hiveConfig, runtimeConfig.toolTimeoutMs)
+        const result = await executeInMainThreadWithTimeout({
+          toolCall, allTools: options.allTools, toolConfig: options.toolConfig, signal: options.signal,
+        }, effectiveTimeout)
+        return {
+          toolCall, toolName: toolCall.function.name, result,
+          ok: !(result && typeof result === "object" && (result as any).error === true),
+          durationMs: Math.round(performance.now() - startedAt),
+        }
+      }))
+    }
     const results: ToolBatchResult[] = []
     for (const toolCall of options.toolCalls) {
       const startedAt = performance.now()

package/packages/core/src/tools/agents/get-available-models.ts

@@ -60,7 +60,9 @@ export const getAvailableModelsTool: Tool = {
         .filter(m => m.enabled && providersById.has(m.provider_id));
 
       if (providerId) models = models.filter(m => m.provider_id === providerId);
-      if (modelType) models = models.filter(m => m.model_type === modelType);
+      // Decision models (Jev) only answer the Decisions API, never chat: an
+      // agent assigned one would fail every turn.
+      models = modelType ? models.filter(m => m.model_type === modelType) : models.filter(m => m.model_type !== "decision");
       if (capabilities) models = models.filter(m => (m.capabilities ?? "").includes(capabilities));
 
       // Transformar a formato amigable

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

@@ -14,7 +14,7 @@ import {
   type CapabilityType,
 } from "../../agent/capability-search.ts";
 import { CORE_TOOL_CATALOG } from "../../agent/tool-selector.ts";
-import { saveScratchpadNote } from "../../agent/conversation-store.ts";
+import { saveScratchpadNote, getRecentMessages, getScratchpad } from "../../agent/conversation-store.ts";
 
 const log = logger.child("core");
 
@@ -503,6 +503,37 @@ export const reportProgressTool: Tool = {
   },
 };
 
+/** Recover a small, scoped slice of conversation omitted by Jev's context plan. */
+export const conversationReadTool: Tool = {
+  name: "conversation_read",
+  description: "Read earlier messages from the current conversation by message IDs or text query when selected context is insufficient.",
+  parameters: {
+    type: "object",
+    properties: {
+      message_ids: { type: "array", description: "Message IDs shown in the context plan", items: { type: "number" } },
+      note_keys: { type: "array", description: "Scratchpad note keys shown in the context plan", items: { type: "string" } },
+      query: { type: "string", description: "Optional case-insensitive text to search in earlier messages" },
+    },
+  },
+  execute: async (params, config) => {
+    const threadId = config?.configurable?.thread_id as string | undefined
+    if (!threadId) return { ok: false, error: "Conversation scope unavailable" }
+    const ids = new Set(Array.isArray(params.message_ids) ? params.message_ids.map(Number).filter(Number.isFinite) : [])
+    const noteKeys = new Set(Array.isArray(params.note_keys) ? params.note_keys.map(String) : [])
+    const query = String(params.query ?? "").trim().toLocaleLowerCase()
+    if (!ids.size && !noteKeys.size && !query) return { ok: false, error: "Provide message_ids, note_keys or query" }
+    const rows = await getRecentMessages(threadId, 200)
+    const notes = await getScratchpad(threadId)
+    return {
+      ok: true,
+      messages: rows.filter(row => (ids.size && ids.has(row.id)) || (query && row.content.toLocaleLowerCase().includes(query)))
+        .slice(-8).map(row => ({ id: row.id, role: row.role, source: row.source, content: row.content.slice(0, 2000) })),
+      notes: notes.filter(note => noteKeys.has(note.key) || (query && `${note.key} ${note.value}`.toLocaleLowerCase().includes(query)))
+        .slice(0, 8).map(note => ({ key: note.key, value: note.value.slice(0, 2000) })),
+    }
+  },
+};
+
 export function createTools(): Tool[] {
-  return [searchKnowledgeTool, notifyTool, saveNoteTool, reportProgressTool];
+  return [searchKnowledgeTool, notifyTool, saveNoteTool, reportProgressTool, conversationReadTool];
 }