@namzu/sdk 0.1.1

package/src/connector/mcp/http-sse.ts

@@ -0,0 +1,137 @@
+import type {
+  MCPTransport,
+  MCPJsonRpcMessage,
+  MCPHttpSseTransportConfig,
+} from '../../types/connector/index.js'
+import { getRootLogger, type Logger } from '../../utils/logger.js'
+
+export class HttpSseTransport implements MCPTransport {
+  private messageHandlers: Array<(message: MCPJsonRpcMessage) => void> = []
+  private closeHandlers: Array<() => void> = []
+  private errorHandlers: Array<(error: Error) => void> = []
+  private connected = false
+  private abortController: AbortController | null = null
+  private sseUrl: string
+  private postUrl: string
+  private log: Logger
+
+  constructor(private readonly config: MCPHttpSseTransportConfig) {
+    const base = config.url.replace(/\/+$/, '')
+    this.sseUrl = `${base}/sse`
+    this.postUrl = `${base}/message`
+    this.log = getRootLogger().child({ component: 'HttpSseTransport' })
+  }
+
+  async connect(): Promise<void> {
+    if (this.connected) return
+
+    this.abortController = new AbortController()
+    await this.startSSE()
+    this.connected = true
+    this.log.info(`HttpSseTransport connected to ${this.config.url}`)
+  }
+
+  async close(): Promise<void> {
+    this.connected = false
+    this.abortController?.abort()
+    this.abortController = null
+    for (const handler of this.closeHandlers) handler()
+  }
+
+  async send(message: MCPJsonRpcMessage): Promise<void> {
+    if (!this.connected) {
+      throw new Error('HttpSseTransport: not connected')
+    }
+
+    const controller = new AbortController()
+    const timeout = setTimeout(() => controller.abort(), this.config.timeoutMs ?? 30_000)
+
+    try {
+      const response = await fetch(this.postUrl, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          ...this.config.headers,
+        },
+        body: JSON.stringify(message),
+        signal: controller.signal,
+      })
+
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`)
+      }
+
+      const contentType = response.headers.get('content-type') ?? ''
+      if (contentType.includes('application/json')) {
+        const body = (await response.json()) as MCPJsonRpcMessage
+        for (const handler of this.messageHandlers) handler(body)
+      }
+    } finally {
+      clearTimeout(timeout)
+    }
+  }
+
+  onMessage(handler: (message: MCPJsonRpcMessage) => void): void {
+    this.messageHandlers.push(handler)
+  }
+
+  onClose(handler: () => void): void {
+    this.closeHandlers.push(handler)
+  }
+
+  onError(handler: (error: Error) => void): void {
+    this.errorHandlers.push(handler)
+  }
+
+  isConnected(): boolean {
+    return this.connected
+  }
+
+  private async startSSE(): Promise<void> {
+    this.listenSSE().catch((err) => {
+      if (this.connected) {
+        this.log.error('SSE stream error', { error: String(err) })
+        for (const handler of this.errorHandlers) handler(err instanceof Error ? err : new Error(String(err)))
+      }
+    })
+  }
+
+  private async listenSSE(): Promise<void> {
+    const response = await fetch(this.sseUrl, {
+      headers: {
+        Accept: 'text/event-stream',
+        ...this.config.headers,
+      },
+      signal: this.abortController?.signal,
+    })
+
+    if (!response.ok || !response.body) {
+      throw new Error(`SSE connection failed: HTTP ${response.status}`)
+    }
+
+    const reader = response.body.getReader()
+    const decoder = new TextDecoder()
+    let buffer = ''
+
+    while (this.connected) {
+      const { done, value } = await reader.read()
+      if (done) break
+
+      buffer += decoder.decode(value, { stream: true })
+      const events = buffer.split('\n\n')
+      buffer = events.pop() ?? ''
+
+      for (const event of events) {
+        const dataLine = event.split('\n').find((line) => line.startsWith('data: '))
+        if (!dataLine) continue
+        const data = dataLine.slice(6)
+        try {
+          const message = JSON.parse(data) as MCPJsonRpcMessage
+          for (const handler of this.messageHandlers) handler(message)
+        } catch {
+          this.log.warn(`HttpSseTransport: invalid SSE data: ${data.slice(0, 100)}`)
+        }
+      }
+    }
+  }
+}

package/src/connector/mcp/index.ts

@@ -0,0 +1,20 @@
+export { StdioTransport } from './stdio.js'
+export { HttpSseTransport } from './http-sse.js'
+
+export { MCPClient } from './client.js'
+
+export {
+  mcpToolToToolDefinition,
+  toolDefinitionToMCPTool,
+  mcpJsonSchemaToZod,
+  zodToMCPJsonSchema,
+  mcpToolResultToToolResult,
+  toolResultToMCPToolResult,
+} from './adapter.js'
+
+export { MCPToolDiscovery } from './discovery.js'
+
+export { MCPConnectorBridge } from '../../bridge/mcp/connector/adapter.js'
+
+export { MCPServer } from './server.js'
+export type { MCPServerToolProvider, MCPServerResourceProvider } from './server.js'

package/src/connector/mcp/server.ts

@@ -0,0 +1,204 @@
+import type {
+  MCPTransport,
+  MCPJsonRpcMessage,
+  MCPServerConfig,
+  MCPServerState,
+  MCPServerCapabilities,
+  MCPToolDefinition,
+  MCPToolResult,
+  MCPResource,
+  MCPContentBlock,
+} from '../../types/connector/index.js'
+import type { MCPServerId } from '../../types/ids/index.js'
+import { generateMCPServerId } from '../../utils/id.js'
+import { getRootLogger, type Logger } from '../../utils/logger.js'
+import { toErrorMessage } from '../../utils/error.js'
+
+export interface MCPServerToolProvider {
+  listTools(): MCPToolDefinition[]
+  callTool(name: string, args?: Record<string, unknown>): Promise<MCPToolResult>
+}
+
+export interface MCPServerResourceProvider {
+  listResources(): MCPResource[]
+  readResource(uri: string): Promise<MCPContentBlock[]>
+}
+
+export class MCPServer {
+  readonly id: MCPServerId
+  private config: MCPServerConfig
+  private toolProvider: MCPServerToolProvider
+  private resourceProvider?: MCPServerResourceProvider
+  private transport: MCPTransport | null = null
+  private running = false
+  private connectedClients = 0
+  private startedAt?: number
+  private log: Logger
+
+  constructor(
+    config: MCPServerConfig,
+    toolProvider: MCPServerToolProvider,
+    resourceProvider?: MCPServerResourceProvider,
+  ) {
+    this.id = config.id ?? generateMCPServerId()
+    this.config = config
+    this.toolProvider = toolProvider
+    this.resourceProvider = resourceProvider
+    this.log = getRootLogger().child({ component: 'MCPServer', serverId: this.id })
+  }
+
+  async start(transport: MCPTransport): Promise<void> {
+    if (this.running) {
+      throw new Error(`MCPServer "${this.config.name}" is already running`)
+    }
+
+    this.transport = transport
+
+    transport.onMessage((msg) => this.handleRequest(msg))
+    transport.onClose(() => {
+      this.connectedClients = Math.max(0, this.connectedClients - 1)
+      this.log.info('MCP client disconnected')
+    })
+    transport.onError((err) => {
+      this.log.error('MCP server transport error', { error: err.message })
+    })
+
+    await transport.connect()
+    this.running = true
+    this.startedAt = Date.now()
+    this.log.info(`MCPServer "${this.config.name}" started`)
+  }
+
+  async stop(): Promise<void> {
+    if (!this.running) return
+    this.running = false
+    if (this.transport) {
+      await this.transport.close()
+      this.transport = null
+    }
+    this.log.info(`MCPServer "${this.config.name}" stopped`)
+  }
+
+  isRunning(): boolean {
+    return this.running
+  }
+
+  getState(): MCPServerState {
+    return {
+      id: this.id,
+      name: this.config.name,
+      running: this.running,
+      connectedClients: this.connectedClients,
+      startedAt: this.startedAt,
+    }
+  }
+
+  private async handleRequest(message: MCPJsonRpcMessage): Promise<void> {
+    if (message.id === undefined || !message.method) return
+
+    try {
+      const result = await this.dispatch(message.method, message.params ?? {})
+      await this.respond(message.id, result)
+    } catch (err) {
+      await this.respondError(message.id, -32603, toErrorMessage(err))
+    }
+  }
+
+  private async dispatch(method: string, params: Record<string, unknown>): Promise<unknown> {
+    switch (method) {
+      case 'initialize':
+        return this.handleInitialize()
+      case 'tools/list':
+        return this.handleToolsList()
+      case 'tools/call':
+        return this.handleToolsCall(params)
+      case 'resources/list':
+        return this.handleResourcesList()
+      case 'resources/read':
+        return this.handleResourcesRead(params)
+      case 'ping':
+        return {}
+      default:
+        throw new Error(`Unknown method: ${method}`)
+    }
+  }
+
+  private handleInitialize(): {
+    protocolVersion: string
+    capabilities: MCPServerCapabilities
+    serverInfo: { name: string; version?: string }
+  } {
+    this.connectedClients++
+    const capabilities: MCPServerCapabilities = {
+      tools: { listChanged: false },
+      ...this.config.capabilities,
+    }
+
+    if (this.resourceProvider) {
+      capabilities.resources = { subscribe: false, listChanged: false }
+    }
+
+    return {
+      protocolVersion: '2024-11-05',
+      capabilities,
+      serverInfo: {
+        name: this.config.name,
+        version: this.config.version,
+      },
+    }
+  }
+
+  private handleToolsList(): { tools: MCPToolDefinition[] } {
+    return { tools: this.toolProvider.listTools() }
+  }
+
+  private async handleToolsCall(params: Record<string, unknown>): Promise<MCPToolResult> {
+    const name = params['name'] as string
+    const args = (params['arguments'] ?? {}) as Record<string, unknown>
+
+    if (!name) {
+      return {
+        content: [{ type: 'text', text: 'Missing tool name' }],
+        isError: true,
+      }
+    }
+
+    return this.toolProvider.callTool(name, args)
+  }
+
+  private handleResourcesList(): { resources: MCPResource[] } {
+    if (!this.resourceProvider) {
+      return { resources: [] }
+    }
+    return { resources: this.resourceProvider.listResources() }
+  }
+
+  private async handleResourcesRead(params: Record<string, unknown>): Promise<{ contents: MCPContentBlock[] }> {
+    const uri = params['uri'] as string
+    if (!uri) {
+      throw new Error('Missing resource URI')
+    }
+    if (!this.resourceProvider) {
+      throw new Error('Resource provider not configured')
+    }
+    return { contents: await this.resourceProvider.readResource(uri) }
+  }
+
+  private async respond(id: string | number, result: unknown): Promise<void> {
+    if (!this.transport) return
+    await this.transport.send({
+      jsonrpc: '2.0',
+      id,
+      result,
+    })
+  }
+
+  private async respondError(id: string | number, code: number, message: string): Promise<void> {
+    if (!this.transport) return
+    await this.transport.send({
+      jsonrpc: '2.0',
+      id,
+      error: { code, message },
+    })
+  }
+}

package/src/connector/mcp/stdio.ts

@@ -0,0 +1,102 @@
+import { spawn, type ChildProcess } from 'node:child_process'
+import type {
+  MCPTransport,
+  MCPJsonRpcMessage,
+  MCPStdioTransportConfig,
+} from '../../types/connector/index.js'
+import { getRootLogger, type Logger } from '../../utils/logger.js'
+
+export class StdioTransport implements MCPTransport {
+  private process: ChildProcess | null = null
+  private messageHandlers: Array<(message: MCPJsonRpcMessage) => void> = []
+  private closeHandlers: Array<() => void> = []
+  private errorHandlers: Array<(error: Error) => void> = []
+  private connected = false
+  private buffer = ''
+  private log: Logger
+
+  constructor(private readonly config: MCPStdioTransportConfig) {
+    this.log = getRootLogger().child({ component: 'StdioTransport' })
+  }
+
+  async connect(): Promise<void> {
+    if (this.connected) return
+
+    this.process = spawn(this.config.command, this.config.args ?? [], {
+      env: { ...process.env, ...this.config.env },
+      cwd: this.config.cwd,
+      stdio: ['pipe', 'pipe', 'pipe'],
+    })
+
+    this.process.stdout!.on('data', (chunk: Buffer) => {
+      this.buffer += chunk.toString('utf-8')
+      this.processBuffer()
+    })
+
+    this.process.stderr!.on('data', (chunk: Buffer) => {
+      this.log.warn(`MCP server stderr: ${chunk.toString('utf-8').trim()}`)
+    })
+
+    this.process.on('close', (code) => {
+      this.connected = false
+      this.log.info(`MCP server process exited with code ${code}`)
+      for (const handler of this.closeHandlers) handler()
+    })
+
+    this.process.on('error', (err) => {
+      this.connected = false
+      for (const handler of this.errorHandlers) handler(err)
+    })
+
+    this.connected = true
+    this.log.info(`StdioTransport connected: ${this.config.command} ${(this.config.args ?? []).join(' ')}`)
+  }
+
+  async close(): Promise<void> {
+    if (!this.process) return
+    this.connected = false
+    this.process.kill('SIGTERM')
+    this.process = null
+    this.buffer = ''
+  }
+
+  async send(message: MCPJsonRpcMessage): Promise<void> {
+    if (!this.process?.stdin?.writable) {
+      throw new Error('StdioTransport: not connected or stdin not writable')
+    }
+    const data = JSON.stringify(message) + '\n'
+    this.process.stdin.write(data)
+  }
+
+  onMessage(handler: (message: MCPJsonRpcMessage) => void): void {
+    this.messageHandlers.push(handler)
+  }
+
+  onClose(handler: () => void): void {
+    this.closeHandlers.push(handler)
+  }
+
+  onError(handler: (error: Error) => void): void {
+    this.errorHandlers.push(handler)
+  }
+
+  isConnected(): boolean {
+    return this.connected
+  }
+
+  private processBuffer(): void {
+    const lines = this.buffer.split('\n')
+    this.buffer = lines.pop() ?? ''
+
+    for (const line of lines) {
+      const trimmed = line.trim()
+      if (!trimmed) continue
+      try {
+        const message = JSON.parse(trimmed) as MCPJsonRpcMessage
+        for (const handler of this.messageHandlers) handler(message)
+      } catch {
+        this.log.warn(`StdioTransport: invalid JSON-RPC message: ${trimmed.slice(0, 100)}`)
+      }
+    }
+  }
+}

package/src/contracts/a2a.ts

@@ -0,0 +1,113 @@
+import { z } from 'zod'
+
+export const A2ATaskStateSchema = z.enum([
+  'pending',
+  'running',
+  'completed',
+  'failed',
+  'canceled',
+  'rejected',
+  'input-required',
+])
+
+export const A2APartKindSchema = z.enum(['text', 'file', 'data'])
+export const A2AMessageRoleSchema = z.enum(['user', 'agent'])
+export const A2ATransportSchema = z.enum(['jsonrpc', 'rest', 'grpc'])
+
+export const TextPartSchema = z.object({
+  kind: z.literal('text'),
+  text: z.string().min(1),
+  metadata: z.record(z.unknown()).optional(),
+}).strict()
+
+export const FilePartSchema = z.object({
+  kind: z.literal('file'),
+  file: z.object({
+    uri: z.string().url(),
+    mimeType: z.string().min(1),
+    name: z.string().optional(),
+    bytes: z.string().optional(),
+  }).strict(),
+  metadata: z.record(z.unknown()).optional(),
+}).strict()
+
+export const DataPartSchema = z.object({
+  kind: z.literal('data'),
+  data: z.record(z.unknown()),
+  mimeType: z.string().optional(),
+  metadata: z.record(z.unknown()).optional(),
+}).strict()
+
+export const A2APartSchema = z.discriminatedUnion('kind', [
+  TextPartSchema,
+  FilePartSchema,
+  DataPartSchema,
+])
+
+export const A2AMessageSchema = z.object({
+  role: A2AMessageRoleSchema,
+  parts: z.array(A2APartSchema).min(1, 'Message must have at least one part'),
+  metadata: z.record(z.unknown()).optional(),
+}).strict()
+
+export const A2ATaskStatusSchema = z.object({
+  state: A2ATaskStateSchema,
+  message: A2AMessageSchema.optional(),
+  timestamp: z.string().optional(),
+}).strict()
+
+export const A2AArtifactSchema = z.object({
+  artifactId: z.string().min(1),
+  name: z.string().optional(),
+  description: z.string().optional(),
+  parts: z.array(A2APartSchema).min(1),
+  metadata: z.record(z.unknown()).optional(),
+}).strict()
+
+export const A2AMessageSendSchema = z.object({
+  message: A2AMessageSchema,
+  id: z.string().optional(),
+  contextId: z.string().optional(),
+  metadata: z.record(z.unknown()).optional(),
+}).strict()
+
+export const A2ATaskGetSchema = z.object({
+  id: z.string().min(1, 'Task ID is required'),
+  includeHistory: z.boolean().optional(),
+}).strict()
+
+export const A2ATaskListSchema = z.object({
+  contextId: z.string().optional(),
+  state: A2ATaskStateSchema.optional(),
+  limit: z.number().int().min(1).max(100).default(20),
+  cursor: z.string().optional(),
+}).strict()
+
+export const A2ATaskCancelSchema = z.object({
+  id: z.string().min(1, 'Task ID is required'),
+}).strict()
+
+export const A2ATaskSchema = z.object({
+  id: z.string(),
+  contextId: z.string().optional(),
+  status: A2ATaskStatusSchema,
+  history: z.array(A2AMessageSchema).optional(),
+  artifacts: z.array(A2AArtifactSchema).optional(),
+  metadata: z.record(z.unknown()).optional(),
+})
+
+export const A2AErrorCodeSchema = z.enum([
+  'TaskNotFound',
+  'TaskNotCancelable',
+  'ContentTypeNotSupported',
+  'UnsupportedOperation',
+  'PushNotificationNotSupported',
+  'InvalidRequest',
+  'InternalError',
+  'Unauthorized',
+])
+
+export type A2AMessageSendInput = z.infer<typeof A2AMessageSendSchema>
+export type A2ATaskGetInput = z.infer<typeof A2ATaskGetSchema>
+export type A2ATaskListInput = z.infer<typeof A2ATaskListSchema>
+export type A2ATaskCancelInput = z.infer<typeof A2ATaskCancelSchema>