ummaya 0.2.4 → 0.2.5

package/tui/src/tools/LookupPrimitive/LookupPrimitive.ts

@@ -28,11 +28,11 @@ import {
 } from '../../services/api/adapterManifest.js'
 import { FIND_TOOL_NAME, DESCRIPTION, FIND_TOOL_PROMPT } from './prompt.js'
 import { dispatchPrimitive } from '../_shared/dispatchPrimitive.js'
-import { validateKmaAviationToolChoice } from '../_shared/kmaAviationGuard.js'
-import { validateKmaAnalysisToolChoice } from '../_shared/kmaAnalysisGuard.js'
-import { validateNmcAedToolChoice } from '../_shared/nmcAedGuard.js'
-import { validateProtectedCheckToolChoice } from '../_shared/protectedCheckGuard.js'
-import { validateDirectPublicDataToolChoice } from '../_shared/directPublicDataGuard.js'
+import {
+  applyDocumentVisualRenderGateToOutput,
+  isDocumentVisualRenderFailedOutput,
+  renderDocumentToolResultIfPresent,
+} from '../_shared/documentToolResultRender.js'
 import {
   renderVerboseInputJson,
   renderVerboseOutputJson,
@@ -631,26 +631,27 @@ export const LookupPrimitive = buildTool({
   },
 
   mapToolResultToToolResultBlockParam(output, toolUseID) {
+    const gatedOutput = applyDocumentVisualRenderGateToOutput(output)
     // Spec 2521 (2026-05-02) — strip ``outbound_traces`` from the
     // LLM-facing content. The trace is UI-only (verbose render);
     // shipping raw HTTP bodies back into the next turn would bloat
     // K-EXAONE's context with KMA/data.go.kr response payloads.
     const llmContent =
-      typeof output === 'object' && output !== null
+      typeof gatedOutput === 'object' && gatedOutput !== null
         ? Object.fromEntries(
-            Object.entries(output as Record<string, unknown>).filter(
+            Object.entries(gatedOutput as Record<string, unknown>).filter(
               ([k]) => k !== 'outbound_traces',
             ),
           )
-        : output
+        : gatedOutput
     return {
       tool_use_id: toolUseID,
       type: 'tool_result',
       content: JSON.stringify(llmContent),
+      ...(isDocumentVisualRenderFailedOutput(gatedOutput) ? { is_error: true } : {}),
     }
   },
 
-  // UMMAYA hotfix #2518 follow-up — CC pattern (tools/BashTool/UI.tsx:renderToolUseMessage).
   // Return an args preview so the citizen can see which tool was dispatched.
   // Spec 2521 (2026-05-01) — fetch-only surface; legacy mode='search'
   // payloads from older sessions surface as the bare tool_id.
@@ -697,21 +698,6 @@ export const LookupPrimitive = buildTool({
       }
     }
 
-    const protectedChoice = validateProtectedCheckToolChoice(input.tool_id, context)
-    if (protectedChoice) return protectedChoice
-    const directPublicDataChoice = validateDirectPublicDataToolChoice(
-      input.tool_id,
-      context,
-      input.params,
-    )
-    if (directPublicDataChoice) return directPublicDataChoice
-    const kmaAviationChoice = validateKmaAviationToolChoice(input.tool_id, context)
-    if (kmaAviationChoice) return kmaAviationChoice
-    const kmaAnalysisChoice = validateKmaAnalysisToolChoice(input.tool_id, context)
-    if (kmaAnalysisChoice) return kmaAnalysisChoice
-    const nmcAedChoice = validateNmcAedToolChoice(input.tool_id, context)
-    if (nmcAedChoice) return nmcAedChoice
-
     // Tier 1 — synced backend manifest (FR-017).
     if (isManifestSynced()) {
       const backendEntry = resolveAdapter(input.tool_id)
@@ -787,14 +773,17 @@ export const LookupPrimitive = buildTool({
     _progress: unknown,
     options: { verbose: boolean; isTranscriptMode?: boolean } = { verbose: false },
   ): React.ReactNode {
+    const gatedOutput = applyDocumentVisualRenderGateToOutput(output) as Output
+    const documentResult = renderDocumentToolResultIfPresent(gatedOutput, options)
+    if (documentResult !== null) {
+      return documentResult
+    }
     // Spec 2521 (2026-05-01 evening) — Ctrl+O expand / transcript mode
     // surfaces the full envelope JSON the backend returned. Mirrors
     // CC BashTool/UI.tsx:renderToolResultMessage(verbose).
     if (options.verbose || options.isTranscriptMode) {
-      return renderVerboseOutputJson(output)
+      return renderVerboseOutputJson(gatedOutput)
     }
-    // UMMAYA hotfix #2519 (CC-original migration, 2026-04-30):
-    //
     // After the dispatchPrimitive register-and-await rewrite, output.result
     // is the actual primitive output (the inner of the backend envelope:
     // src/ummaya/tools/find.py LookupSearchResult / LookupRecord /
@@ -802,8 +791,8 @@ export const LookupPrimitive = buildTool({
     // its own `kind` field. The CC pattern wraps each branch in
     // <MessageResponse> so the "  ⎿  " gutter glyph prefixes every row
     // (tui/src/components/MessageResponse.tsx:22).
-    if (!output.ok) {
-      const message = extractErrorMessage(output.error.message)
+    if (!gatedOutput.ok) {
+      const message = extractErrorMessage(gatedOutput.error.message)
       return React.createElement(
         MessageResponse,
         null,
@@ -815,7 +804,7 @@ export const LookupPrimitive = buildTool({
       )
     }
 
-    const result = output.result as Record<string, unknown>
+    const result = gatedOutput.result as Record<string, unknown>
 
     // search mode (LookupSearchResult, models.py:820):
     //   { kind: "search", candidates: [AdapterCandidate], total_registry_size, effective_top_k, reason }
@@ -872,12 +861,16 @@ export const LookupPrimitive = buildTool({
    * validateInput has already resolved the adapter and populated ummayaCitations on the context.
    */
   async call(input, context) {
-    return dispatchPrimitive<Output>({
+    const result = await dispatchPrimitive<Output>({
       primitive: 'find',
-      args: input as Record<string, unknown>,
+      args: input,
       context,
       registry: getOrCreatePendingCallRegistry(),
       bridge: getOrCreateUmmayaBridge(),
     })
+    return {
+      ...result,
+      data: applyDocumentVisualRenderGateToOutput(result.data) as Output,
+    }
   },
 } satisfies ToolDef<InputSchema, Output>)

package/tui/src/tools/LookupPrimitive/prompt.ts

@@ -17,7 +17,6 @@ export const FIND_TOOL_PROMPT = `Discover Korean public-service lookup adapters
 
 Preferred path:
 - Call concrete adapter functions directly after their schemas are loaded.
-- Example: kma_current_observation({ base_date: "YYYYMMDD", base_time: "HH00", nx: 97, ny: 74 })
 - Adapter ids and schemas are progressively disclosed by ToolSearch, adapter_manifest, or backend top-K retrieval for the current citizen request.
 - Only top candidates should be loaded; do not expect every adapter schema in the prompt.
 - A concrete adapter id may be valid even when it is not listed in <available-deferred-tools>; if it appears in <available_adapters> or adapter_manifest and its function is loaded, call that function directly with its schema fields.
@@ -26,7 +25,6 @@ Legacy root wrapper:
 - If a concrete adapter function is not loaded and only the root primitive is available, find accepts { tool_id, params } for old transcripts and compatibility paths.
 - tool_id must be a concrete adapter id from <available_adapters>, never "find", "locate", "check", or "send".
 - Invalid: find({ tool_id: "find", params: {...} })
-- Compatibility-only: find({ tool_id: "kma_apihub_url_air_metar_decoded", params: { org: "K", help: 1 } })
 
 Rules:
 - Do not call find with mode='search' or query; discovery is handled outside the primitive call.

package/tui/src/tools/MCPTool/trustPolicy.ts

@@ -0,0 +1,118 @@
+import { mcpInfoFromString } from '../../services/mcp/mcpStringUtils.js'
+import type { ToolPermissionContext, ToolUseContext } from '../../Tool.js'
+import type { PermissionResult } from '../../utils/permissions/PermissionResult.js'
+import {
+  getAllowRules,
+  getDenyRuleForTool,
+} from '../../utils/permissions/permissions.js'
+
+const TRUSTED_BUILTIN_MCP_SERVERS = ['ummaya'] as const
+
+type McpTrustInput = { readonly [key: string]: unknown }
+
+function mcpServerRuleName(serverName: string): string {
+  return `mcp__${serverName}`
+}
+
+function hasExactServerAllowRule(
+  permissionContext: ToolPermissionContext,
+  serverName: string,
+): boolean {
+  return getAllowRules(permissionContext).some(rule => {
+    if (rule.ruleValue.ruleContent !== undefined) return false
+    const ruleInfo = mcpInfoFromString(rule.ruleValue.toolName)
+    if (ruleInfo === null) return false
+    return (
+      ruleInfo.serverName === serverName &&
+      (ruleInfo.toolName === undefined || ruleInfo.toolName === '*')
+    )
+  })
+}
+
+function hasServerDenyRule(
+  permissionContext: ToolPermissionContext,
+  serverName: string,
+): boolean {
+  return (
+    getDenyRuleForTool(permissionContext, {
+      name: mcpServerRuleName(serverName),
+      mcpInfo: { serverName, toolName: '*' },
+    }) !== null
+  )
+}
+
+export function isTrustedMcpServer(
+  permissionContext: ToolPermissionContext,
+  serverName: string,
+): boolean {
+  if (hasServerDenyRule(permissionContext, serverName)) return false
+  if (TRUSTED_BUILTIN_MCP_SERVERS.some(name => name === serverName)) return true
+  return hasExactServerAllowRule(permissionContext, serverName)
+}
+
+export function assertNonEmptyMcpServerName(serverName: string): void {
+  if (serverName.trim().length === 0) {
+    throw new Error('MCP server name cannot be empty')
+  }
+}
+
+export function assertNonEmptyMcpResourceUri(uri: string): void {
+  if (uri.trim().length === 0) {
+    throw new Error('MCP resource URI cannot be empty')
+  }
+}
+
+export function assertTrustedMcpServerForResourceAccess(
+  permissionContext: ToolPermissionContext,
+  serverName: string,
+): void {
+  assertTrustedMcpServer(
+    permissionContext,
+    serverName,
+    `Server "${serverName}" is not trusted for MCP resource access`,
+  )
+}
+
+export function assertTrustedMcpServer(
+  permissionContext: ToolPermissionContext,
+  serverName: string,
+  message: string,
+): void {
+  assertNonEmptyMcpServerName(serverName)
+  if (!isTrustedMcpServer(permissionContext, serverName)) {
+    throw new Error(message)
+  }
+}
+
+export function createMcpServerTrustSuggestion(serverName: string) {
+  return {
+    type: 'addRules' as const,
+    rules: [
+      {
+        toolName: mcpServerRuleName(serverName),
+        ruleContent: undefined,
+      },
+    ],
+    behavior: 'allow' as const,
+    destination: 'localSettings' as const,
+  }
+}
+
+export function checkMcpServerTrustPermission<Input extends McpTrustInput>(
+  serverName: string,
+  input: Input,
+  context: ToolUseContext,
+  message: string,
+): PermissionResult<Input> {
+  assertNonEmptyMcpServerName(serverName)
+  if (
+    isTrustedMcpServer(context.getAppState().toolPermissionContext, serverName)
+  ) {
+    return { behavior: 'allow', updatedInput: input }
+  }
+  return {
+    behavior: 'passthrough',
+    message,
+    suggestions: [createMcpServerTrustSuggestion(serverName)],
+  }
+}

package/tui/src/tools/McpAuthTool/McpAuthTool.ts

@@ -18,7 +18,11 @@ import type { Tool } from '../../Tool.js'
 import { errorMessage } from '../../utils/errors.js'
 import { lazySchema } from '../../utils/lazySchema.js'
 import { logMCPDebug, logMCPError } from '../../utils/log.js'
-import type { PermissionDecision } from '../../utils/permissions/PermissionResult.js'
+import type { PermissionResult } from '../../utils/permissions/PermissionResult.js'
+import {
+  assertTrustedMcpServer,
+  checkMcpServerTrustPermission,
+} from '../MCPTool/trustPolicy.js'
 
 const inputSchema = lazySchema(() => z.object({}))
 type InputSchema = ReturnType<typeof inputSchema>
@@ -79,10 +83,21 @@ export function createMcpAuthTool(
     get inputSchema(): InputSchema {
       return inputSchema()
     },
-    async checkPermissions(input): Promise<PermissionDecision> {
-      return { behavior: 'allow', updatedInput: input }
+    async checkPermissions(input, context): Promise<PermissionResult> {
+      return checkMcpServerTrustPermission(
+        serverName,
+        input,
+        context,
+        `MCP server "${serverName}" requires trust before authentication can run.`,
+      )
     },
     async call(_input, context) {
+      assertTrustedMcpServer(
+        context.getAppState().toolPermissionContext,
+        serverName,
+        `MCP server "${serverName}" requires trust before authentication can run.`,
+      )
+
       // claude.ai connectors use a separate auth flow (handleClaudeAIAuth in
       // MCPRemoteServerMenu) that we don't invoke programmatically here —
       // just point the user at /mcp.
@@ -196,6 +211,9 @@ export function createMcpAuthTool(
           },
         }
       } catch (err) {
+        if (!(err instanceof Error)) {
+          throw err
+        }
         return {
           data: {
             status: 'error' as const,

package/tui/src/tools/NotebookEditTool/NotebookEditTool.ts

@@ -1,22 +1,10 @@
 import { feature } from 'bun:bundle'
-import { extname, isAbsolute, resolve } from 'path'
-import {
-  fileHistoryEnabled,
-  fileHistoryTrackEdit,
-} from 'src/utils/fileHistory.js'
 import { z } from 'zod/v4'
-import { buildTool, type ToolDef, type ToolUseContext } from '../../Tool.js'
-import type { NotebookCell, NotebookContent } from '../../types/notebook.js'
-import { getCwd } from '../../utils/cwd.js'
-import { isENOENT } from '../../utils/errors.js'
-import { getFileModificationTime, writeTextContent } from '../../utils/file.js'
-import { readFileSyncWithMetadata } from '../../utils/fileRead.js'
-import { safeParseJSON } from '../../utils/json.js'
+import { buildTool, type ToolDef } from '../../Tool.js'
 import { lazySchema } from '../../utils/lazySchema.js'
-import { parseCellId } from '../../utils/notebook.js'
 import { checkWritePermissionForTool } from '../../utils/permissions/filesystem.js'
 import type { PermissionDecision } from '../../utils/permissions/PermissionResult.js'
-import { jsonParse, jsonStringify } from '../../utils/slowOperations.js'
+import { callNotebookEditTool } from './call.js'
 import { NOTEBOOK_EDIT_TOOL_NAME } from './constants.js'
 import { DESCRIPTION, PROMPT } from './prompt.js'
 import {
@@ -26,6 +14,7 @@ import {
   renderToolUseMessage,
   renderToolUseRejectedMessage,
 } from './UI.js'
+import { validateNotebookEditInput } from './validateInput.js'
 
 export const inputSchema = lazySchema(() =>
   z.strictObject({
@@ -173,318 +162,10 @@ export const NotebookEditTool = buildTool({
   renderToolUseRejectedMessage,
   renderToolUseErrorMessage,
   renderToolResultMessage,
-  async validateInput(
-    { notebook_path, cell_type, cell_id, edit_mode = 'replace' },
-    toolUseContext: ToolUseContext,
-  ) {
-    const fullPath = isAbsolute(notebook_path)
-      ? notebook_path
-      : resolve(getCwd(), notebook_path)
-
-    // SECURITY: Skip filesystem operations for UNC paths to prevent NTLM credential leaks.
-    if (fullPath.startsWith('\\\\') || fullPath.startsWith('//')) {
-      return { result: true }
-    }
-
-    if (extname(fullPath) !== '.ipynb') {
-      return {
-        result: false,
-        message:
-          'File must be a Jupyter notebook (.ipynb file). For editing other file types, use the FileEdit tool.',
-        errorCode: 2,
-      }
-    }
-
-    if (
-      edit_mode !== 'replace' &&
-      edit_mode !== 'insert' &&
-      edit_mode !== 'delete'
-    ) {
-      return {
-        result: false,
-        message: 'Edit mode must be replace, insert, or delete.',
-        errorCode: 4,
-      }
-    }
-
-    if (edit_mode === 'insert' && !cell_type) {
-      return {
-        result: false,
-        message: 'Cell type is required when using edit_mode=insert.',
-        errorCode: 5,
-      }
-    }
-
-    // Require Read-before-Edit (matches FileEditTool/FileWriteTool). Without
-    // this, the model could edit a notebook it never saw, or edit against a
-    // stale view after an external change — silent data loss.
-    const readTimestamp = toolUseContext.readFileState.get(fullPath)
-    if (!readTimestamp) {
-      return {
-        result: false,
-        message:
-          'File has not been read yet. Read it first before writing to it.',
-        errorCode: 9,
-      }
-    }
-    if (getFileModificationTime(fullPath) > readTimestamp.timestamp) {
-      return {
-        result: false,
-        message:
-          'File has been modified since read, either by the user or by a linter. Read it again before attempting to write it.',
-        errorCode: 10,
-      }
-    }
-
-    let content: string
-    try {
-      content = readFileSyncWithMetadata(fullPath).content
-    } catch (e) {
-      if (isENOENT(e)) {
-        return {
-          result: false,
-          message: 'Notebook file does not exist.',
-          errorCode: 1,
-        }
-      }
-      throw e
-    }
-    const notebook = safeParseJSON(content) as NotebookContent | null
-    if (!notebook) {
-      return {
-        result: false,
-        message: 'Notebook is not valid JSON.',
-        errorCode: 6,
-      }
-    }
-    if (!cell_id) {
-      if (edit_mode !== 'insert') {
-        return {
-          result: false,
-          message: 'Cell ID must be specified when not inserting a new cell.',
-          errorCode: 7,
-        }
-      }
-    } else {
-      // First try to find the cell by its actual ID
-      const cellIndex = notebook.cells.findIndex(cell => cell.id === cell_id)
-
-      if (cellIndex === -1) {
-        // If not found, try to parse as a numeric index (cell-N format)
-        const parsedCellIndex = parseCellId(cell_id)
-        if (parsedCellIndex !== undefined) {
-          if (!notebook.cells[parsedCellIndex]) {
-            return {
-              result: false,
-              message: `Cell with index ${parsedCellIndex} does not exist in notebook.`,
-              errorCode: 7,
-            }
-          }
-        } else {
-          return {
-            result: false,
-            message: `Cell with ID "${cell_id}" not found in notebook.`,
-            errorCode: 8,
-          }
-        }
-      }
-    }
-
-    return { result: true }
+  async validateInput(input, toolUseContext) {
+    return validateNotebookEditInput(input, toolUseContext)
   },
-  async call(
-    {
-      notebook_path,
-      new_source,
-      cell_id,
-      cell_type,
-      edit_mode: originalEditMode,
-    },
-    { readFileState, updateFileHistoryState },
-    _,
-    parentMessage,
-  ) {
-    const fullPath = isAbsolute(notebook_path)
-      ? notebook_path
-      : resolve(getCwd(), notebook_path)
-
-    if (fileHistoryEnabled()) {
-      await fileHistoryTrackEdit(
-        updateFileHistoryState,
-        fullPath,
-        parentMessage.uuid,
-      )
-    }
-
-    try {
-      // readFileSyncWithMetadata gives content + encoding + line endings in
-      // one safeResolvePath + readFileSync pass, replacing the previous
-      // detectFileEncoding + readFile + detectLineEndings chain (each of
-      // which redid safeResolvePath and/or a 4KB readSync).
-      const { content, encoding, lineEndings } =
-        readFileSyncWithMetadata(fullPath)
-      // Must use non-memoized jsonParse here: safeParseJSON caches by content
-      // string and returns a shared object reference, but we mutate the
-      // notebook in place below (cells.splice, targetCell.source = ...).
-      // Using the memoized version poisons the cache for validateInput() and
-      // any subsequent call() with the same file content.
-      let notebook: NotebookContent
-      try {
-        notebook = jsonParse(content) as NotebookContent
-      } catch {
-        return {
-          data: {
-            new_source,
-            cell_type: cell_type ?? 'code',
-            language: 'python',
-            edit_mode: 'replace',
-            error: 'Notebook is not valid JSON.',
-            cell_id,
-            notebook_path: fullPath,
-            original_file: '',
-            updated_file: '',
-          },
-        }
-      }
-
-      let cellIndex
-      if (!cell_id) {
-        cellIndex = 0 // Default to inserting at the beginning if no cell_id is provided
-      } else {
-        // First try to find the cell by its actual ID
-        cellIndex = notebook.cells.findIndex(cell => cell.id === cell_id)
-
-        // If not found, try to parse as a numeric index (cell-N format)
-        if (cellIndex === -1) {
-          const parsedCellIndex = parseCellId(cell_id)
-          if (parsedCellIndex !== undefined) {
-            cellIndex = parsedCellIndex
-          }
-        }
-
-        if (originalEditMode === 'insert') {
-          cellIndex += 1 // Insert after the cell with this ID
-        }
-      }
-
-      // Convert replace to insert if trying to replace one past the end
-      let edit_mode = originalEditMode
-      if (edit_mode === 'replace' && cellIndex === notebook.cells.length) {
-        edit_mode = 'insert'
-        if (!cell_type) {
-          cell_type = 'code' // Default to code if no cell_type specified
-        }
-      }
-
-      const language = notebook.metadata.language_info?.name ?? 'python'
-      let new_cell_id = undefined
-      if (
-        notebook.nbformat > 4 ||
-        (notebook.nbformat === 4 && notebook.nbformat_minor >= 5)
-      ) {
-        if (edit_mode === 'insert') {
-          new_cell_id = Math.random().toString(36).substring(2, 15)
-        } else if (cell_id !== null) {
-          new_cell_id = cell_id
-        }
-      }
-
-      if (edit_mode === 'delete') {
-        // Delete the specified cell
-        notebook.cells.splice(cellIndex, 1)
-      } else if (edit_mode === 'insert') {
-        let new_cell: NotebookCell
-        if (cell_type === 'markdown') {
-          new_cell = {
-            cell_type: 'markdown',
-            id: new_cell_id,
-            source: new_source,
-            metadata: {},
-          }
-        } else {
-          new_cell = {
-            cell_type: 'code',
-            id: new_cell_id,
-            source: new_source,
-            metadata: {},
-            execution_count: null,
-            outputs: [],
-          }
-        }
-        // Insert the new cell
-        notebook.cells.splice(cellIndex, 0, new_cell)
-      } else {
-        // Find the specified cell
-        const targetCell = notebook.cells[cellIndex]! // validateInput ensures cell_number is in bounds
-        targetCell.source = new_source
-        if (targetCell.cell_type === 'code') {
-          // Reset execution count and clear outputs since cell was modified
-          targetCell.execution_count = null
-          targetCell.outputs = []
-        }
-        if (cell_type && cell_type !== targetCell.cell_type) {
-          targetCell.cell_type = cell_type
-        }
-      }
-      // Write back to file
-      const IPYNB_INDENT = 1
-      const updatedContent = jsonStringify(notebook, null, IPYNB_INDENT)
-      writeTextContent(fullPath, updatedContent, encoding, lineEndings)
-      // Update readFileState with post-write mtime (matches FileEditTool/
-      // FileWriteTool). offset:undefined breaks FileReadTool's dedup match —
-      // without this, Read→NotebookEdit→Read in the same millisecond would
-      // return the file_unchanged stub against stale in-context content.
-      readFileState.set(fullPath, {
-        content: updatedContent,
-        timestamp: getFileModificationTime(fullPath),
-        offset: undefined,
-        limit: undefined,
-      })
-      const data = {
-        new_source,
-        cell_type: cell_type ?? 'code',
-        language,
-        edit_mode: edit_mode ?? 'replace',
-        cell_id: new_cell_id || undefined,
-        error: '',
-        notebook_path: fullPath,
-        original_file: content,
-        updated_file: updatedContent,
-      }
-      return {
-        data,
-      }
-    } catch (error) {
-      if (error instanceof Error) {
-        const data = {
-          new_source,
-          cell_type: cell_type ?? 'code',
-          language: 'python',
-          edit_mode: 'replace',
-          error: error.message,
-          cell_id,
-          notebook_path: fullPath,
-          original_file: '',
-          updated_file: '',
-        }
-        return {
-          data,
-        }
-      }
-      const data = {
-        new_source,
-        cell_type: cell_type ?? 'code',
-        language: 'python',
-        edit_mode: 'replace',
-        error: 'Unknown error occurred while editing notebook',
-        cell_id,
-        notebook_path: fullPath,
-        original_file: '',
-        updated_file: '',
-      }
-      return {
-        data,
-      }
-    }
+  async call(input, context, _, parentMessage) {
+    return callNotebookEditTool(input, context, parentMessage)
   },
 } satisfies ToolDef<InputSchema, Output>)