@vellumai/assistant 0.8.4 → 0.8.6

package/src/tools/skills/skill-tool-factory.ts

@@ -1,6 +1,6 @@
 import type { SkillToolEntry } from "../../config/skills.js";
 import { RiskLevel } from "../../permissions/types.js";
-import type { ToolDefinition } from "../../providers/types.js";
+import { validateInputAgainstSchema } from "../../skills/validate-input.js";
 import type {
   ExecutionTarget,
   Tool,
@@ -15,39 +15,16 @@ const riskMap: Record<SkillToolEntry["risk"], RiskLevel> = {
   high: RiskLevel.High,
 };
 
-/**
- * Validate that all keys in `input` are declared in the tool's input_schema
- * properties. Returns an error result listing unknown parameters, or undefined
- * if validation passes.
- */
-function validateNoUnknownParams(
-  toolName: string,
-  input: Record<string, unknown>,
-  schema: SkillToolEntry["input_schema"],
-): ToolExecutionResult | undefined {
-  const properties = schema?.properties;
-  if (!properties) return undefined;
-
-  const knownKeys = new Set(Object.keys(properties));
-  const unknownKeys = Object.keys(input).filter((k) => !knownKeys.has(k));
-  if (unknownKeys.length === 0) return undefined;
-
-  const listed = unknownKeys.map((k) => `"${k}"`).join(", ");
-  const supported = [...knownKeys].map((k) => `"${k}"`).join(", ");
-  return {
-    content: `Unknown parameter${unknownKeys.length > 1 ? "s" : ""} ${listed} for tool "${toolName}". Supported parameters: ${supported}. Remove unsupported parameters and retry.`,
-    isError: true,
-  };
-}
-
 /**
  * Create a runtime Tool object from a manifest entry.
  * Maps SkillToolEntry metadata to the Tool interface and routes execution
- * through the skill script runner.
+ * through the skill script runner. Ownership (the originating skill id) is
+ * recorded by the tool registry at `registerSkillTools(skillId, tools)`
+ * time, not stamped on the `Tool` object — see
+ * {@link ../../tools/registry.getToolOwner}.
  */
 export function createSkillTool(
   entry: SkillToolEntry,
-  skillId: string,
   skillDir: string,
   versionHash: string,
   bundled?: boolean,
@@ -57,30 +34,25 @@ export function createSkillTool(
     description: entry.description,
     category: entry.category,
     defaultRiskLevel: riskMap[entry.risk],
-    origin: "skill",
-    ownerSkillId: skillId,
     executionTarget: entry.execution_target as ExecutionTarget,
-    ownerSkillVersionHash: versionHash,
-    ownerSkillBundled: bundled,
 
-    getDefinition(): ToolDefinition {
-      return {
-        name: entry.name,
-        description: entry.description,
-        input_schema: entry.input_schema as ToolDefinition["input_schema"],
-      };
-    },
+    input_schema: entry.input_schema as object,
 
     async execute(
       input: Record<string, unknown>,
       context: ToolContext,
     ): Promise<ToolExecutionResult> {
-      const validationError = validateNoUnknownParams(
+      const validation = validateInputAgainstSchema(
         entry.name,
         input,
-        entry.input_schema,
+        entry.input_schema as Record<string, unknown> | undefined,
       );
-      if (validationError) return validationError;
+      if (!validation.ok) {
+        return {
+          content: `Invalid input for tool "${entry.name}": ${validation.errors.join("; ")}. Fix the arguments and retry.`,
+          isError: true,
+        };
+      }
 
       return runSkillToolScript(skillDir, entry.executor, input, context, {
         target: entry.execution_target,
@@ -93,15 +65,17 @@ export function createSkillTool(
 
 /**
  * Create runtime Tool objects from all entries in a manifest.
+ * The caller is responsible for passing the resulting array to
+ * `registerSkillTools(skillId, tools)`, which is where ownership is
+ * recorded.
  */
 export function createSkillToolsFromManifest(
   entries: SkillToolEntry[],
-  skillId: string,
   skillDir: string,
   versionHash: string,
   bundled?: boolean,
 ): Tool[] {
   return entries.map((entry) =>
-    createSkillTool(entry, skillId, skillDir, versionHash, bundled),
+    createSkillTool(entry, skillDir, versionHash, bundled),
   );
 }

package/src/tools/subagent/notify-parent.ts

@@ -1,5 +1,4 @@
 import { RiskLevel } from "../../permissions/types.js";
-import type { ToolDefinition } from "../../providers/types.js";
 import { getSubagentManager } from "../../subagent/index.js";
 import { registerTool } from "../registry.js";
 import type { Tool, ToolContext, ToolExecutionResult } from "../types.js";
@@ -37,13 +36,10 @@ class NotifyParentTool implements Tool {
   description =
     "Send a notification to the parent conversation. Use this for important findings, when you're blocked, or when you have preliminary results the parent should know about. Do not overuse — notify for significant findings, not after every tool call.";
   category = "orchestration";
+  executionTarget = "sandbox" as const;
   defaultRiskLevel = RiskLevel.Low;
 
-  getDefinition(): ToolDefinition {
-    return {
-      name: this.name,
-      description: this.description,
-      input_schema: {
+  input_schema = {
         type: "object",
         properties: {
           message: {
@@ -63,9 +59,7 @@ class NotifyParentTool implements Tool {
           },
         },
         required: ["message", "activity"],
-      },
-    };
-  }
+      };
 
   async execute(
     input: Record<string, unknown>,

package/src/tools/subagent/spawn.ts

@@ -102,6 +102,9 @@ export async function executeSubagentSpawn(
         ...(inheritedOverrideProfile
           ? { overrideProfile: inheritedOverrideProfile }
           : {}),
+        ...(context.toolUseId
+          ? { parentToolUseId: context.toolUseId }
+          : {}),
         ...forkFields,
       },
       sendToClient as (msg: unknown) => void,

package/src/tools/system/request-permission.ts

@@ -1,5 +1,4 @@
 import { RiskLevel } from "../../permissions/types.js";
-import type { ToolDefinition } from "../../providers/types.js";
 import { registerTool } from "../registry.js";
 import type { Tool, ToolContext, ToolExecutionResult } from "../types.js";
 
@@ -57,13 +56,10 @@ class RequestSystemPermissionTool implements Tool {
     "Use when a tool fails with a permission/access error (e.g. 'Operation not permitted', 'EACCES', sandbox denial). " +
     "Do not explain how to open System Settings manually - this tool handles it with a clickable button.";
   category = "system";
+  executionTarget = "sandbox" as const;
   defaultRiskLevel = RiskLevel.High;
 
-  getDefinition(): ToolDefinition {
-    return {
-      name: this.name,
-      description: this.description,
-      input_schema: {
+  input_schema = {
         type: "object",
         properties: {
           permission_type: {
@@ -78,9 +74,7 @@ class RequestSystemPermissionTool implements Tool {
           },
         },
         required: ["permission_type", "activity"],
-      },
-    };
-  }
+      };
 
   async execute(
     input: Record<string, unknown>,

package/src/tools/terminal/shell.ts

@@ -4,7 +4,6 @@ import { spawn } from "node:child_process";
 import { getConfig } from "../../config/loader.js";
 import { isCesShellLockdownEnabled } from "../../credential-execution/feature-gates.js";
 import { RiskLevel } from "../../permissions/types.js";
-import type { ToolDefinition } from "../../providers/types.js";
 import { isUntrustedTrustClass } from "../../runtime/actor-trust-resolver.js";
 import { wakeAgentForOpportunity } from "../../runtime/agent-wake.js";
 import { redactSecrets } from "../../security/secret-scanner.js";
@@ -49,13 +48,10 @@ class ShellTool implements Tool {
   name = "bash";
   description = "Execute a shell command on the local machine";
   category = "terminal";
+  executionTarget = "sandbox" as const;
   defaultRiskLevel = RiskLevel.Medium;
 
-  getDefinition(): ToolDefinition {
-    return {
-      name: this.name,
-      description: this.description,
-      input_schema: {
+  input_schema = {
         type: "object",
         properties: {
           command: {
@@ -91,9 +87,7 @@ class ShellTool implements Tool {
           },
         },
         required: ["command", "activity"],
-      },
-    };
-  }
+      };
 
   async execute(
     input: Record<string, unknown>,

package/src/tools/tool-approval-handler.ts

@@ -10,7 +10,7 @@ import { createOrReuseToolGrantRequest } from "../runtime/tool-grant-request-hel
 import { redactSecrets } from "../security/secret-scanner.js";
 import { computeToolApprovalDigest } from "../security/tool-approval-digest.js";
 import { getLogger } from "../util/logger.js";
-import { getAllTools, getTool } from "./registry.js";
+import { getAllTools, getTool, getToolOwner } from "./registry.js";
 import { isSideEffectTool } from "./side-effects.js";
 import { summarizeToolInput } from "./tool-input-summary.js";
 import {
@@ -340,8 +340,12 @@ export class ToolApprovalHandler {
     const tool = getTool(name);
     if (!tool) {
       const allowedToolNames = context.allowedToolNames;
+      // List every registered tool. Tools that need an external resolver
+      // (computer-use, ui-surface, etc.) now return a structured error
+      // from their `execute()` when no resolver is connected, rather than
+      // being filtered out here — listing them surfaces a clearer path
+      // than hiding their names entirely.
       const available = getAllTools()
-        .filter((t) => t.executionMode !== "proxy" || context.proxyToolResolver)
         .map((t) => t.name)
         .filter((n) => !allowedToolNames || allowedToolNames.has(n))
         .sort()
@@ -368,8 +372,10 @@ export class ToolApprovalHandler {
 
     // Gate tools not active for the current turn
     if (context.allowedToolNames && !context.allowedToolNames.has(name)) {
-      const loadHint = tool.ownerSkillId
-        ? `Load the "${tool.ownerSkillId}" skill that provides this tool first.`
+      const owner = getToolOwner(name);
+      const ownerSkillId = owner?.kind === "skill" ? owner.id : undefined;
+      const loadHint = ownerSkillId
+        ? `Load the "${ownerSkillId}" skill that provides this tool first.`
         : `Load the skill that provides this tool first.`;
       const msg = `Tool "${name}" is not currently active. ${loadHint}`;
       const durationMs = Date.now() - startTime;

package/src/tools/tool-defaults.ts

@@ -0,0 +1,94 @@
+/**
+ * Single source of truth for the defaults applied when a `ToolDefinition`
+ * omits one of the normally-required fields, plus the `finalizeTool`
+ * helper that lifts a `ToolDefinition` into a `LoadedTool`.
+ *
+ * Plugins, external loaders, and any other registration boundary that
+ * accepts loose `ToolDefinition` objects from authors must run them
+ * through `finalizeTool` before handing the result to a `registerXxxTools`
+ * call. The registry types make this a hard rule: every registered tool
+ * is a `LoadedTool` (`Required<ToolDefinition> & { name }`).
+ */
+
+import type {
+  LoadedTool,
+  RiskLevel,
+  ToolDefinition,
+  ToolExecutionResult,
+} from "./types.js";
+
+/**
+ * Default values applied by `finalizeTool` when the author omits a field.
+ *
+ * - `description` defaults to empty — the model sees the tool name only
+ *   for un-documented tools, which is the correct minimal-info signal.
+ * - `defaultRiskLevel` defaults to `medium` — the safe middle band that
+ *   forces explicit approval for risky calls without spamming approval
+ *   prompts on no-op tools.
+ * - `input_schema` defaults to an empty closed object — the model is
+ *   allowed to call the tool with no arguments, and unknown arguments
+ *   are rejected at the JSON-schema layer.
+ * - `executionTarget` defaults to `sandbox` — author-supplied tool code
+ *   runs in the assistant container by default; opt in to `host` when
+ *   the tool proxies work to the connected client.
+ *
+ * `execute` has no constant default because the default closure needs to
+ * close over the tool's name to produce a useful error message; see
+ * `finalizeTool` below.
+ */
+export const TOOL_DEFAULTS = Object.freeze({
+  description: "",
+  defaultRiskLevel: "medium" as RiskLevel,
+  input_schema: Object.freeze({
+    type: "object",
+    properties: {},
+    additionalProperties: false,
+  }) as object,
+  executionTarget: "sandbox" as const,
+});
+
+/**
+ * Fill the four normally-required `ToolDefinition` fields with documented
+ * defaults when the author omitted them, attach the registration-time
+ * `name`, and return a `LoadedTool` that is safe to hand to a
+ * `registerXxxTools` call.
+ *
+ * The default `execute` returns an error result so the model sees a clear
+ * "this tool isn't wired up" signal at call time. The owning loader still
+ * registers the tool cleanly — a broken individual tool must never block
+ * the registration batch.
+ */
+export function finalizeTool(
+  tool: ToolDefinition,
+  name: string,
+): LoadedTool {
+  const description =
+    typeof tool.description === "string"
+      ? tool.description
+      : TOOL_DEFAULTS.description;
+  const defaultRiskLevel =
+    typeof tool.defaultRiskLevel === "string"
+      ? tool.defaultRiskLevel
+      : TOOL_DEFAULTS.defaultRiskLevel;
+  const input_schema =
+    tool.input_schema !== null && typeof tool.input_schema === "object"
+      ? tool.input_schema
+      : TOOL_DEFAULTS.input_schema;
+  const execute =
+    typeof tool.execute === "function"
+      ? tool.execute
+      : async (): Promise<ToolExecutionResult> => ({
+          content: `tool ${name} has no execute implementation`,
+          isError: true,
+        });
+  const executionTarget = tool.executionTarget ?? TOOL_DEFAULTS.executionTarget;
+  return {
+    ...tool,
+    name,
+    description,
+    defaultRiskLevel,
+    input_schema,
+    executionTarget,
+    execute,
+  };
+}

package/src/tools/tool-name-aliases.ts

@@ -1,19 +1,77 @@
-const TOOL_NAME_ALIASES = new Map<string, string>([
-  ["create_app", "app_create"],
+type ToolInputNormalizer = (
+  input: Record<string, unknown>,
+) => Record<string, unknown>;
+
+const TOOL_NAME_ALIASES = new Map<
+  string,
+  { canonicalName: string; normalizeInput?: ToolInputNormalizer }
+>([
+  ["create_app", { canonicalName: "app_create" }],
+  [
+    "computer_use_press_key",
+    {
+      canonicalName: "computer_use_key",
+      normalizeInput: normalizeLegacyComputerUsePressKeyInput,
+    },
+  ],
 ]);
 
-/**
- * Resolve high-confidence compatibility aliases before active-tool gating.
- * Keep this list narrow: aliases should only cover observed model drift where
- * the canonical target is active for the turn.
- */
-export function resolveToolNameAlias(
+export function resolveToolInvocationAlias(
   name: string,
+  input: Record<string, unknown>,
   allowedToolNames?: ReadonlySet<string>,
-): string {
-  if (allowedToolNames?.has(name)) return name;
-  const canonical = TOOL_NAME_ALIASES.get(name);
-  if (!canonical) return name;
-  if (allowedToolNames && !allowedToolNames.has(canonical)) return name;
-  return canonical;
+): { name: string; input: Record<string, unknown> } {
+  if (allowedToolNames?.has(name)) return { name, input };
+  const alias = TOOL_NAME_ALIASES.get(name);
+  if (!alias) return { name, input };
+  if (allowedToolNames && !allowedToolNames.has(alias.canonicalName)) {
+    return { name, input };
+  }
+  return {
+    name: alias.canonicalName,
+    input: alias.normalizeInput ? alias.normalizeInput(input) : input,
+  };
+}
+
+function normalizeLegacyComputerUsePressKeyInput(
+  input: Record<string, unknown>,
+): Record<string, unknown> {
+  const normalized = { ...input };
+  const key = typeof normalized.key === "string" ? normalized.key.trim() : "";
+  const modifiers = Array.isArray(normalized.modifiers)
+    ? normalized.modifiers.flatMap((modifier) => {
+        if (typeof modifier !== "string") return [];
+        const normalizedModifier = normalizeKeyModifier(modifier);
+        return normalizedModifier ? [normalizedModifier] : [];
+      })
+    : [];
+
+  delete normalized.modifiers;
+
+  if (key && modifiers.length > 0 && !key.includes("+")) {
+    normalized.key = [...new Set(modifiers), key.toLowerCase()].join("+");
+  } else if (key && !key.includes("+")) {
+    normalized.key = key.toLowerCase();
+  }
+
+  return normalized;
+}
+
+function normalizeKeyModifier(modifier: string): string | undefined {
+  switch (modifier.trim().toLowerCase()) {
+    case "cmd":
+    case "command":
+    case "meta":
+      return "cmd";
+    case "ctrl":
+    case "control":
+      return "ctrl";
+    case "option":
+    case "alt":
+      return "option";
+    case "shift":
+      return "shift";
+    default:
+      return undefined;
+  }
 }

package/src/tools/types.ts

@@ -5,7 +5,6 @@ import type {
   ProxyApprovalCallback,
   RiskLevel,
   SensitiveOutputBinding,
-  ToolDefinition,
   ToolExecutionErrorEvent,
   ToolExecutionStartEvent,
   ToolPermissionDeniedEvent,
@@ -64,7 +63,6 @@ export type {
   ProxyEnvVars,
   SensitiveOutputBinding,
   SensitiveOutputKind,
-  ToolDefinition,
   ToolExecutionErrorEvent,
   ToolExecutionStartEvent,
   ToolPermissionDeniedEvent,
@@ -76,19 +74,7 @@ export { RiskLevel } from "@vellumai/skill-host-contracts";
 // Assistant-side concrete overlays
 // ---------------------------------------------------------------------------
 
-/**
- * Public, narrow subset of {@link ToolExecutionResult} that plugin-authored
- * tools are responsible for producing. Re-exported from
- * `@vellumai/plugin-api` as `ToolExecutionResult` — the type name plugin
- * authors actually import. The daemon-internal version below extends
- * this and adds runtime-only fields (risk metadata, approval
- * bookkeeping, sensitive-output bindings, etc.) that the executor
- * populates around the call — plugins MUST NOT set those.
- *
- * Adding fields here is a non-breaking change; renaming or removing
- * fields is breaking and gated on a major bump of `@vellumai/plugin-api`.
- */
-export interface PluginToolExecutionResult {
+export interface ToolExecutionResult {
   /** Textual result shown to the model in the tool-result block. Empty string is valid. */
   content: string;
   /** When true, the agent loop treats `content` as an error and may surface it / retry. */
@@ -105,9 +91,6 @@ export interface PluginToolExecutionResult {
    * the LLM voluntarily end its turn.
    */
   yieldToUser?: boolean;
-}
-
-export interface ToolExecutionResult extends PluginToolExecutionResult {
   diff?: DiffInfo;
   /** Optional rich content blocks (e.g. images) to include alongside text in the tool result. */
   contentBlocks?: ContentBlock[];
@@ -211,20 +194,7 @@ export type ToolLifecycleEventHandler = (
   event: ToolLifecycleEvent,
 ) => void | Promise<void>;
 
-/**
- * Public, narrow subset of {@link ToolContext} handed to plugin-authored
- * tools. Re-exported from `@vellumai/plugin-api` as `ToolContext` — the
- * type name plugin authors actually import. The daemon-internal version
- * below extends this and adds host-only fields (CES client, trust class,
- * lifecycle handlers, requester metadata, host-bash proxy, etc.). Plugin
- * tools see this shape only — the runtime still hands them the full
- * {@link ToolContext} value, but the structural extension here guarantees
- * the assignment without a manual cast.
- *
- * Adding fields here is a non-breaking change; renaming or removing
- * fields is breaking and gated on a major bump of `@vellumai/plugin-api`.
- */
-export interface PluginToolContext {
+export interface ToolContext {
   /** Identifier of the conversation this tool invocation belongs to. */
   conversationId: string;
   /** Working directory the daemon was launched from. */
@@ -235,9 +205,6 @@ export interface PluginToolContext {
   signal?: AbortSignal;
   /** Optional incremental-output callback for streaming tools. Streaming tools should fall back to returning the full result in `content` when this is absent. */
   onOutput?: (chunk: string) => void;
-}
-
-export interface ToolContext extends PluginToolContext {
   /** Logical assistant scope for multi-assistant routing. */
   assistantId?: string;
   /** When set, the tool execution is part of a task run. Used to retrieve ephemeral permission rules. */
@@ -349,82 +316,46 @@ export interface ToolContext extends PluginToolContext {
   sourceActorPrincipalId?: string;
 }
 
-export interface Tool {
-  name: string;
-  description: string;
-  category: string;
-  defaultRiskLevel: RiskLevel;
-  /** When set to 'proxy', the tool is forwarded to a connected client rather than executed locally. */
-  executionMode?: "local" | "proxy";
-  /** Whether this tool is a core built-in, provided by a skill, contributed by a plugin, or from an MCP server. */
-  origin?: "core" | "skill" | "mcp" | "plugin";
-  /** If origin is 'skill', the ID of the owning skill. */
-  ownerSkillId?: string;
-  /** If origin is 'mcp', the ID of the owning MCP server. */
-  ownerMcpServerId?: string;
-  /** If origin is 'plugin', the name of the owning plugin. */
-  ownerPluginId?: string;
-  /** Content-hash of the owning skill's source at registration time. */
-  ownerSkillVersionHash?: string;
-  /** Whether the owning skill is bundled with the daemon (trusted first-party). */
-  ownerSkillBundled?: boolean;
-  /** Declared execution target from the skill manifest. Used by resolveExecutionTarget
-   * to accurately label lifecycle events for skill-provided tools. */
-  executionTarget?: ExecutionTarget;
-  getDefinition(): ToolDefinition;
-  execute(
-    input: Record<string, unknown>,
-    context: ToolContext,
-  ): Promise<ToolExecutionResult>;
-}
-
 /**
- * Plugin-facing tool shape. The narrow surface plugin authors implement;
- * differs from {@link Tool} in four ways:
- * - Plugins declare `input_schema` as a top-level field instead of
- *   implementing `getDefinition()`. The registration boundary synthesizes
- *   `getDefinition()` from `{name, description, input_schema}` before the
- *   tool enters the internal registry.
- * - `name` is derived from the tool file's basename by the external plugin
- *   loader.
- * - `category` is registry-owned and stamped to `"plugin"` when the tool is
- *   registered.
- * - All ownership stamps (`origin`, `ownerPluginId`, etc.) are set
- *   authoritatively by the bootstrap; plugin authors leave them blank.
- *
- * Every author-visible field is optional. The loader fills the four
- * normally-required slots (`description`, `defaultRiskLevel`,
- * `input_schema`, `execute`) with documented defaults when a plugin omits
- * them — see `applyPluginToolDefaults` in `external-plugin-loader.ts`.
- * A nameless, body-less `export default {}` is a valid (if useless) tool;
- * misconfigured tools surface at call time rather than blocking plugin
- * load.
+ * Author-facing tool spec — re-exported from `@vellumai/plugin-api`.
+ * Loaders fill documented defaults for omitted fields via `finalizeTool`
+ * in `tool-defaults.ts`.
  */
-export type PluginTool = Omit<
-  Tool,
-  "category" | "getDefinition" | "name" | "description" | "defaultRiskLevel"
-> & {
+export interface ToolDefinition {
+  /** Human-readable description shown to the model in the tool catalog. */
   description?: string;
+  /** Author-asserted risk band — low / medium / high. Drives default permission gating. */
   defaultRiskLevel?: RiskLevel;
+  /** JSON schema describing the tool's input arguments. */
   input_schema?: object;
+  /** Where the tool runs — sandbox (assistant container) or host (guardian device via proxy). Resolved by `resolveExecutionTarget` if omitted. */
+  executionTarget?: ExecutionTarget;
+  /** Implementation invoked when the model calls the tool. */
   execute?: (
     input: Record<string, unknown>,
     context: ToolContext,
   ) => Promise<ToolExecutionResult>;
+}
+
+/** Tool after the loader has derived its name and filled defaults. */
+export type LoadedTool = Required<ToolDefinition> & {
+  name: string;
 };
 
+/** The kind of extension that owns a tool. Core tools have no owner. */
+export type OwnerKind = "skill" | "mcp" | "plugin";
+
 /**
- * Plugin tool after the external loader has derived its registry name and
- * filled defaults for any author-omitted fields. All four normally-required
- * slots are guaranteed present.
+ * Identifies which extension owns a tool (skill / plugin / MCP server).
+ * Tracked by the tool registry keyed by tool name, not stored on the `Tool`
+ * object itself — query via {@link ../tools/registry.getToolOwner}.
  */
-export type LoadedPluginTool = PluginTool & {
-  name: string;
-  description: string;
-  defaultRiskLevel: RiskLevel;
-  input_schema: object;
-  execute: (
-    input: Record<string, unknown>,
-    context: ToolContext,
-  ) => Promise<ToolExecutionResult>;
-};
+export interface OwnerInfo {
+  kind: OwnerKind;
+  /** ID of the owning extension (skill id / plugin name / MCP server id). */
+  id: string;
+}
+
+export interface Tool extends LoadedTool {
+  category: string;
+}