@open-mercato/ai-assistant 0.6.8-develop.7100.1.fbf66fca35 → 0.7.0

package/src/modules/ai_assistant/lib/mcp-server.ts

@@ -5,7 +5,6 @@ import {
   CallToolRequestSchema,
 } from '@modelcontextprotocol/sdk/types.js'
 import { toolInputJsonSchema } from './tool-input-schema'
-import { buildMcpToolAnnotations } from './mcp-tool-annotations'
 import { getToolRegistry } from './tool-registry'
 import { executeTool } from './tool-executor'
 import { loadAllModuleTools, indexToolsForSearch } from './tool-loader'
@@ -134,7 +133,6 @@ export async function createMcpServer(options: McpServerOptions): Promise<Server
         name: tool.name,
         description: tool.description,
         inputSchema: toolInputJsonSchema(tool.inputSchema),
-        annotations: buildMcpToolAnnotations(tool),
       })),
     }
   })

package/src/modules/ai_assistant/lib/types.ts

@@ -249,17 +249,6 @@ export type ToolInfo = {
   name: string
   description: string
   inputSchema: Record<string, unknown>
-  /** MCP capability hints advertised for the tool (see `buildMcpToolAnnotations`). */
-  annotations?: McpToolAnnotations
-}
-
-/** MCP `ToolAnnotations` values carried through remote and in-process clients. */
-export type McpToolAnnotations = {
-  title?: string
-  readOnlyHint?: boolean
-  destructiveHint?: boolean
-  idempotentHint?: boolean
-  openWorldHint?: boolean
 }
 
 /**

package/dist/modules/ai_assistant/lib/mcp-tool-annotations.js

@@ -1,18 +0,0 @@
-function buildMcpToolAnnotations(tool) {
-  const definition = tool;
-  if (definition.isMutation !== true) {
-    return { readOnlyHint: true };
-  }
-  const { isDestructive } = definition;
-  if (isDestructive === void 0) {
-    return { readOnlyHint: false };
-  }
-  return {
-    readOnlyHint: false,
-    destructiveHint: typeof isDestructive === "function" ? true : isDestructive
-  };
-}
-export {
-  buildMcpToolAnnotations
-};
-//# sourceMappingURL=mcp-tool-annotations.js.map

package/dist/modules/ai_assistant/lib/mcp-tool-annotations.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../../src/modules/ai_assistant/lib/mcp-tool-annotations.ts"],
-  "sourcesContent": ["import type { AiToolDefinition, McpToolAnnotations, McpToolDefinition } from './types'\n\n/**\n * Build the MCP annotations advertised for a registered tool.\n *\n * `readOnlyHint` follows the registry's existing mutation contract: a tool is\n * read-only unless it declares `isMutation: true`. Every write tool is required\n * to set that flag (see the module AGENTS.md) and the agent mutation-policy gate\n * already reads it the same way.\n *\n * `destructiveHint` only carries meaning for mutating tools. A predicate\n * `isDestructive` cannot be evaluated without call input, so it resolves to\n * `true` rather than under-warning the client. When the flag is absent the hint\n * is omitted so clients fall back to the conservative MCP default (`true`).\n *\n * `idempotentHint` is deliberately not emitted: no tool-definition field\n * carries that information, so clients keep the MCP default (`false`).\n */\nexport function buildMcpToolAnnotations(tool: McpToolDefinition): McpToolAnnotations {\n  const definition = tool as AiToolDefinition\n\n  if (definition.isMutation !== true) {\n    return { readOnlyHint: true }\n  }\n\n  const { isDestructive } = definition\n  if (isDestructive === undefined) {\n    return { readOnlyHint: false }\n  }\n\n  return {\n    readOnlyHint: false,\n    destructiveHint: typeof isDestructive === 'function' ? true : isDestructive,\n  }\n}\n"],
-  "mappings": "AAkBO,SAAS,wBAAwB,MAA6C;AACnF,QAAM,aAAa;AAEnB,MAAI,WAAW,eAAe,MAAM;AAClC,WAAO,EAAE,cAAc,KAAK;AAAA,EAC9B;AAEA,QAAM,EAAE,cAAc,IAAI;AAC1B,MAAI,kBAAkB,QAAW;AAC/B,WAAO,EAAE,cAAc,MAAM;AAAA,EAC/B;AAEA,SAAO;AAAA,IACL,cAAc;AAAA,IACd,iBAAiB,OAAO,kBAAkB,aAAa,OAAO;AAAA,EAChE;AACF;",
-  "names": []
-}

package/src/modules/ai_assistant/lib/__tests__/codemode-tool-annotations.test.ts

@@ -1,58 +0,0 @@
-import { loadCodeModeTools } from '../codemode-tools'
-import { buildMcpToolAnnotations } from '../mcp-tool-annotations'
-import { registerMcpTool } from '../tool-registry'
-import type { McpToolDefinition } from '../types'
-
-jest.mock('../api-endpoint-index', () => ({
-  getApiEndpoints: jest.fn(async () => []),
-  getRawOpenApiSpec: jest.fn(async () => null),
-}))
-
-jest.mock('../tool-registry', () => ({
-  registerMcpTool: jest.fn(),
-}))
-
-const mockedRegisterMcpTool = jest.mocked(registerMcpTool)
-
-async function loadRegisteredCodeModeTools(): Promise<Map<string, McpToolDefinition>> {
-  await loadCodeModeTools()
-  const tools = new Map<string, McpToolDefinition>()
-  for (const call of mockedRegisterMcpTool.mock.calls) {
-    const tool = call[0] as McpToolDefinition
-    tools.set(tool.name, tool)
-  }
-  return tools
-}
-
-describe('issue #5283 — Code Mode tools declare their mutation surface', () => {
-  beforeEach(() => {
-    mockedRegisterMcpTool.mockClear()
-  })
-
-  it('advertises the spec-querying search tool as read-only', async () => {
-    const tools = await loadRegisteredCodeModeTools()
-    const search = tools.get('search')
-
-    expect(search).toBeDefined()
-    expect(buildMcpToolAnnotations(search!)).toEqual({ readOnlyHint: true })
-  })
-
-  it('never advertises the api.request() execute tool as read-only', async () => {
-    const tools = await loadRegisteredCodeModeTools()
-    const execute = tools.get('execute')
-
-    expect(execute).toBeDefined()
-    expect(buildMcpToolAnnotations(execute!)).toEqual({
-      readOnlyHint: false,
-      destructiveHint: true,
-    })
-  })
-
-  it('registers both Code Mode tools under the codemode module id', async () => {
-    await loadRegisteredCodeModeTools()
-
-    for (const call of mockedRegisterMcpTool.mock.calls) {
-      expect(call[1]).toEqual({ moduleId: 'codemode' })
-    }
-  })
-})

package/src/modules/ai_assistant/lib/__tests__/mcp-server-tool-annotations.test.ts

@@ -1,120 +0,0 @@
-import { z } from 'zod'
-import { ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js'
-import { createMcpServer } from '../mcp-server'
-import type { AiToolDefinition, McpServerOptions, McpToolDefinition } from '../types'
-
-const mockCapturedHandlers = new Map<unknown, (request: unknown) => Promise<unknown>>()
-const mockRegisteredTools = new Map<string, McpToolDefinition>()
-
-jest.mock('@modelcontextprotocol/sdk/server/index.js', () => ({
-  Server: class {
-    setRequestHandler(schema: unknown, handler: (request: unknown) => Promise<unknown>) {
-      mockCapturedHandlers.set(schema, handler)
-    }
-  },
-}))
-jest.mock('@modelcontextprotocol/sdk/server/stdio.js', () => ({
-  StdioServerTransport: class {},
-}))
-jest.mock('@modelcontextprotocol/sdk/types.js', () => ({
-  ListToolsRequestSchema: { id: 'tools/list' },
-  CallToolRequestSchema: { id: 'tools/call' },
-}))
-jest.mock('../tool-registry', () => ({
-  getToolRegistry: () => ({
-    getTools: () => mockRegisteredTools,
-    listToolNames: () => Array.from(mockRegisteredTools.keys()),
-  }),
-}))
-jest.mock('../tool-executor', () => ({ executeTool: jest.fn() }))
-jest.mock('../tool-loader', () => ({
-  loadAllModuleTools: jest.fn(),
-  indexToolsForSearch: jest.fn(),
-}))
-jest.mock('../auth', () => ({
-  authenticateMcpRequest: jest.fn(),
-  hasRequiredFeatures: jest.fn(() => true),
-}))
-
-function registerTool(overrides: Partial<AiToolDefinition> & { name: string }): void {
-  mockRegisteredTools.set(overrides.name, {
-    description: `${overrides.name} description`,
-    inputSchema: z.object({ id: z.string() }),
-    handler: async () => ({}),
-    ...overrides,
-  } as McpToolDefinition)
-}
-
-function makeContainer(): McpServerOptions['container'] {
-  return {
-    resolve: () => ({ loadAcl: jest.fn() }),
-  } as unknown as McpServerOptions['container']
-}
-
-type ListedTool = {
-  name: string
-  description: string
-  inputSchema: unknown
-  annotations?: { readOnlyHint?: boolean; destructiveHint?: boolean }
-}
-
-async function listTools(): Promise<ListedTool[]> {
-  await createMcpServer({
-    config: { name: 'test-mcp', version: '0.0.0' },
-    container: makeContainer(),
-    allowUnauthenticatedSuperadmin: true,
-  })
-  const handler = mockCapturedHandlers.get(ListToolsRequestSchema)
-  if (!handler) throw new Error('[internal] tools/list handler was not registered')
-  const response = (await handler({})) as { tools: ListedTool[] }
-  return response.tools
-}
-
-describe('issue #5283 — MCP tools/list publishes readOnlyHint annotations', () => {
-  beforeEach(() => {
-    mockRegisteredTools.clear()
-    mockCapturedHandlers.clear()
-    jest.spyOn(process.stderr, 'write').mockImplementation(() => true)
-  })
-
-  afterEach(() => {
-    jest.restoreAllMocks()
-  })
-
-  it('marks read operations as read-only so clients can skip approval', async () => {
-    registerTool({ name: 'customers.get_company' })
-    registerTool({ name: 'customers.list_people' })
-    registerTool({ name: 'search_status', isMutation: false })
-
-    const tools = await listTools()
-
-    expect(tools).toHaveLength(3)
-    for (const tool of tools) {
-      expect(tool.annotations?.readOnlyHint).toBe(true)
-    }
-  })
-
-  it('never marks mutating operations as read-only', async () => {
-    registerTool({ name: 'catalog.update_product', isMutation: true })
-    registerTool({ name: 'customers.manage_deal_comment', isMutation: true, isDestructive: true })
-
-    const tools = await listTools()
-
-    const byName = new Map(tools.map((tool) => [tool.name, tool]))
-    expect(byName.get('catalog.update_product')?.annotations?.readOnlyHint).toBe(false)
-    expect(byName.get('customers.manage_deal_comment')?.annotations).toEqual({
-      readOnlyHint: false,
-      destructiveHint: true,
-    })
-  })
-
-  it('keeps the existing name / description / inputSchema fields intact', async () => {
-    registerTool({ name: 'customers.get_company' })
-
-    const [tool] = await listTools()
-
-    expect(tool.name).toBe('customers.get_company')
-    expect(tool.description).toBe('customers.get_company description')
-    expect(tool.inputSchema).toBeDefined()
-  })
-})

package/src/modules/ai_assistant/lib/__tests__/mcp-tool-annotations.test.ts

@@ -1,57 +0,0 @@
-import { z } from 'zod'
-import { buildMcpToolAnnotations } from '../mcp-tool-annotations'
-import type { AiToolDefinition } from '../types'
-
-function makeTool(overrides: Partial<AiToolDefinition> = {}): AiToolDefinition {
-  return {
-    name: 'customers.get_company',
-    description: 'Fetch a single company record.',
-    inputSchema: z.object({ id: z.string() }),
-    handler: async () => ({}),
-    ...overrides,
-  } as AiToolDefinition
-}
-
-describe('buildMcpToolAnnotations', () => {
-  it('advertises readOnlyHint for tools that do not declare a mutation', () => {
-    expect(buildMcpToolAnnotations(makeTool())).toEqual({ readOnlyHint: true })
-  })
-
-  it('advertises readOnlyHint for tools that explicitly declare isMutation: false', () => {
-    expect(buildMcpToolAnnotations(makeTool({ isMutation: false }))).toEqual({ readOnlyHint: true })
-  })
-
-  it('never advertises readOnlyHint for mutating tools', () => {
-    expect(buildMcpToolAnnotations(makeTool({ isMutation: true }))).toEqual({ readOnlyHint: false })
-  })
-
-  it('advertises destructiveHint when the mutation declares isDestructive', () => {
-    expect(buildMcpToolAnnotations(makeTool({ isMutation: true, isDestructive: true }))).toEqual({
-      readOnlyHint: false,
-      destructiveHint: true,
-    })
-  })
-
-  it('carries an explicit non-destructive declaration through', () => {
-    expect(buildMcpToolAnnotations(makeTool({ isMutation: true, isDestructive: false }))).toEqual({
-      readOnlyHint: false,
-      destructiveHint: false,
-    })
-  })
-
-  it('resolves a per-input isDestructive predicate to true rather than under-warning', () => {
-    const annotations = buildMcpToolAnnotations(
-      makeTool({ isMutation: true, isDestructive: (input: unknown) => (input as { op: string }).op === 'delete' }),
-    )
-    expect(annotations).toEqual({ readOnlyHint: false, destructiveHint: true })
-  })
-
-  it('omits destructiveHint when a mutation does not declare isDestructive', () => {
-    expect(buildMcpToolAnnotations(makeTool({ isMutation: true }))).not.toHaveProperty('destructiveHint')
-  })
-
-  it('never advertises idempotentHint, which no tool definition carries', () => {
-    expect(buildMcpToolAnnotations(makeTool())).not.toHaveProperty('idempotentHint')
-    expect(buildMcpToolAnnotations(makeTool({ isMutation: true }))).not.toHaveProperty('idempotentHint')
-  })
-})

package/src/modules/ai_assistant/lib/mcp-tool-annotations.ts

@@ -1,35 +0,0 @@
-import type { AiToolDefinition, McpToolAnnotations, McpToolDefinition } from './types'
-
-/**
- * Build the MCP annotations advertised for a registered tool.
- *
- * `readOnlyHint` follows the registry's existing mutation contract: a tool is
- * read-only unless it declares `isMutation: true`. Every write tool is required
- * to set that flag (see the module AGENTS.md) and the agent mutation-policy gate
- * already reads it the same way.
- *
- * `destructiveHint` only carries meaning for mutating tools. A predicate
- * `isDestructive` cannot be evaluated without call input, so it resolves to
- * `true` rather than under-warning the client. When the flag is absent the hint
- * is omitted so clients fall back to the conservative MCP default (`true`).
- *
- * `idempotentHint` is deliberately not emitted: no tool-definition field
- * carries that information, so clients keep the MCP default (`false`).
- */
-export function buildMcpToolAnnotations(tool: McpToolDefinition): McpToolAnnotations {
-  const definition = tool as AiToolDefinition
-
-  if (definition.isMutation !== true) {
-    return { readOnlyHint: true }
-  }
-
-  const { isDestructive } = definition
-  if (isDestructive === undefined) {
-    return { readOnlyHint: false }
-  }
-
-  return {
-    readOnlyHint: false,
-    destructiveHint: typeof isDestructive === 'function' ? true : isDestructive,
-  }
-}