@johpaz/hive-sdk 0.4.8 → 0.5.0

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];
 }