@namzu/sdk 0.1.1 → 0.1.2

package/src/connector/mcp/server.ts

@@ -1,204 +1,206 @@
 import type {
-  MCPTransport,
-  MCPJsonRpcMessage,
-  MCPServerConfig,
-  MCPServerState,
-  MCPServerCapabilities,
-  MCPToolDefinition,
-  MCPToolResult,
-  MCPResource,
-  MCPContentBlock,
+	MCPContentBlock,
+	MCPJsonRpcMessage,
+	MCPResource,
+	MCPServerCapabilities,
+	MCPServerConfig,
+	MCPServerState,
+	MCPToolDefinition,
+	MCPToolResult,
+	MCPTransport,
 } 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'
+import { generateMCPServerId } from '../../utils/id.js'
+import { type Logger, getRootLogger } from '../../utils/logger.js'
 
 export interface MCPServerToolProvider {
-  listTools(): MCPToolDefinition[]
-  callTool(name: string, args?: Record<string, unknown>): Promise<MCPToolResult>
+	listTools(): MCPToolDefinition[]
+	callTool(name: string, args?: Record<string, unknown>): Promise<MCPToolResult>
 }
 
 export interface MCPServerResourceProvider {
-  listResources(): MCPResource[]
-  readResource(uri: string): Promise<MCPContentBlock[]>
+	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 },
-    })
-  }
+	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

@@ -1,102 +1,104 @@
-import { spawn, type ChildProcess } from 'node:child_process'
+import { type ChildProcess, spawn } from 'node:child_process'
 import type {
-  MCPTransport,
-  MCPJsonRpcMessage,
-  MCPStdioTransportConfig,
+	MCPJsonRpcMessage,
+	MCPStdioTransportConfig,
+	MCPTransport,
 } from '../../types/connector/index.js'
-import { getRootLogger, type Logger } from '../../utils/logger.js'
+import { type Logger, getRootLogger } 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)}`)
-      }
-    }
-  }
+	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/constants/a2a/index.ts

@@ -0,0 +1,21 @@
+import type { RunStatus } from '../../contracts/index.js'
+import type { A2ATaskState } from '../../types/a2a/index.js'
+
+export const A2A_PROTOCOL_VERSION = '0.3.0'
+
+export const RUN_STATUS_TO_A2A: Record<RunStatus, A2ATaskState> = {
+	queued: 'pending',
+	running: 'running',
+	completed: 'completed',
+	failed: 'failed',
+	cancelled: 'canceled',
+	cancelling: 'running',
+	expired: 'failed',
+}
+
+export const TERMINAL_STATES: ReadonlySet<A2ATaskState> = new Set([
+	'completed',
+	'failed',
+	'canceled',
+	'rejected',
+])

package/src/constants/agent/index.ts

@@ -0,0 +1,17 @@
+import type { AgentCapabilities } from '../../types/agent/index.js'
+import type { AgentManagerConfig } from '../../types/agent/task.js'
+
+export const MAX_RECENT_ACTIVITIES = 5
+
+export const AGENT_MANAGER_DEFAULTS: Readonly<AgentManagerConfig> = {
+	maxDepth: 3,
+	evictionMs: 30_000,
+	maxBudgetFraction: 0.5,
+}
+
+export const DEFAULT_CAPABILITIES: AgentCapabilities = {
+	supportsTools: false,
+	supportsStreaming: false,
+	supportsConcurrency: false,
+	supportsSubAgents: false,
+}

package/src/constants/index.ts

@@ -0,0 +1,8 @@
+export * from './a2a/index.js'
+export * from './mcp/index.js'
+export * from './provider/index.js'
+export * from './rag/index.js'
+export * from './tools/index.js'
+export * from './telemetry/index.js'
+export * from './agent/index.js'
+export * from './limits.js'