@johpaz/hive-sdk 0.1.6 → 0.3.0

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

@@ -33,22 +33,9 @@ export const memoryWriteTool: Tool = {
     required: ["title", "content"],
   },
   execute: async (params: Record<string, unknown>) => {
-    const title = params.title as string;
-    const content = params.content as string;
-
     try {
-      const memoryCol = await col<MemoryDoc>("memory");
-      const existing = await memoryCol.get(title);
-      const now = Date.now();
-      await memoryCol.put(title, {
-        id: title,
-        title,
-        content,
-        created_at: existing?.doc.created_at ?? now,
-        updated_at: now,
-      }, existing ? { expectedVersion: existing.version } : { expectedVersion: 0 });
-
-      return { ok: true, title, message: "Memory saved." };
+      const entry = await writeMemory(params.title as string, params.content as string);
+      return { ok: true, title: entry.title, message: "Memory saved." };
     } catch (error) {
       return { ok: false, error: `Failed to save memory: ${(error as Error).message}` };
     }
@@ -69,21 +56,15 @@ export const memoryReadTool: Tool = {
   },
   execute: async (params: Record<string, unknown>) => {
     const title = params.title as string;
-
     try {
-      const memoryCol = await col<MemoryDoc>("memory");
-      const entry = await memoryCol.get(title);
-
-      if (!entry) {
-        return { ok: false, error: `Memory not found: ${title}` };
-      }
-
+      const entry = await readMemory(title);
+      if (!entry) return { ok: false, error: `Memory not found: ${title}` };
       return {
         ok: true,
-        title: entry.doc.title,
-        content: entry.doc.content,
-        createdAt: new Date(entry.doc.created_at).toISOString(),
-        updatedAt: new Date(entry.doc.updated_at).toISOString(),
+        title: entry.title,
+        content: entry.content,
+        createdAt: new Date(entry.createdAt).toISOString(),
+        updatedAt: new Date(entry.updatedAt).toISOString(),
       };
     } catch (error) {
       return { ok: false, error: `Failed to read memory: ${(error as Error).message}` };
@@ -102,15 +83,11 @@ export const memoryListTool: Tool = {
   },
   execute: async () => {
     try {
-      const memoryCol = await col<MemoryDoc>("memory");
-      const notes = (await memoryCol.scan({}))
-        .map(e => e.doc)
-        .sort((a, b) => b.updated_at - a.updated_at);
-
+      const entries = await listMemories();
       return {
         ok: true,
-        count: notes.length,
-        entries: notes.map((n) => ({ title: n.title, createdAt: new Date(n.created_at).toISOString() })),
+        count: entries.length,
+        entries: entries.map((n) => ({ title: n.title, createdAt: new Date(n.createdAt).toISOString() })),
       };
     } catch (error) {
       return { ok: false, error: `Failed to list memories: ${(error as Error).message}` };
@@ -132,23 +109,9 @@ export const memorySearchTool: Tool = {
   },
   execute: async (params: Record<string, unknown>) => {
     const query = params.query as string;
-    const needle = query.toLowerCase();
-
     try {
-      const memoryCol = await col<MemoryDoc>("memory");
-      const notes = (await memoryCol.scan({}))
-        .map(e => e.doc)
-        .filter(n => n.content.toLowerCase().includes(needle) || n.title.toLowerCase().includes(needle));
-
-      return {
-        ok: true,
-        query,
-        count: notes.length,
-        results: notes.map((n) => ({
-          title: n.title,
-          snippet: n.content.slice(0, 200) + (n.content.length > 200 ? "..." : ""),
-        })),
-      };
+      const results = await searchMemories(query);
+      return { ok: true, query, count: results.length, results };
     } catch (error) {
       return { ok: false, error: `Failed to search memories: ${(error as Error).message}` };
     }
@@ -169,17 +132,9 @@ export const memoryDeleteTool: Tool = {
   },
   execute: async (params: Record<string, unknown>) => {
     const title = params.title as string;
-
     try {
-      const memoryCol = await col<MemoryDoc>("memory");
-      const existing = await memoryCol.get(title);
-
-      if (!existing) {
-        return { ok: false, error: `Memory not found: ${title}` };
-      }
-
-      await memoryCol.delete(title);
-
+      const borrada = await deleteMemory(title);
+      if (!borrada) return { ok: false, error: `Memory not found: ${title}` };
       return { ok: true, title, message: "Memory deleted." };
     } catch (error) {
       return { ok: false, error: `Failed to delete memory: ${(error as Error).message}` };
@@ -1202,6 +1157,9 @@ export const busReadTool: Tool = {
 
 import crypto from "crypto";
 import { getAvailableModelsTool } from "./get-available-models.ts";
+// Las tools de memoria son envoltorios: la implementación vive en services/memory.ts,
+// para que una UI pueda usarla sin pasar por el formato que espera el modelo.
+import { writeMemory, readMemory, listMemories, searchMemories, deleteMemory } from "../../services/memory.ts";
 
 export function createTools(): Tool[] {
   return [

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

@@ -10,6 +10,7 @@ import type { Tool } from "../types.ts";
 import { logger } from "../../utils/logger.ts";
 import { resolveInWorkspace, getWorkspace, expandPath } from "../filesystem/workspace-guard.ts";
 import * as fs from "node:fs";
+import { loadConfig } from "../../config/loader.ts";
 
 const log = logger.child("cli-exec");
 
@@ -28,6 +29,53 @@ const BLOCKED_PATTERNS: Array<{ pattern: RegExp; reason: string }> = [
   { pattern: /format\s+[a-z]:/i, reason: "disk format (Windows)" },
 ];
 
+/** El primer token del comando: `git status` → `git`. Es lo que se compara. */
+function commandName(command: string): string {
+  const limpio = command.trim().replace(/^\s*(sudo|env|nohup)\s+/i, "");
+  return (limpio.split(/[\s;|&<>]/)[0] ?? "").split("/").pop() ?? "";
+}
+
+/**
+ * Aplica la política de comandos que el usuario configuró.
+ *
+ * `tools.exec.allowlist` y `.denylist` existían en el esquema de configuración y
+ * **no las leía nadie**: alguien podía escribir `denylist: ["curl", "rm"]`
+ * creyendo que restringía a sus agentes, y no restringía nada. En una opción de
+ * seguridad eso es peor que no tenerla, porque da confianza falsa.
+ *
+ * `BLOCKED_PATTERNS` sigue siendo incondicional: lo catastrófico se bloquea
+ * haya o no configuración. Esta capa es la que el usuario controla.
+ *
+ * Precedencia: si hay allowlist, sólo eso se permite (es la postura más
+ * restrictiva y la que alguien espera al escribirla). La denylist se aplica
+ * después, para poder tener una allowlist amplia con excepciones puntuales.
+ *
+ * Devuelve el motivo del rechazo, o `null` si no hay objeción.
+ */
+function checkExecPolicy(command: string): string | null {
+  const exec = loadConfig().tools?.exec;
+  if (!exec) return null;
+
+  if (exec.enabled === false) {
+    return "La ejecución de comandos está deshabilitada en la configuración";
+  }
+
+  const nombre = commandName(command).toLowerCase();
+  if (!nombre) return null;
+
+  const permitidos = exec.allowlist?.map((c) => c.toLowerCase());
+  if (permitidos?.length && !permitidos.includes(nombre)) {
+    return `Comando no permitido: "${nombre}". Permitidos: ${permitidos.join(", ")}`;
+  }
+
+  const denegados = exec.denylist?.map((c) => c.toLowerCase());
+  if (denegados?.includes(nombre)) {
+    return `Comando denegado por la configuración: "${nombre}"`;
+  }
+
+  return null;   // sin objeción
+}
+
 export const cliExecTool: Tool = {
   name: "cli_exec",
   // Long-running commands need a generous runtime ceiling (the tool allows
@@ -75,6 +123,13 @@ export const cliExecTool: Tool = {
       return { ok: false, error: `Working directory not found: ${cwd}` };
     }
 
+    // ── Política configurable por el usuario ──────────────────────────────────
+    const objecion = checkExecPolicy(command);
+    if (objecion) {
+      log.warn(`bloqueado por configuración: ${command}`);
+      return { ok: false, error: objecion };
+    }
+
     // ── Dangerous pattern check ────────────────────────────────────────────────
     for (const { pattern, reason } of BLOCKED_PATTERNS) {
       if (pattern.test(command)) {

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

@@ -136,6 +136,40 @@ function translateQueryToEnglish(query: string): string {
 
 // ─── search_knowledge ────────────────────────────────────────────────────────
 
+/**
+ * Las tools que el agente que pregunta puede realmente usar.
+ *
+ * El descubrimiento buscaba contra el índice global y devolvía cualquier
+ * coincidencia, sin mirar la lista blanca de quien preguntaba. La ejecución sí
+ * estaba protegida —`context-compiler.ts` recorta `allTools`, así que una tool
+ * fuera de la lista no se puede resolver ni llamar— pero el agente igual veía su
+ * nombre y su descripción. Filtrar acá cierra esa fuga y, de paso, deja de
+ * ofrecerle al modelo capacidades que no va a poder usar, que es una forma
+ * segura de hacerle perder un turno.
+ *
+ * Sin agente en el contexto (una llamada suelta, un test) no se filtra nada.
+ */
+async function allowedToolNames(agentId?: string): Promise<Set<string> | null> {
+  if (!agentId) return null;
+  try {
+    const agents = await col<AgentDoc>("agents");
+    const entry = await agents.get(agentId);
+    if (!entry) return null;
+
+    const raw = entry.doc.tool_allowlist_json ?? entry.doc.tools_json;
+    if (!raw) return null;   // sin lista declarada, descubrimiento abierto
+
+    const { expandToolAllowlist } = await import("../../agent/delegation-runtime.ts");
+    const patrones = JSON.parse(raw) as string[];
+    if (!Array.isArray(patrones) || patrones.length === 0) return new Set();
+
+    const { MINIMAL_TOOLS } = await import("../../agent/minimal-loadout.ts");
+    return new Set([...MINIMAL_TOOLS, ...expandToolAllowlist(patrones)]);
+  } catch {
+    return null;
+  }
+}
+
 export const searchKnowledgeTool: Tool = {
   name: "search_knowledge",
   description: "Busca en TODO el conocimiento de Hive: tools nativas, MCP, skills, agentes de catálogo y playbook.",
@@ -158,10 +192,11 @@ export const searchKnowledgeTool: Tool = {
     },
     required: ["query"],
   },
-  execute: async (params: Record<string, unknown>) => {
+  execute: async (params: Record<string, unknown>, config?: any) => {
     const query = params.query as string;
     const type = (params.type as string) ?? "all";
     const limit = (params.limit as number) ?? 10;
+    const usuarioActual = (config?.configurable?.user_id as string) ?? "";
     const MIN_RESULTS_FOR_BILINGUAL = 2;
 
     // Map the tool's `type` param onto capability types
@@ -187,6 +222,8 @@ export const searchKnowledgeTool: Tool = {
 
       const result: any = { query, type, tools: [], skills: [], playbook: [], toolsmcp: [], agents: [] };
 
+      const permitidas = await allowedToolNames(config?.configurable?.agent_id);
+
       // ─── Hydration from HiveDB collections (index stores only ids + search text) ──
 
       const coreCatalog = new Map(CORE_TOOL_CATALOG.map(t => [t.name, t]));
@@ -198,6 +235,10 @@ export const searchKnowledgeTool: Tool = {
       const agentsCol = await col<AgentDoc>("agents");
 
       async function hydrateTool(hit: CapabilityHit): Promise<any | null> {
+        // Ofrecerle al modelo una tool que no puede ejecutar es hacerle perder
+        // un turno, además de contarle qué existe fuera de su alcance.
+        if (permitidas && !permitidas.has(hit.rawId)) return null;
+
         const entry = await toolsCol.get(hit.rawId);
         if (entry) {
           const row = entry.doc;
@@ -232,6 +273,10 @@ export const searchKnowledgeTool: Tool = {
         const entry = await playbookCol.get(hit.rawId);
         const p = entry?.doc;
         if (!p || !p.active) return null;
+        // Mismo alcance que la inyección en el prompt: lo global más lo propio.
+        // Sin esto, el agente puede buscar en el playbook y leerle a un usuario
+        // lo que aprendió de otro, por la puerta de al lado.
+        if (p.user_id !== "" && p.user_id !== usuarioActual) return null;
         return {
           id: p.id, rule: p.rule, category: p.category,
           applicable_to: p.applicable_to ? JSON.parse(p.applicable_to) : null,
@@ -346,14 +391,17 @@ export const notifyTool: Tool = {
     required: ["message"],
   },
   execute: async (params: Record<string, unknown>, config?: any) => {
-    const { sendToUserChannel } = await import("../../gateway/channel-notify");
+    const { sendToUserChannel } = await import("../../gateway/channel-notify.ts");
     const message = params.message as string;
     const channel = (config?.configurable?.channel as string) ?? "webchat";
     const userId = (config?.configurable?.user_id as string) ?? "";
 
     log.info(`[notify] Sending to ${channel}/${userId}: ${message.substring(0, 80)}`);
 
-    const result = await sendToUserChannel(channel, userId, message)
+    // El aviso tiene que volver al hilo del que salió: sin el threadId,
+    // `notifyChannel` no sabe a qué conversación del canal responder.
+    const threadId = config?.configurable?.thread_id as string | undefined;
+    const result = await sendToUserChannel(channel, userId, message, { threadId })
     if (!result.ok) throw new Error(`Channel send failed: ${result.error}`)
     return result
   },
@@ -423,7 +471,7 @@ export const reportProgressTool: Tool = {
     required: ["progress", "message"],
   },
   execute: async (params: Record<string, unknown>, config?: any) => {
-    const { sendToUserChannel } = await import("../../gateway/channel-notify");
+    const { sendToUserChannel } = await import("../../gateway/channel-notify.ts");
     const progress = params.progress as number;
     const message = params.message as string;
     const taskId = (params.task_id as string) ?? null;

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

@@ -8,11 +8,11 @@
  * @category cron
  */
 
-import type { Tool } from "../types";
-import { col, toIndexable } from "../../storage/hive";
-import type { UserDoc, UserIdentityDoc, ChannelDoc, CronJobDoc, TaskRunDoc } from "../../storage/collections";
-import { logger } from "../../utils/logger";
-import { Cron } from "croner";
+import type { Tool } from "../types.ts";
+import { col, toIndexable } from "../../storage/hive.ts";
+import type { UserDoc, UserIdentityDoc, ChannelDoc, CronJobDoc, TaskRunDoc } from "../../storage/collections.ts";
+import { logger } from "../../utils/logger.ts";
+import { Cron } from "../../scheduler/cron/index.ts";
 
 const log = logger.child("CronTools");
 
@@ -114,9 +114,9 @@ export const cronCreateTool: Tool = {
       tool_name: { type: "string", description: "Specific tool to execute (optional)" },
       max_runs: { type: "number", description: "Maximum executions (optional, null = unlimited)" },
       channel: { type: "string", description: "Notification channel (system, telegram, discord, whatsapp, cli)" },
-      start_at: { type: "string", description: "ISO 8601 datetime: start of execution window (Croner startAt). Optional." },
-      stop_at: { type: "string", description: "ISO 8601 datetime: end of execution window (Croner stopAt). Optional." },
-      dom_and_dow: { type: "boolean", description: "If true, both day-of-month AND day-of-week must match (Croner domAndDow). Default: false (OR logic)" },
+      start_at: { type: "string", description: "ISO 8601 datetime: start of execution window. Optional." },
+      stop_at: { type: "string", description: "ISO 8601 datetime: end of execution window. Optional." },
+      dom_and_dow: { type: "boolean", description: "If true, both day-of-month AND day-of-week must match. Default: false (OR logic)" },
     },
     required: ["name", "task", "task_type"],
   },

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

@@ -0,0 +1,130 @@
+/**
+ * Tools de imagen — redimensionar, convertir y medir.
+ *
+ * Se apoyan en `Bun.Image` (ver `images/`), así que no agregan dependencias: el
+ * SDK ya exige Bun ≥ 1.4.
+ *
+ * Trabajan sobre **artefactos**, no sobre base64 suelto, y eso es deliberado.
+ * Devolver una imagen en base64 al modelo es exactamente lo que llena la
+ * ventana de contexto —el problema que `mcp-result-normalizer.ts` existe para
+ * evitar—. Acá la entrada es un `artifact_id` y la salida es otro: el modelo
+ * maneja referencias y sólo mira la imagen si de verdad la necesita.
+ *
+ * Como cualquier otra tool, se activan o desactivan desde el catálogo.
+ */
+
+import type { Tool } from "../types.ts";
+import { createArtifact, readArtifactBytes } from "../../artifacts/store.ts";
+import { measureImage, transformImage, imagesSupported, type ImageFormat } from "../../images/index.ts";
+import { resolveUserId } from "../../storage/onboarding.ts";
+import { logger } from "../../utils/logger.ts";
+
+const log = logger.child("tools/images");
+
+const FORMATOS: ImageFormat[] = ["jpeg", "png", "webp", "avif", "heic"];
+
+/** Mensaje común: sin Bun 1.4 estas tools no pueden hacer nada. */
+function sinSoporte() {
+  return { ok: false, error: "El procesamiento de imágenes necesita Bun >= 1.4 (Bun.Image no está disponible)" };
+}
+
+async function leerArtefacto(artifactId: string) {
+  const datos = await readArtifactBytes(artifactId);
+  if (!datos) return null;
+  return datos;
+}
+
+export const imageMetadataTool: Tool = {
+  name: "image_metadata",
+  description:
+    "Lee las dimensiones y el formato de una imagen guardada, sin abrirla ni cargarla al contexto. " +
+    "Spanish: medir imagen, dimensiones de la imagen, tamaño de la foto, formato de imagen",
+  parameters: {
+    type: "object",
+    properties: {
+      artifact_id: { type: "string", description: "Id del artefacto que contiene la imagen" },
+    },
+    required: ["artifact_id"],
+  },
+  execute: async (params: Record<string, unknown>) => {
+    if (!imagesSupported()) return sinSoporte();
+    const id = params.artifact_id as string;
+    try {
+      const datos = await leerArtefacto(id);
+      if (!datos) return { ok: false, error: `No encontré el artefacto ${id}` };
+      const meta = await measureImage(datos.bytes);
+      return { ok: true, artifact_id: id, ...meta, bytes: datos.bytes.length };
+    } catch (error) {
+      return { ok: false, error: `No pude leer la imagen: ${(error as Error).message}` };
+    }
+  },
+};
+
+export const imageTransformTool: Tool = {
+  name: "image_transform",
+  description:
+    "Redimensiona, rota o convierte de formato una imagen guardada y devuelve un artefacto nuevo. " +
+    "El original no se toca. Spanish: redimensionar imagen, cambiar tamaño, convertir a webp, " +
+    "comprimir imagen, rotar foto, achicar imagen",
+  parameters: {
+    type: "object",
+    properties: {
+      artifact_id: { type: "string", description: "Id del artefacto de origen" },
+      width: { type: "number", description: "Ancho en píxeles. Si sólo se da uno, se mantiene la proporción" },
+      height: { type: "number", description: "Alto en píxeles" },
+      format: { type: "string", description: "Formato de salida", enum: FORMATOS },
+      quality: { type: "number", description: "1–100, sólo para formatos con pérdida", minimum: 1, maximum: 100 },
+      rotate: { type: "number", description: "Grados: 90, 180 o 270" },
+    },
+    required: ["artifact_id"],
+  },
+  execute: async (params: Record<string, unknown>) => {
+    if (!imagesSupported()) return sinSoporte();
+    const id = params.artifact_id as string;
+
+    const formato = params.format as ImageFormat | undefined;
+    if (formato && !FORMATOS.includes(formato)) {
+      return { ok: false, error: `Formato no soportado: ${formato}. Disponibles: ${FORMATOS.join(", ")}` };
+    }
+
+    try {
+      const datos = await leerArtefacto(id);
+      if (!datos) return { ok: false, error: `No encontré el artefacto ${id}` };
+
+      const { bytes, metadata } = await transformImage(datos.bytes, {
+        width: params.width as number | undefined,
+        height: params.height as number | undefined,
+        format: formato,
+        quality: params.quality as number | undefined,
+        rotate: params.rotate as number | undefined,
+      });
+
+      const userId = (await resolveUserId({}).catch(() => null)) ?? "";
+      const artefacto = await createArtifact({
+        bytes,
+        mimeType: `image/${metadata.format}`,
+        kind: "image",
+        userId,
+      });
+
+      log.info(`imagen ${id} → ${artefacto.id} (${metadata.width}x${metadata.height} ${metadata.format})`);
+      // Se devuelve la referencia, nunca los bytes: el base64 en el contexto es
+      // justo lo que se quiere evitar.
+      return {
+        ok: true,
+        artifact_id: artefacto.id,
+        width: metadata.width,
+        height: metadata.height,
+        format: metadata.format,
+        bytes: bytes.length,
+        original_bytes: datos.bytes.length,
+      };
+    } catch (error) {
+      return { ok: false, error: `No pude transformar la imagen: ${(error as Error).message}` };
+    }
+  },
+};
+
+export function createTools(): Tool[] {
+  return [imageMetadataTool, imageTransformTool];
+}

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

@@ -13,8 +13,9 @@ import * as filesystem from "./filesystem/index.ts";
 
 // Web (10)
 import * as web from "./web/index.ts";
+import * as images from "./images/index.ts";
 
-// Cron (8) - Croner-based scheduler tools
+// Cron (8) - scheduler tools
 import * as cron from "./cron/index.ts";
 
 // CLI (1)
@@ -70,6 +71,7 @@ export function createAllTools(config: Config): Tool[] {
 
     // WEB (10)
     ...web.createTools(),
+    ...images.createTools(),
 
     // CRON (8)
     ...cron.createTools(),
@@ -215,3 +217,14 @@ export {
 export {
   apiRequestTool,
 } from "./api/index.ts";
+
+// Arranque del navegador. Las browser tools existen en el catálogo desde el
+// seed, pero no operan hasta que alguien levanta el servicio: quien construya
+// sobre el SDK necesita poder hacerlo sin importar rutas internas.
+export {
+  initializeBrowserService,
+  getBrowserService,
+  shutdownBrowser,
+} from "./web/browser-service.ts";
+
+export * from "./images/index.ts";

package/packages/core/src/tools/office/office-escribir-xlsx.ts

@@ -10,6 +10,7 @@ import type { Tool } from "../types.ts";
 import { logger } from "../../utils/logger.ts";
 import * as path from "node:path";
 import * as fs from "node:fs";
+import { cargarXlsx } from "./xlsx-loader.ts";
 
 const log = logger.child("office-escribir-xlsx");
 
@@ -55,7 +56,7 @@ export const officeEscribirXlsxTool: Tool = {
     log.debug(`Generando XLSX: ${ruta}`);
 
     try {
-      const XLSX = await import("xlsx");
+      const XLSX = await cargarXlsx();
 
       const workbook = XLSX.utils.book_new();
 

package/packages/core/src/tools/office/office-leer-xlsx.ts

@@ -10,6 +10,7 @@ import type { Tool } from "../types.ts";
 import { logger } from "../../utils/logger.ts";
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { cargarXlsx } from "./xlsx-loader.ts";
 
 const log = logger.child("office-leer-xlsx");
 
@@ -55,7 +56,7 @@ export const officeLeerXlsxTool: Tool = {
         return { ok: false, error: `Archivo no encontrado: ${rutaAbsoluta}` };
       }
 
-      const XLSX = await import("xlsx");
+      const XLSX = await cargarXlsx();
       const buffer = fs.readFileSync(rutaAbsoluta);
       const workbook = XLSX.read(buffer, { type: "buffer" });
 

package/packages/core/src/tools/office/xlsx-loader.ts

@@ -0,0 +1,19 @@
+/**
+ * Carga el lector de hojas de cálculo, o explica por qué no puede.
+ *
+ * `xlsx` se importa en caliente para no pagarlo en cada arranque, y eso deja el
+ * fallo a merced del momento: si la dependencia no llegó a instalarse —su
+ * tarball se cayó una vez en mitad de un release— el usuario recibía un
+ * "Cannot find module" crudo en medio de una respuesta.
+ */
+export async function cargarXlsx(): Promise<typeof import("xlsx")> {
+  try {
+    return await import("xlsx");
+  } catch (error) {
+    throw new Error(
+      "El soporte de hojas de cálculo no está disponible en esta instalación: " +
+        `falta la dependencia «xlsx» (${(error as Error).message}). ` +
+        "Reinstala las dependencias con `bun install` para recuperarlo.",
+    );
+  }
+}

package/packages/core/src/tools/web/artifact-inspect.ts

@@ -1,5 +1,5 @@
-import type { Tool } from "../types";
-import { inspectArtifact } from "../../artifacts/store";
+import type { Tool } from "../types.ts";
+import { inspectArtifact } from "../../artifacts/store.ts";
 
 export const artifactInspectTool: Tool = {
   name: "artifact_inspect",