@notis_ai/cli 0.2.0-beta.41.1 → 0.2.0-beta.48.1

package/README.md

@@ -179,9 +179,9 @@ Examples:
 
 ### `npx --package @notis_ai/cli@latest -- notis tools toolkits`
 
-List toolkit namespaces available to the active user.
+List toolkit namespaces and connection statuses available to the active user.
 
-When to use: Use this before searching or executing generic tools.
+When to use: Use this to inspect connection state before searching or executing generic tools.
 
 Examples:
 - `npx --package @notis_ai/cli@latest -- notis tools toolkits`
@@ -194,11 +194,11 @@ Search across toolkit namespaces using natural language.
 When to use: Use this when you need a generic capability that does not have a first-class CLI command.
 
 Options:
-- `--toolkits <csv-or-json>` — Optional subset of toolkit ids to search.
+- `--known-fields <text>` — Optional known field hints, such as channel_name:general or user_email:a@example.com.
 
 Examples:
 - `npx --package @notis_ai/cli@latest -- notis tools search "send an email"`
-- `npx --package @notis_ai/cli@latest -- notis tools search "update framer page" --toolkits mcp-framer`
+- `npx --package @notis_ai/cli@latest -- notis tools search "post on LinkedIn" --known-fields "platform:linkedin"`
 
 ### `npx --package @notis_ai/cli@latest -- notis tools describe <tool-name>`
 
@@ -206,12 +206,9 @@ Describe a generic tool by name.
 
 When to use: Use this when you know the tool name and want its parameter schema before execution.
 
-Options:
-- `--toolkits <csv-or-json>` — Optional subset of toolkit ids to search.
-
 Examples:
 - `npx --package @notis_ai/cli@latest -- notis tools describe composio-gmail-default-send_email`
-- `npx --package @notis_ai/cli@latest -- notis tools describe notis-default-query --toolkits notis-default`
+- `npx --package @notis_ai/cli@latest -- notis tools describe notis-default-query`
 
 ### `npx --package @notis_ai/cli@latest -- notis tools exec <tool-name>`
 
@@ -224,7 +221,6 @@ Options:
 - `--file <argument-path=local-path>` — Upload a local file into a file-uploadable tool argument. Repeatable.
 - `--get-schema` — Display the tool parameter schema without executing.
 - `--dry-run` — Validate arguments against the tool schema without executing.
-- `--toolkits <csv-or-json>` — Optional toolkit namespace(s) to use when resolving the tool.
 
 Examples:
 - `npx --package @notis_ai/cli@latest -- notis tools exec notis-default-query --arguments '{"database_slug":"tasks","query":{}}'`
@@ -272,7 +268,7 @@ Examples:
 
 ### `npx --package @notis_ai/cli@latest -- notis whoami`
 
-Display the active profile, user, and available toolkits.
+Display the active profile, user, and available toolkit connection statuses.
 
 When to use: Use this to quickly confirm which account and environment a command will target.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@notis_ai/cli",
-  "version": "0.2.0-beta.41.1",
+  "version": "0.2.0-beta.48.1",
   "description": "Agent-first Notis CLI for apps and generic tool execution",
   "type": "module",
   "bin": {

package/skills/notis-cli/SKILL.md

@@ -130,7 +130,7 @@ This is the main escape hatch for:
    - `npx --package @notis_ai/cli@latest -- notis tools toolkits`
 2. Search for the capability you need using natural language:
    - `npx --package @notis_ai/cli@latest -- notis tools search "<query>"`
-   - optionally narrow with `--toolkits <csv-or-json>`
+   - optionally add known field hints with `--known-fields "<key:value>"`
 3. If needed, inspect the exact tool and parameter schema:
    - `npx --package @notis_ai/cli@latest -- notis tools describe <tool-name>`
    - `npx --package @notis_ai/cli@latest -- notis tools exec <tool-name> --get-schema`

package/src/command-specs/apps.js

@@ -447,7 +447,7 @@ function databaseMaterializationWarnings(apps) {
 async function assertDirectDeployAccess(runtime, appId) {
   const result = await runToolCommand({
     runtime,
-    toolName: 'notis_list_apps',
+    toolName: 'notis-default-list_apps',
   });
   const apps = result.payload.apps || [];
   const hasAccess = apps.some((app) => (app.app_id || app.id) === appId);
@@ -463,7 +463,7 @@ async function assertDirectDeployAccess(runtime, appId) {
 async function appsListHandler(ctx) {
   const result = await runToolCommand({
     runtime: ctx.runtime,
-    toolName: 'notis_list_apps',
+    toolName: 'notis-default-list_apps',
   });
   const apps = result.payload.apps || [];
   return ctx.output.emitSuccess({
@@ -511,7 +511,7 @@ async function appsCreateHandler(ctx) {
   const idempotencyKey = nextIdempotencyKey(ctx.globalOptions);
   const result = await runToolCommand({
     runtime: ctx.runtime,
-    toolName: 'notis_create_app',
+    toolName: 'notis-default-create_app',
     arguments_: {
       name: ctx.args.name,
       description: appConfig?.description || undefined,
@@ -1073,7 +1073,7 @@ async function appsDeployHandler(ctx) {
   try {
     result = await runToolCommand({
       runtime: ctx.runtime,
-      toolName: 'notis_save_app_files',
+      toolName: 'notis-default-save_app_files',
       arguments_: {
         app_id: appId,
         files,
@@ -1185,7 +1185,7 @@ export const appsCommandSpecs = [
     examples: ['notis apps list', 'notis apps list --json'],
     mutates: false,
     idempotent: true,
-    backend_call: { type: 'tool', name: 'notis_list_apps' },
+    backend_call: { type: 'tool', name: 'notis-default-list_apps' },
     handler: appsListHandler,
   },
   {
@@ -1242,7 +1242,7 @@ export const appsCommandSpecs = [
     ],
     mutates: true,
     idempotent: false,
-    backend_call: { type: 'tool', name: 'notis_create_app' },
+    backend_call: { type: 'tool', name: 'notis-default-create_app' },
     handler: appsCreateHandler,
   },
   {
@@ -1376,7 +1376,7 @@ export const appsCommandSpecs = [
     examples: ['notis apps deploy', 'notis apps deploy --skip-build', 'notis apps deploy --app-id abc123', 'notis apps deploy --direct'],
     mutates: true,
     idempotent: true,
-    backend_call: { type: 'tool', name: 'notis_save_app_files' },
+    backend_call: { type: 'tool', name: 'notis-default-save_app_files' },
     handler: appsDeployHandler,
   },
   {

package/src/command-specs/helpers.js

@@ -17,23 +17,6 @@ export function parseMaybeJson(value, label) {
   return parseJson(value, label);
 }
 
-export function normalizeToolkits(value) {
-  if (!value) {
-    return [];
-  }
-  if (value.startsWith('[')) {
-    const parsed = parseJson(value, 'toolkits');
-    if (!Array.isArray(parsed)) {
-      throw usageError('toolkits JSON must be an array of toolkit strings');
-    }
-    return parsed;
-  }
-  return value
-    .split(',')
-    .map((entry) => entry.trim())
-    .filter(Boolean);
-}
-
 export function nextIdempotencyKey(globalOptions) {
   return globalOptions.idempotencyKey || randomUUID();
 }
@@ -57,28 +40,19 @@ export async function runToolCommand({
 }
 
 export async function fetchToolkits(runtime) {
-  const result = await runToolCommand({
-    runtime,
-    toolName: 'notis_find_toolkits',
-  });
-  return result.payload.toolkits || [];
-}
-
-export async function resolveSearchToolkits(runtime, rawToolkits) {
-  const toolkits = normalizeToolkits(rawToolkits);
-  if (toolkits.length) {
-    return toolkits;
-  }
-  const availableToolkits = await fetchToolkits(runtime);
-  return availableToolkits.map((entry) => entry.id);
+  const payload = await fetchToolDiscovery(runtime, 'List available toolkit namespaces and connection statuses');
+  return (payload.toolkit_connection_statuses || []).map((entry) => ({
+    id: entry.toolkit,
+    provider: typeof entry.toolkit === 'string' ? entry.toolkit.split('-', 1)[0] : undefined,
+    description: entry.description || entry.status_message || entry.toolkit,
+    has_active_connection: Boolean(entry.has_active_connection),
+    status_message: entry.status_message || '',
+    connection_details: entry.connection_details || {},
+  }));
 }
 
 export async function probeAuth(runtime) {
-  const result = await runToolCommand({
-    runtime,
-    toolName: 'notis_find_toolkits',
-  });
-  return result.payload;
+  return fetchToolDiscovery(runtime, 'List available toolkit namespaces and connection statuses');
 }
 
 export async function healthCheck(runtime) {
@@ -90,22 +64,69 @@ export async function healthCheck(runtime) {
   });
 }
 
-export async function fetchToolSchema(runtime, toolName, rawToolkits) {
-  const toolkits = normalizeToolkits(rawToolkits);
+export async function fetchToolSchema(runtime, toolName) {
+  const canonicalHints = canonicalToolHints(toolName);
+  const payload = await fetchToolDiscovery(
+    runtime,
+    canonicalHints.useCase,
+    canonicalHints.knownFields,
+  );
+  const schema = payload.tool_schemas?.[toolName];
+  if (!schema) {
+    throw usageError(`Tool "${toolName}" not found.`);
+  }
+  return {
+    name: toolName,
+    toolkit_id: schema.toolkit,
+    description: schema.description || '',
+    parameters: schema.input_schema || { type: 'object', properties: {} },
+    output_schema: schema.output_schema || {},
+    schema_available: Boolean(schema.hasFullSchema),
+  };
+}
+
+function canonicalToolHints(toolName) {
+  const rawName = String(toolName || '').trim();
+  const parts = rawName.split('-').filter(Boolean);
+  if (parts.length < 3) {
+    return {
+      useCase: `Describe the ${rawName} tool schema`,
+      knownFields: `tool_name:${rawName}`,
+    };
+  }
+
+  const provider = parts[0];
+  const action = parts[parts.length - 1];
+  const toolkitParts = parts.slice(1, -1);
+  const toolkit = [provider, ...toolkitParts].join('-');
+  const providerToolkit = toolkitParts[0] || '';
+  const knownFields = [
+    `tool_name:${rawName}`,
+    `provider:${provider}`,
+    `toolkit:${toolkit}`,
+    providerToolkit ? `toolkit_slug:${providerToolkit}` : null,
+    `action:${action}`,
+  ].filter(Boolean).join(' ');
+
+  return {
+    useCase: `Describe the ${action} schema for ${toolkit}`,
+    knownFields,
+  };
+}
+
+export async function fetchToolDiscovery(runtime, useCase, knownFields = '') {
+  const query = { use_case: useCase };
+  if (knownFields) {
+    query.known_fields = knownFields;
+  }
   const result = await runToolCommand({
     runtime,
     toolName: 'notis_find_tools',
     arguments_: {
-      query: toolName,
-      ...(toolkits.length ? { toolkits } : {}),
+      queries: [query],
     },
   });
-  const tools = result.payload.tools || [];
-  const match = tools.find((t) => t.name === toolName);
-  if (!match) {
-    throw usageError(`Tool "${toolName}" not found.`);
-  }
-  return match;
+  return result.payload || {};
 }
 
 export function validateArguments(schema, args) {

package/src/command-specs/meta.js

@@ -21,7 +21,7 @@ async function doctorHandler(ctx) {
   if (ctx.runtime.jwt) {
     try {
       const payload = await probeAuth(ctx.runtime);
-      checks.tool_roundtrip = Array.isArray(payload.toolkits) ? 'ok' : 'error';
+      checks.tool_roundtrip = Array.isArray(payload.toolkit_connection_statuses) ? 'ok' : 'error';
     } catch {
       checks.tool_roundtrip = 'error';
     }
@@ -68,7 +68,7 @@ function decodeJwtUserId(jwt) {
 
 async function whoamiHandler(ctx) {
   const payload = await probeAuth(ctx.runtime);
-  const toolkits = payload.toolkits || [];
+  const toolkits = payload.toolkit_connection_statuses || [];
   const userId = decodeJwtUserId(ctx.runtime.jwt);
 
   return ctx.output.emitSuccess({
@@ -78,7 +78,7 @@ async function whoamiHandler(ctx) {
       api_base: ctx.runtime.apiBase,
       user_id: userId,
       toolkit_count: toolkits.length,
-      toolkits: toolkits.map((t) => t.id),
+      toolkits: toolkits.map((t) => t.toolkit),
       cli_version: ctx.runtime.cliVersion,
     },
     humanSummary: `Logged in as ${userId || 'unknown'} via profile "${ctx.runtime.profileName}"`,
@@ -91,7 +91,7 @@ async function whoamiHandler(ctx) {
         `Version:   ${ctx.runtime.cliVersion}`,
       ].join('\n'),
     hints: [
-      { command: 'notis tools toolkits', reason: 'List available toolkit namespaces' },
+      { command: 'notis tools toolkits', reason: 'List available toolkit namespaces and connection statuses' },
       { command: 'notis doctor', reason: 'Run a full health check' },
     ],
   });
@@ -110,7 +110,7 @@ async function describeHandler(ctx) {
 export const metaCommandSpecs = [
   {
     command_path: ['whoami'],
-    summary: 'Display the active profile, user, and available toolkits.',
+    summary: 'Display the active profile, user, and available toolkit connection statuses.',
     when_to_use: 'Use this to quickly confirm which account and environment a command will target.',
     args_schema: { arguments: [], options: [] },
     examples: ['notis whoami', 'notis whoami --json'],
@@ -118,7 +118,7 @@ export const metaCommandSpecs = [
     mutates: false,
     idempotent: true,
     related_commands: ['notis doctor'],
-    backend_call: { type: 'tool', name: 'notis_find_toolkits' },
+    backend_call: { type: 'tool', name: 'notis_find_tools' },
     handler: whoamiHandler,
   },
   {

package/src/command-specs/tools.js

@@ -3,13 +3,12 @@ import { createHash } from 'node:crypto';
 import { basename } from 'node:path';
 import { usageError } from '../runtime/errors.js';
 import {
+  fetchToolDiscovery,
   fetchToolkits,
   fetchToolSchema,
   nextIdempotencyKey,
   parseJson,
   parseMaybeJson,
-  normalizeToolkits,
-  resolveSearchToolkits,
   runToolCommand,
   validateArguments,
 } from './helpers.js';
@@ -142,27 +141,55 @@ async function toolsToolkitsHandler(ctx) {
     data: { toolkits },
     humanSummary: `Found ${toolkits.length} toolkits`,
     hints: [
-      { command: 'notis tools search <query>', reason: 'Search for tools in these toolkits' },
+      { command: 'notis tools search <query>', reason: 'Search canonical tools and schemas' },
     ],
-    renderHuman: () => toolkits.map((entry) => `${entry.id}  ${entry.description}`).join('\n'),
+    renderHuman: () =>
+      toolkits
+        .map((entry) => {
+          const status = entry.has_active_connection ? 'connected' : 'needs auth';
+          return `${entry.id}  ${status}  ${entry.description}`;
+        })
+        .join('\n'),
   });
 }
 
+function discoveryToolRows(payload) {
+  const schemas = payload.tool_schemas || {};
+  const statuses = new Map(
+    (payload.toolkit_connection_statuses || [])
+      .filter((entry) => entry && typeof entry.toolkit === 'string')
+      .map((entry) => [entry.toolkit, entry])
+  );
+  const seen = new Set();
+  const rows = [];
+  for (const result of payload.results || []) {
+    for (const name of [...(result.primary_tool_slugs || []), ...(result.related_tool_slugs || [])]) {
+      if (!name || seen.has(name)) continue;
+      seen.add(name);
+      const schema = schemas[name] || {};
+      const toolkit = schema.toolkit || name.split('-').slice(0, -1).join('-');
+      const status = statuses.get(toolkit);
+      rows.push({
+        name,
+        toolkit,
+        description: schema.description || '',
+        schema_available: Boolean(schemas[name]),
+        connection_status: status
+          ? (status.has_active_connection ? 'connected' : 'needs auth')
+          : 'unknown',
+      });
+    }
+  }
+  return rows;
+}
+
 async function toolsSearchHandler(ctx) {
-  const toolkits = await resolveSearchToolkits(ctx.runtime, ctx.options.toolkits);
-  const result = await runToolCommand({
-    runtime: ctx.runtime,
-    toolName: 'notis_find_tools',
-    arguments_: {
-      query: ctx.args.query || undefined,
-      toolkits,
-    },
-  });
-  const tools = result.payload.tools || [];
+  const payload = await fetchToolDiscovery(ctx.runtime, ctx.args.query || 'Find tools', ctx.options.knownFields || '');
+  const tools = discoveryToolRows(payload);
   const firstTool = tools[0];
   return ctx.output.emitSuccess({
     command: ctx.spec.command_path.join(' '),
-    data: { toolkits, tools },
+    data: payload,
     humanSummary: `Found ${tools.length} tools`,
     hints: firstTool
       ? [
@@ -172,31 +199,18 @@ async function toolsSearchHandler(ctx) {
       : [],
     renderHuman: () =>
       tools
-        .map((tool) => `${tool.name}\n  ${tool.toolkit_id || 'unknown toolkit'}\n  ${tool.description || 'No description'}\n`)
+        .map((tool) => `${tool.name}\n  toolkit: ${tool.toolkit || 'unknown'} (${tool.connection_status})\n  schema: ${tool.schema_available ? 'available' : 'missing'}\n  ${tool.description || 'No description'}\n`)
         .join('\n')
         .trim(),
   });
 }
 
 async function toolsDescribeHandler(ctx) {
-  const toolkits = await resolveSearchToolkits(ctx.runtime, ctx.options.toolkits);
-  const result = await runToolCommand({
-    runtime: ctx.runtime,
-    toolName: 'notis_find_tools',
-    arguments_: {
-      query: ctx.args.toolName,
-      toolkits,
-    },
-  });
-  const tools = result.payload.tools || [];
-  const match = tools.find((tool) => tool.name === ctx.args.toolName);
-  if (!match) {
-    throw usageError(`Tool ${ctx.args.toolName} was not found in the selected toolkits.`);
-  }
+  const match = await fetchToolSchema(ctx.runtime, ctx.args.toolName);
 
   return ctx.output.emitSuccess({
     command: ctx.spec.command_path.join(' '),
-    data: { tool: match, toolkits },
+    data: { tool: match },
     humanSummary: `Described tool ${ctx.args.toolName}`,
     hints: [
       { command: `notis tools exec ${ctx.args.toolName} --dry-run --arguments '{}'`, reason: 'Validate arguments first' },
@@ -208,14 +222,13 @@ async function toolsDescribeHandler(ctx) {
 
 async function toolsExecHandler(ctx) {
   ensureLongRunningToolTimeout(ctx, ctx.args.toolName);
-  const toolkits = normalizeToolkits(ctx.options.toolkits);
   const fileBindings = await parseFileBindings(ctx.options.file);
 
   if (ctx.options.getSchema) {
-    const tool = await fetchToolSchema(ctx.runtime, ctx.args.toolName, ctx.options.toolkits);
+    const tool = await fetchToolSchema(ctx.runtime, ctx.args.toolName);
     return ctx.output.emitSuccess({
       command: ctx.spec.command_path.join(' '),
-      data: { tool, toolkits },
+      data: { tool },
       humanSummary: `Schema for ${ctx.args.toolName}`,
       hints: [
         { command: `notis tools exec ${ctx.args.toolName} --dry-run --arguments '{}'`, reason: 'Validate arguments before executing' },
@@ -233,13 +246,13 @@ async function toolsExecHandler(ctx) {
     if (fileBindings.length) {
       throw usageError('--file is only supported when executing a tool, not with --dry-run');
     }
-    const tool = await fetchToolSchema(ctx.runtime, ctx.args.toolName, ctx.options.toolkits);
+    const tool = await fetchToolSchema(ctx.runtime, ctx.args.toolName);
     const errors = validateArguments(tool.parameters, args);
 
     if (errors.length) {
       return ctx.output.emitSuccess({
         command: ctx.spec.command_path.join(' '),
-        data: { valid: false, errors, tool: ctx.args.toolName, toolkits },
+        data: { valid: false, errors, tool: ctx.args.toolName },
         humanSummary: `Dry run failed: ${errors.length} validation error(s)`,
         hints: [
           { command: `notis tools exec ${ctx.args.toolName} --get-schema`, reason: 'Review the full parameter schema' },
@@ -250,7 +263,7 @@ async function toolsExecHandler(ctx) {
 
     return ctx.output.emitSuccess({
       command: ctx.spec.command_path.join(' '),
-      data: { valid: true, tool: ctx.args.toolName, arguments: args, toolkits },
+      data: { valid: true, tool: ctx.args.toolName, arguments: args },
       humanSummary: `Dry run passed for ${ctx.args.toolName}`,
       hints: [
         { command: `notis tools exec ${ctx.args.toolName} --arguments '${JSON.stringify(args)}'`, reason: 'Execute with these arguments' },
@@ -266,7 +279,6 @@ async function toolsExecHandler(ctx) {
     arguments_: {
       tool_name: ctx.args.toolName,
       arguments: args,
-      ...(toolkits.length ? { toolkits } : {}),
     },
     mutating: true,
     idempotencyKey,
@@ -369,15 +381,15 @@ async function toolsLinkHandler(ctx) {
 export const toolsCommandSpecs = [
   {
     command_path: ['tools', 'toolkits'],
-    summary: 'List toolkit namespaces available to the active user.',
-    when_to_use: 'Use this before searching or executing generic tools.',
+    summary: 'List toolkit namespaces and connection statuses available to the active user.',
+    when_to_use: 'Use this to inspect connection state before searching or executing generic tools.',
     args_schema: { arguments: [], options: [] },
     examples: ['notis tools toolkits', 'notis tools toolkits --json'],
-    output_schema: 'Returns available toolkit namespaces.',
+    output_schema: 'Returns toolkit_connection_statuses from notis_find_tools, rendered as toolkit rows.',
     mutates: false,
     idempotent: true,
     related_commands: ['notis tools search <query>', 'notis tools describe <tool-name>'],
-    backend_call: { type: 'tool', name: 'notis_find_toolkits' },
+    backend_call: { type: 'tool', name: 'notis_find_tools' },
     handler: toolsToolkitsHandler,
   },
   {
@@ -386,10 +398,10 @@ export const toolsCommandSpecs = [
     when_to_use: 'Use this when you need a generic capability that does not have a first-class CLI command.',
     args_schema: {
       arguments: [{ token: '<query>', description: 'Natural language description of the tool you need.' }],
-      options: [{ flags: '--toolkits <csv-or-json>', description: 'Optional subset of toolkit ids to search.' }],
+      options: [{ flags: '--known-fields <text>', key: 'knownFields', description: 'Optional known field hints, such as channel_name:general or user_email:a@example.com.' }],
     },
-    examples: ['notis tools search "send an email"', 'notis tools search "update framer page" --toolkits mcp-framer'],
-    output_schema: 'Returns tool matches with descriptions and parameter schemas.',
+    examples: ['notis tools search "send an email"', 'notis tools search "post on LinkedIn" --known-fields "platform:linkedin"'],
+    output_schema: 'Returns the full notis_find_tools response. Human output renders canonical names, connection status, and schema availability.',
     mutates: false,
     idempotent: true,
     related_commands: ['notis tools toolkits', 'notis tools exec <tool-name>'],
@@ -402,9 +414,9 @@ export const toolsCommandSpecs = [
     when_to_use: 'Use this when you know the tool name and want its parameter schema before execution.',
     args_schema: {
       arguments: [{ token: '<tool-name>', description: 'Exact tool name to locate and describe.' }],
-      options: [{ flags: '--toolkits <csv-or-json>', description: 'Optional subset of toolkit ids to search.' }],
+      options: [],
     },
-    examples: ['notis tools describe composio-gmail-default-send_email', 'notis tools describe notis-default-query --toolkits notis-default'],
+    examples: ['notis tools describe composio-gmail-default-send_email', 'notis tools describe notis-default-query'],
     output_schema: 'Returns one tool descriptor with name, description, and parameters.',
     mutates: false,
     idempotent: true,
@@ -423,7 +435,6 @@ export const toolsCommandSpecs = [
         { flags: '--file <argument-path=local-path>', description: 'Upload a local file into a file-uploadable tool argument. Repeatable.', collect: true },
         { flags: '--get-schema', description: 'Display the tool parameter schema without executing.' },
         { flags: '--dry-run', description: 'Validate arguments against the tool schema without executing.' },
-        { flags: '--toolkits <csv-or-json>', description: 'Optional toolkit namespace(s) to use when resolving the tool.' },
       ],
     },
     examples: [

package/src/runtime/transport.js

@@ -9,33 +9,6 @@ import {
   saveConfig,
 } from './profiles.js';
 
-const META_TOOL_NAMES = new Set([
-  'notis_find_toolkits',
-  'notis_find_tools',
-  'notis_execute_tool',
-  'notis_find_additional_tools',
-]);
-
-function canonicalizeToolName(toolName) {
-  if (typeof toolName !== 'string' || !toolName.length) {
-    return toolName;
-  }
-
-  if (META_TOOL_NAMES.has(toolName) || toolName.startsWith('notis-default-')) {
-    return toolName;
-  }
-
-  if (toolName.startsWith('notis_')) {
-    return `notis-default-${toolName.slice('notis_'.length)}`;
-  }
-
-  if (toolName.includes('_notis_')) {
-    return `notis-default-${toolName.replace(/_notis_/g, '_')}`;
-  }
-
-  return toolName;
-}
-
 function escapeMultipartHeaderValue(value) {
   return String(value ?? '')
     .replace(/"/g, '%22')
@@ -397,7 +370,7 @@ export async function callTool({
 }) {
   const requestId = idempotencyKey || (runtime.mutating ? randomUUID() : null);
   const payload = {
-    tool_name: canonicalizeToolName(toolName),
+    tool_name: toolName,
     arguments: argumentsPayload,
     idempotency_key: requestId,
     cli_context: {