@johpaz/hive-sdk 0.1.4 → 0.1.6

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

@@ -1,448 +0,0 @@
-import type { Tool } from "../agent/NativeTools.ts";
-import type { Config } from "../config/loader.ts";
-import { canvasManager } from "./CanvasManager.ts";
-import { logger } from "../utils/logger.ts";
-
-export function createCanvasRenderTool(_config: Config): Tool {
-  const log = logger.child("canvas-render");
-
-  return {
-    name: "canvas_render",
-    description: "Render a component on the user's canvas",
-    parameters: {
-      type: "object",
-      properties: {
-        sessionId: {
-          type: "string",
-          description: "Session ID to render to (auto-resolved from user context if omitted)",
-        },
-        component: {
-          type: "object",
-          properties: {
-            id: {
-              type: "string",
-              description: "Unique component ID",
-            },
-            type: {
-              type: "string",
-              enum: ["button", "form", "chart", "table", "markdown", "text", "image"],
-              description: "Component type",
-            },
-            props: {
-              type: "object",
-              description: "Component properties",
-            },
-            span: {
-              type: "string",
-              enum: ["full", "half"],
-              description: "Width span: 'full' for full-width component, 'half' for half width. Default: single column",
-            },
-          },
-          required: ["id", "type", "props"],
-        },
-      },
-      required: ["component"],
-    },
-    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"); })());
-      const component = params.component as {
-        id: string;
-        type: "button" | "form" | "chart" | "table" | "markdown" | "text" | "image" | "card" | "progress" | "list" | "confirm";
-        props: Record<string, unknown>;
-        span?: "full" | "half";
-      };
-
-      log.debug(`Rendering component ${component.id} to session ${sessionId}`);
-
-      // Check if session is connected, if not try to render to any available session
-      if (!canvasManager.isSessionConnected(sessionId)) {
-        const connectedSessions = canvasManager.getConnectedSessions();
-        if (connectedSessions.length > 0) {
-          log.warn(`Session ${sessionId} not connected, using first available: ${connectedSessions[0]}`);
-        } else {
-          log.warn(`No canvas sessions connected. Rendering to ${sessionId} anyway.`);
-        }
-      }
-
-      await canvasManager.render(sessionId, {
-        id: component.id,
-        type: component.type as any,
-        props: component.props,
-        span: component.span,
-      });
-
-      return {
-        success: true,
-        componentId: component.id,
-        sessionId,
-      };
-    },
-  };
-}
-
-export function createCanvasAskTool(_config: Config): Tool {
-  const log = logger.child("canvas-ask");
-
-  return {
-    name: "canvas_ask",
-    description: "Display a form and wait for user response",
-    parameters: {
-      type: "object",
-      properties: {
-        sessionId: {
-          type: "string",
-          description: "Session ID",
-        },
-        title: {
-          type: "string",
-          description: "Form title",
-        },
-        fields: {
-          type: "array",
-          items: {
-            type: "object",
-            properties: {
-              name: { type: "string" },
-              label: { type: "string" },
-              type: { type: "string", enum: ["text", "email", "textarea", "select"] },
-              required: { type: "boolean" },
-              options: {
-                type: "array",
-                items: {
-                  type: "object",
-                  properties: {
-                    label: { type: "string" },
-                    value: { type: "string" },
-                  },
-                },
-              },
-            },
-            required: ["name", "label", "type"],
-          },
-          description: "Form fields",
-        },
-        timeout: {
-          type: "number",
-          description: "Timeout in milliseconds (default: 300000)",
-        },
-      },
-      required: ["fields"],
-    },
-    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"); })());
-      const title = (params.title as string) ?? "Form";
-      const fields = params.fields as Array<{
-        name: string;
-        label: string;
-        type: string;
-        required?: boolean;
-        options?: Array<{ label: string; value: string }>;
-      }>;
-      const timeout = (params.timeout as number) ?? 300000;
-
-      const formId = `form-${Date.now()}`;
-
-      log.debug(`Asking user via form ${formId}`);
-
-      await canvasManager.render(sessionId, {
-        id: formId,
-        type: "form",
-        props: { title, fields },
-      });
-
-      try {
-        const response = await canvasManager.waitForInteraction(sessionId, formId, timeout);
-
-        return {
-          success: true,
-          formId,
-          data: response,
-        };
-      } catch (error) {
-        return {
-          success: false,
-          formId,
-          error: (error as Error).message,
-        };
-      }
-    },
-  };
-}
-
-export function createCanvasClearTool(_config: Config): Tool {
-  const log = logger.child("canvas-clear");
-
-  return {
-    name: "canvas_clear",
-    description: "Clear the canvas for a session",
-    parameters: {
-      type: "object",
-      properties: {
-        sessionId: {
-          type: "string",
-          description: "Session ID to clear",
-        },
-      },
-      required: [],
-    },
-    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"); })());
-
-      log.debug(`Clearing canvas for session ${sessionId}`);
-
-      await canvasManager.clear(sessionId);
-
-      return { success: true, sessionId };
-    },
-  };
-}
-
-export function createCanvasTools(config: Config): Tool[] {
-  return [
-    createCanvasRenderTool(config),
-    createCanvasAskTool(config),
-    createCanvasClearTool(config),
-    createCanvasCardTool(config),
-    createCanvasProgressTool(config),
-    createCanvasListTool(config),
-    createCanvasConfirmTool(config),
-  ];
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Extended Canvas Tools for A2UI
-// ═══════════════════════════════════════════════════════════════════════════
-
-export function createCanvasCardTool(_config: Config): Tool {
-  const log = logger.child("canvas-card");
-
-  return {
-    name: "canvas_show_card",
-    description: "Display a card with labeled items (useful for showing status, summaries)",
-    parameters: {
-      type: "object",
-      properties: {
-        sessionId: { type: "string", description: "Session ID" },
-        title: { type: "string", description: "Card title" },
-        items: {
-          type: "array",
-          items: {
-            type: "object",
-            properties: {
-              label: { type: "string" },
-              value: { type: "string" },
-              variant: { type: "string", enum: ["default", "success", "warning", "danger"] },
-            },
-          },
-        },
-        actions: {
-          type: "array",
-          items: {
-            type: "object",
-            properties: {
-              id: { type: "string" },
-              label: { type: "string" },
-              variant: { type: "string", enum: ["primary", "secondary", "danger", "success"] },
-            },
-          },
-        },
-        span: {
-          type: "string",
-          enum: ["full", "half"],
-          description: "Width span: 'full' for full-width card, 'half' for half width. Default: single column",
-        },
-      },
-      required: ["items"],
-    },
-    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"); })());
-      const title = (params.title as string) ?? "Information";
-      const items = (params.items as Array<{ label: string; value: string; variant?: string }>) ?? [];
-      const actions = (params.actions as Array<{ id: string; label: string; variant?: string }>) ?? [];
-      const span = params.span as "full" | "half" | undefined;
-
-      const cardId = `card-${Date.now()}`;
-
-      await canvasManager.render(sessionId, {
-        id: cardId,
-        type: "card",
-        props: { title, items, actions },
-        span,
-      });
-
-      return { success: true, cardId, sessionId };
-    },
-  };
-}
-
-export function createCanvasProgressTool(_config: Config): Tool {
-  const log = logger.child("canvas-progress");
-
-  return {
-    name: "canvas_show_progress",
-    description: "Display progress bars for tasks (useful for multi-step operations)",
-    parameters: {
-      type: "object",
-      properties: {
-        sessionId: { type: "string", description: "Session ID" },
-        tasks: {
-          type: "array",
-          items: {
-            type: "object",
-            properties: {
-              id: { type: "string" },
-              name: { type: "string" },
-              progress: { type: "number" },
-              status: { type: "string", enum: ["pending", "running", "completed", "error"] },
-            },
-          },
-        },
-        span: {
-          type: "string",
-          enum: ["full", "half"],
-          description: "Width span: 'full' for full-width, 'half' for half width. Default: single column",
-        },
-      },
-      required: ["tasks"],
-    },
-    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"); })());
-      const tasks = (params.tasks as Array<{ id: string; name: string; progress: number; status?: string }>) ?? [];
-      const span = params.span as "full" | "half" | undefined;
-
-      const progressId = `progress-${Date.now()}`;
-
-      await canvasManager.render(sessionId, {
-        id: progressId,
-        type: "progress",
-        props: { tasks },
-        span,
-      });
-
-      return { success: true, progressId, sessionId };
-    },
-  };
-}
-
-export function createCanvasListTool(_config: Config): Tool {
-  const log = logger.child("canvas-list");
-
-  return {
-    name: "canvas_show_list",
-    description: "Display a list of key-value pairs (useful for configuration display)",
-    parameters: {
-      type: "object",
-      properties: {
-        sessionId: { type: "string", description: "Session ID" },
-        title: { type: "string", description: "List title" },
-        items: {
-          type: "array",
-          items: {
-            type: "object",
-            properties: {
-              key: { type: "string" },
-              value: { type: "string" },
-            },
-          },
-        },
-        span: {
-          type: "string",
-          enum: ["full", "half"],
-          description: "Width span: 'full' for full-width, 'half' for half width. Default: single column",
-        },
-      },
-      required: ["items"],
-    },
-    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"); })());
-      const title = (params.title as string) ?? "Details";
-      const items = (params.items as Array<{ key: string; value: string }>) ?? [];
-      const span = params.span as "full" | "half" | undefined;
-
-      const listId = `list-${Date.now()}`;
-
-      await canvasManager.render(sessionId, {
-        id: listId,
-        type: "list",
-        props: { title, items },
-        span,
-      });
-
-      return { success: true, listId, sessionId };
-    },
-  };
-}
-
-export function createCanvasConfirmTool(_config: Config): Tool {
-  const log = logger.child("canvas-confirm");
-
-  return {
-    name: "canvas_confirm",
-    description: "Show a confirmation dialog and wait for user response",
-    parameters: {
-      type: "object",
-      properties: {
-        sessionId: { type: "string", description: "Session ID" },
-        title: { type: "string", description: "Dialog title" },
-        message: { type: "string", description: "Confirmation message" },
-        confirmLabel: { type: "string", description: "Confirm button label" },
-        cancelLabel: { type: "string", description: "Cancel button label" },
-        danger: { type: "boolean", description: "Show as dangerous action" },
-        timeout: { type: "number", description: "Timeout in ms (default: 60000)" },
-      },
-      required: ["message"],
-    },
-    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"); })());
-      const title = (params.title as string) ?? "Confirm";
-      const message = params.message as string;
-      const confirmLabel = (params.confirmLabel as string) ?? "Confirm";
-      const cancelLabel = (params.cancelLabel as string) ?? "Cancel";
-      const danger = (params.danger as boolean) ?? false;
-      const timeout = (params.timeout as number) ?? 60000;
-
-      const confirmId = `confirm-${Date.now()}`;
-
-      await canvasManager.render(sessionId, {
-        id: confirmId,
-        type: "confirm",
-        props: { title, message, confirmLabel, cancelLabel, danger },
-      });
-
-      try {
-        const response = await canvasManager.waitForInteraction(sessionId, confirmId, timeout);
-        return { success: true, confirmed: response === true, confirmId, sessionId };
-      } catch (error) {
-        return { success: false, confirmed: false, confirmId, error: (error as Error).message, sessionId };
-      }
-    },
-  };
-}

package/packages/core/src/harness/collections.ts

@@ -1,98 +0,0 @@
-/**
- * Document shapes for the harness's HiveDB collections. Ported from `hive`'s
- * durable-task harness, generalized for SDK consumers: `JobDoc.type` and
- * `HarnessRunDoc.kind` are plain strings (not a fixed union) so a host app
- * (hive-cloud, a custom hive-sdk app, etc.) can define its own job/run
- * vocabulary and register executors for it via `registerExecutor()`.
- */
-
-export interface HarnessRunDoc {
-  id: string
-  thread_id: string
-  agent_id: string
-  user_id: string
-  channel: string | null
-  /** Host-defined run kind, e.g. "chat" | "worker" | "goal". */
-  kind: string
-  status: "running" | "completed" | "failed" | "interrupted" | "aborted"
-
-  iterations_used: number
-  max_iterations: number
-  turns_used: number
-  max_turns: number | null
-  tokens_used: number
-  max_tokens: number | null
-
-  goal: string | null
-  goal_check_tool: string | null
-  goal_attempts: number
-
-  state_json: string
-  state_bytes: number
-  pending_tool_calls_json: string | null
-  checkpointed_at: number
-
-  boot_id: string
-  lease_expires_at: number
-  resume_policy: "resume" | "mark_interrupted" | "discard"
-
-  /** Whole-job acceptance criteria (harness-engineering "proof" concept): JSON array of AcceptanceCriterion. */
-  acceptance_json: string | null
-  /** Fixed-worker epoch recorded at run creation: RunEpoch JSON. */
-  epoch_json: string | null
-
-  error: string | null
-  created_at: number
-  updated_at: number
-  finished_at: number | null
-}
-
-export interface JobDoc {
-  id: string
-  lane: string
-  /** Host-defined job type, e.g. "chat_turn" | "worker_task" | "goal_run". */
-  type: string
-  status: "pending" | "running" | "completed" | "failed" | "cancelled" | "interrupted"
-  priority: number
-  payload_json: string
-  run_id: string
-  attempts: number
-  max_attempts: number
-  not_before: number
-  boot_id: string | null
-  lease_expires_at: number | null
-  result_json: string | null
-  error: string | null
-  created_at: number
-  started_at: number | null
-  finished_at: number | null
-  /** Logical-failure retries (executor returned {ok:false, retryable:true}). Separate from `attempts` (crash/lease-expiry only). */
-  retry_count: number
-  /** Error from the most recent logical-failure retry; `error` stays null until the job is terminal. */
-  last_error: string | null
-  /** `toIndexable`-encoded — sentinel when unset. Client-supplied dedup key for job creation. */
-  idempotency_key: string
-}
-
-/**
- * Compressed evidence artifact for a completed run — the "proof packet"
- * concept from harness-engineering's proof/verification practice: what was
- * intended, what was checked, what evidence backs the verdict, known limits.
- */
-export interface ProofPacketDoc {
-  id: string
-  run_id: string
-  agent_id: string
-  intended_outcome: string
-  /** Per-acceptance-criterion verdicts: [{id, description, met, evidence}]. */
-  acceptance_results_json: string
-  /** Names of checks executed (tool ids, LLM verifier, etc). */
-  checks_run_json: string
-  /** Free-form evidence snippets backing the verdict (tool outputs, verifier reasons). */
-  evidence_json: string
-  known_limits: string | null
-  /** Fixed-worker epoch this run executed under — copied from HarnessRunDoc.epoch_json. */
-  epoch_json: string | null
-  met: boolean
-  created_at: number
-}

package/packages/core/src/harness/goal-verifier.ts

@@ -1,141 +0,0 @@
-/**
- * goal-verifier — verify whether a goal/acceptance-criterion has been met.
- * Ported from `hive`'s agent/goal-runner.ts#verifyGoal, decoupled from
- * `hive`'s goal-run orchestration loop (that's host-app specific — see
- * `harness/collections.ts` doc comment). This module only answers "was it
- * met", using either a caller-provided deterministic check tool or an LLM
- * verifier.
- */
-
-import { logger } from "../utils/logger";
-import { callLLM, type LLMMessage, type LLMCallOptions } from "../agent/providers/LLMClient";
-import type { AcceptanceCriterion } from "./run-store";
-
-type ProviderConfig = Pick<LLMCallOptions, "provider" | "model" | "apiKey" | "baseUrl" | "numCtx" | "numGpu">;
-
-const log = logger.child("harness:goal-verifier");
-
-export interface AcceptanceResult {
-  id: string;
-  description: string;
-  met: boolean;
-  evidence: string;
-}
-
-export interface GoalVerdict {
-  met: boolean;
-  reason: string;
-  acceptanceResults?: AcceptanceResult[];
-}
-
-/**
- * Runs a caller-provided check tool and interprets its result (boolean, or
- * an object/string with a `met` field). The harness has no built-in tool
- * registry — the host app resolves `checkTool` to a callable.
- */
-export type CheckToolRunner = (checkTool: string, args: { goal: string }) => Promise<unknown>;
-
-export interface VerifyGoalOptions {
-  goal: string;
-  checkTool?: string | null;
-  messages: LLMMessage[];
-  providerCfg: ProviderConfig;
-  /** Required when any criterion (or the top-level goal) specifies `checkTool`. */
-  runCheckTool?: CheckToolRunner;
-  acceptance?: AcceptanceCriterion[] | null;
-}
-
-/**
- * Verify whether a goal has been met using either a deterministic check
- * tool (via `runCheckTool`) or an LLM verifier. When `acceptance` criteria
- * are supplied, each is verified independently and the overall verdict is
- * the conjunction of all of them — the top-level `goal`/`checkTool` are
- * ignored in that case.
- */
-export async function verifyGoal(opts: VerifyGoalOptions): Promise<GoalVerdict> {
-  const { goal, checkTool, messages, providerCfg, runCheckTool, acceptance } = opts;
-
-  if (acceptance && acceptance.length > 0) {
-    const results: AcceptanceResult[] = [];
-    for (const criterion of acceptance) {
-      const verdict = await verifyGoal({
-        goal: criterion.description,
-        checkTool: criterion.checkTool,
-        messages,
-        providerCfg,
-        runCheckTool,
-      });
-      results.push({ id: criterion.id, description: criterion.description, met: verdict.met, evidence: verdict.reason });
-    }
-    const met = results.every((r) => r.met);
-    const reason = results.map((r) => `${r.met ? "✅" : "❌"} ${r.description}: ${r.evidence}`).join("\n");
-    return { met, reason, acceptanceResults: results };
-  }
-
-  if (checkTool) {
-    if (!runCheckTool) {
-      log.warn(`[verifyGoal] Check tool "${checkTool}" requested but no runCheckTool was provided — falling back to LLM verifier`);
-    } else {
-      try {
-        const result = await runCheckTool(checkTool, { goal });
-        return interpretCheckResult(result);
-      } catch (err) {
-        log.warn(`[verifyGoal] Check tool "${checkTool}" failed: ${(err as Error).message}`);
-        // Fall through to LLM verifier
-      }
-    }
-  }
-
-  try {
-    const verificationMessages: LLMMessage[] = [
-      ...messages,
-      {
-        role: "user",
-        content: `Evaluá si el siguiente objetivo ha sido cumplido basándote en la conversación anterior.\n\nObjetivo: "${goal}"\n\nRespondé en JSON:\n{"met": true/false, "reason": "explicación breve"}`,
-      },
-    ];
-
-    const response = await callLLM({ ...providerCfg, messages: verificationMessages, tools: undefined });
-
-    const content = response.content?.trim() || "";
-    const jsonMatch = content.match(/\{[^}]*\}/);
-    if (jsonMatch) {
-      const parsed = JSON.parse(jsonMatch[0]);
-      return { met: !!parsed.met, reason: parsed.reason || "No reason provided" };
-    }
-    return { met: false, reason: "Could not parse verification response" };
-  } catch (err) {
-    log.warn(`[verifyGoal] LLM verification failed: ${(err as Error).message}`);
-    return { met: false, reason: `Verification error: ${(err as Error).message}` };
-  }
-}
-
-/**
- * Interpret a check tool's result strictly: an object with a boolean `met`,
- * a bare boolean, or a JSON string with `met` — anything else is not met.
- */
-function interpretCheckResult(raw: unknown): { met: boolean; reason: string } {
-  if (typeof raw === "boolean") {
-    return { met: raw, reason: raw ? "Check tool returned true" : "Check tool returned false" };
-  }
-  if (raw && typeof raw === "object" && "met" in (raw as Record<string, unknown>)) {
-    const obj = raw as { met: unknown; reason?: unknown };
-    return { met: obj.met === true, reason: typeof obj.reason === "string" ? obj.reason : `Check tool met=${obj.met === true}` };
-  }
-  if (typeof raw === "string") {
-    const trimmed = raw.trim();
-    if (trimmed === "true" || trimmed === "false") {
-      return { met: trimmed === "true", reason: `Check tool returned "${trimmed}"` };
-    }
-    try {
-      const parsed = JSON.parse(trimmed);
-      if (parsed && typeof parsed === "object" && "met" in parsed) {
-        return { met: parsed.met === true, reason: typeof parsed.reason === "string" ? parsed.reason : `Check tool met=${parsed.met === true}` };
-      }
-      if (typeof parsed === "boolean") {
-        return { met: parsed, reason: `Check tool returned ${parsed}` };
-      }
-    } catch { /* not JSON */ }
-  }
-  return { met: false, reason: "Check tool result had no interpretable met/true signal" };
-}