@open-mercato/ai-assistant 0.4.2-canary-c02407ff85

package/src/modules/ai_assistant/lib/in-process-client.ts

@@ -0,0 +1,205 @@
+import type { AwilixContainer } from 'awilix'
+import type { z } from 'zod'
+import { zodToJsonSchema } from 'zod-to-json-schema'
+import { getToolRegistry } from './tool-registry'
+import { executeTool } from './tool-executor'
+import { loadAllModuleTools } from './tool-loader'
+import { authenticateMcpRequest, hasRequiredFeatures, type McpAuthSuccess } from './auth'
+import type { McpToolContext, McpClientInterface, ToolInfo, ToolResult, McpToolDefinition } from './types'
+
+/**
+ * Options for creating an in-process MCP client.
+ */
+export type InProcessClientOptions = {
+  /** API key secret for authentication */
+  apiKeySecret: string
+  /** DI container */
+  container: AwilixContainer
+}
+
+/**
+ * Options for creating an in-process MCP client with direct auth context.
+ * Used when the caller already has authenticated user context (e.g., from session).
+ */
+export type AuthContextOptions = {
+  /** DI container */
+  container: AwilixContainer
+  /** Pre-authenticated user context */
+  authContext: {
+    tenantId: string | null
+    organizationId: string | null
+    userId: string
+    userFeatures: string[]
+    isSuperAdmin: boolean
+  }
+}
+
+/**
+ * Tool info with raw Zod schema for AI SDK integration.
+ */
+export type ToolInfoWithSchema = {
+  name: string
+  description: string
+  inputSchema: z.ZodType<unknown>
+}
+
+/**
+ * In-process MCP client for direct tool execution.
+ *
+ * This client executes tools directly without MCP protocol overhead,
+ * making it the fastest option when running in the same process as
+ * the LLM service.
+ *
+ * Authentication is still performed via API key to ensure proper
+ * ACL filtering of available tools.
+ */
+export class InProcessMcpClient implements McpClientInterface {
+  private auth: McpAuthSuccess
+  private container: AwilixContainer
+  private toolContext: McpToolContext
+  private toolsLoaded = false
+
+  private constructor(auth: McpAuthSuccess, container: AwilixContainer) {
+    this.auth = auth
+    this.container = container
+    this.toolContext = {
+      tenantId: auth.tenantId,
+      organizationId: auth.organizationId,
+      userId: auth.userId,
+      container,
+      userFeatures: auth.features,
+      isSuperAdmin: auth.isSuperAdmin,
+    }
+  }
+
+  /**
+   * Create and authenticate an in-process client using API key.
+   */
+  static async create(options: InProcessClientOptions): Promise<InProcessMcpClient> {
+    const { apiKeySecret, container } = options
+
+    const authResult = await authenticateMcpRequest(apiKeySecret, container)
+    if (!authResult.success) {
+      throw new Error(`Authentication failed: ${authResult.error}`)
+    }
+
+    return new InProcessMcpClient(authResult, container)
+  }
+
+  /**
+   * Create an in-process client with pre-authenticated context.
+   * Use this when you already have user auth context (e.g., from session auth).
+   */
+  static async createWithAuthContext(options: AuthContextOptions): Promise<InProcessMcpClient> {
+    const { container, authContext } = options
+
+    // Create a synthetic auth result (no API key lookup needed)
+    const syntheticAuth: McpAuthSuccess = {
+      success: true,
+      keyId: 'session-auth',
+      keyName: 'Session Authentication',
+      tenantId: authContext.tenantId,
+      organizationId: authContext.organizationId,
+      userId: authContext.userId,
+      features: authContext.userFeatures,
+      isSuperAdmin: authContext.isSuperAdmin,
+    }
+
+    return new InProcessMcpClient(syntheticAuth, container)
+  }
+
+  /**
+   * Ensure tools are loaded from all modules.
+   */
+  private async ensureToolsLoaded(): Promise<void> {
+    if (!this.toolsLoaded) {
+      await loadAllModuleTools()
+      this.toolsLoaded = true
+    }
+  }
+
+  /**
+   * List available tools filtered by API key's permissions.
+   * Returns JSON Schema format (for MCP protocol compatibility).
+   */
+  async listTools(): Promise<ToolInfo[]> {
+    await this.ensureToolsLoaded()
+
+    const registry = getToolRegistry()
+    const tools = Array.from(registry.getTools().values())
+
+    const accessibleTools = tools.filter((tool) =>
+      hasRequiredFeatures(tool.requiredFeatures, this.auth.features, this.auth.isSuperAdmin)
+    )
+
+    return accessibleTools.map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+      inputSchema: zodToJsonSchema(tool.inputSchema as any) as Record<string, unknown>,
+    }))
+  }
+
+  /**
+   * List available tools with raw Zod schemas.
+   * Use this for AI SDK integration which requires Zod schemas.
+   */
+  async listToolsWithSchemas(): Promise<ToolInfoWithSchema[]> {
+    await this.ensureToolsLoaded()
+
+    const registry = getToolRegistry()
+    const tools = Array.from(registry.getTools().values())
+
+    const accessibleTools = tools.filter((tool) =>
+      hasRequiredFeatures(tool.requiredFeatures, this.auth.features, this.auth.isSuperAdmin)
+    )
+
+    return accessibleTools.map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+      inputSchema: tool.inputSchema,
+    }))
+  }
+
+  /**
+   * Execute a tool directly.
+   */
+  async callTool(name: string, args: unknown): Promise<ToolResult> {
+    await this.ensureToolsLoaded()
+
+    const result = await executeTool(name, args ?? {}, this.toolContext)
+
+    return {
+      success: result.success,
+      result: result.result,
+      error: result.error,
+    }
+  }
+
+  /**
+   * Close the client (no-op for in-process).
+   */
+  async close(): Promise<void> {
+    // No resources to clean up for in-process client
+  }
+
+  /**
+   * Get the authenticated context info.
+   */
+  getAuthInfo(): {
+    keyId: string
+    keyName: string
+    tenantId: string | null
+    organizationId: string | null
+    userId: string
+    isSuperAdmin: boolean
+  } {
+    return {
+      keyId: this.auth.keyId,
+      keyName: this.auth.keyName,
+      tenantId: this.auth.tenantId,
+      organizationId: this.auth.organizationId,
+      userId: this.auth.userId,
+      isSuperAdmin: this.auth.isSuperAdmin,
+    }
+  }
+}

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

@@ -0,0 +1,221 @@
+import { spawn, type ChildProcess } from 'node:child_process'
+import { Client } from '@modelcontextprotocol/sdk/client/index.js'
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js'
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js'
+import type { McpClientInterface, ToolInfo, ToolResult } from './types'
+
+/**
+ * Options for stdio transport.
+ */
+export type StdioClientOptions = {
+  transport: 'stdio'
+  /** API key secret (passed to server via --api-key) */
+  apiKeySecret: string
+  /** Command to run (default: 'yarn') */
+  command?: string
+  /** Arguments for the command (default: mercato mcp:serve with api-key) */
+  args?: string[]
+  /** Working directory (default: process.cwd()) */
+  cwd?: string
+}
+
+/**
+ * Options for HTTP transport.
+ */
+export type HttpClientOptions = {
+  transport: 'http'
+  /** API key secret (sent via x-api-key header) */
+  apiKeySecret: string
+  /** MCP server URL (e.g., 'http://localhost:3001/mcp') */
+  url: string
+}
+
+/**
+ * Combined options for McpClient.
+ */
+export type McpClientOptions = StdioClientOptions | HttpClientOptions
+
+/**
+ * MCP protocol client for connecting to MCP servers.
+ *
+ * Supports two transport modes:
+ * - stdio: Spawns server as subprocess
+ * - http: Connects to HTTP server
+ */
+export class McpClient implements McpClientInterface {
+  private client: Client
+  private transport: StdioClientTransport | StreamableHTTPClientTransport
+  private childProcess?: ChildProcess
+  private apiKeySecret: string
+
+  private constructor(
+    client: Client,
+    transport: StdioClientTransport | StreamableHTTPClientTransport,
+    apiKeySecret: string,
+    childProcess?: ChildProcess
+  ) {
+    this.client = client
+    this.transport = transport
+    this.apiKeySecret = apiKeySecret
+    this.childProcess = childProcess
+  }
+
+  /**
+   * Connect to an MCP server via the specified transport.
+   */
+  static async connect(options: McpClientOptions): Promise<McpClient> {
+    if (options.transport === 'stdio') {
+      return McpClient.connectStdio(options)
+    } else {
+      return McpClient.connectHttp(options)
+    }
+  }
+
+  /**
+   * Connect via stdio transport (spawn subprocess).
+   */
+  private static async connectStdio(options: StdioClientOptions): Promise<McpClient> {
+    const command = options.command ?? 'yarn'
+    const args = options.args ?? [
+      'mercato',
+      'ai_assistant',
+      'mcp:serve',
+      '--api-key',
+      options.apiKeySecret,
+    ]
+    const cwd = options.cwd ?? process.cwd()
+
+    const childProcess = spawn(command, args, {
+      cwd,
+      stdio: ['pipe', 'pipe', 'pipe'],
+      env: { ...process.env },
+    })
+
+    // Forward stderr for debugging
+    childProcess.stderr?.on('data', (data) => {
+      const message = data.toString().trim()
+      if (message) {
+        console.error(`[MCP Client] ${message}`)
+      }
+    })
+
+    const transport = new StdioClientTransport({
+      command,
+      args,
+      cwd,
+      env: process.env as Record<string, string>,
+    })
+
+    const client = new Client(
+      { name: 'open-mercato-client', version: '0.1.0' },
+      { capabilities: {} }
+    )
+
+    await client.connect(transport)
+
+    return new McpClient(client, transport, options.apiKeySecret, childProcess)
+  }
+
+  /**
+   * Connect via HTTP transport.
+   */
+  private static async connectHttp(options: HttpClientOptions): Promise<McpClient> {
+    const transport = new StreamableHTTPClientTransport(
+      new URL(options.url),
+      {
+        requestInit: {
+          headers: {
+            'x-api-key': options.apiKeySecret,
+          },
+        },
+      }
+    )
+
+    const client = new Client(
+      { name: 'open-mercato-client', version: '0.1.0' },
+      { capabilities: {} }
+    )
+
+    await client.connect(transport)
+
+    return new McpClient(client, transport, options.apiKeySecret)
+  }
+
+  /**
+   * List available tools from the server.
+   */
+  async listTools(): Promise<ToolInfo[]> {
+    const response = await this.client.listTools()
+
+    return response.tools.map((tool) => ({
+      name: tool.name,
+      description: tool.description ?? '',
+      inputSchema: (tool.inputSchema ?? {}) as Record<string, unknown>,
+    }))
+  }
+
+  /**
+   * Call a tool on the server.
+   */
+  async callTool(name: string, args: unknown): Promise<ToolResult> {
+    try {
+      const response = await this.client.callTool({
+        name,
+        arguments: args as Record<string, unknown>,
+      })
+
+      // Parse content from response
+      const content = response.content
+      if (!Array.isArray(content) || content.length === 0) {
+        return { success: true, result: null }
+      }
+
+      const firstContent = content[0]
+      if (firstContent.type === 'text') {
+        try {
+          const parsed = JSON.parse(firstContent.text)
+
+          // Check if it's an error response
+          if (response.isError || parsed.error) {
+            return {
+              success: false,
+              error: parsed.error ?? 'Unknown error',
+            }
+          }
+
+          return { success: true, result: parsed }
+        } catch {
+          // Not JSON, return as-is
+          return { success: true, result: firstContent.text }
+        }
+      }
+
+      return { success: true, result: content }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error)
+      return { success: false, error: message }
+    }
+  }
+
+  /**
+   * Close the client and release resources.
+   */
+  async close(): Promise<void> {
+    try {
+      await this.client.close()
+    } catch {
+      // Ignore close errors
+    }
+
+    try {
+      await this.transport.close()
+    } catch {
+      // Ignore close errors
+    }
+
+    if (this.childProcess) {
+      this.childProcess.kill()
+      this.childProcess = undefined
+    }
+  }
+}