@namzu/sdk 0.1.1 → 0.1.2

package/src/bridge/a2a/task.ts

@@ -1,125 +1,105 @@
+import { RUN_STATUS_TO_A2A, TERMINAL_STATES } from '../../constants/a2a/index.js'
+import type { Run, RunConfig, RunStatus, ThreadMessage } from '../../contracts/index.js'
 import type {
-  Run,
-  RunStatus,
-  ThreadMessage,
-  RunConfig,
-} from '../../contracts/index.js'
-import type {
-  A2ATask,
-  A2ATaskState,
-  A2ATaskStatus,
-  A2AArtifact,
-  A2AMessage,
-  A2AMessageSendParams,
+	A2AArtifact,
+	A2AMessage,
+	A2AMessageSendParams,
+	A2ATask,
+	A2ATaskState,
+	A2ATaskStatus,
 } from '../../types/a2a/index.js'
-import { threadMessageToA2A, extractTextFromA2AMessage } from './message.js'
-
-const RUN_STATUS_TO_A2A: Record<RunStatus, A2ATaskState> = {
-  queued: 'pending',
-  running: 'running',
-  completed: 'completed',
-  failed: 'failed',
-  cancelled: 'canceled',
-  cancelling: 'running',
-  expired: 'failed',
-}
-
-const TERMINAL_STATES: ReadonlySet<A2ATaskState> = new Set([
-  'completed',
-  'failed',
-  'canceled',
-  'rejected',
-])
+import { extractTextFromA2AMessage, threadMessageToA2A } from './message.js'
 
 export function isTerminalState(state: A2ATaskState): boolean {
-  return TERMINAL_STATES.has(state)
+	return TERMINAL_STATES.has(state)
 }
 
 export function runStatusToA2AState(status: RunStatus): A2ATaskState {
-  return RUN_STATUS_TO_A2A[status]
+	return RUN_STATUS_TO_A2A[status]
 }
 
 function buildTaskStatus(run: Run): A2ATaskStatus {
-  const state = runStatusToA2AState(run.status)
-  const timestamp = run.completed_at ?? run.started_at ?? run.created_at
+	const state = runStatusToA2AState(run.status)
+	const timestamp = run.completed_at ?? run.started_at ?? run.created_at
 
-  const message: A2AMessage | undefined = run.result
-    ? { role: 'agent', parts: [{ kind: 'text', text: run.result }] }
-    : run.last_error
-      ? { role: 'agent', parts: [{ kind: 'text', text: run.last_error }] }
-      : undefined
+	const message: A2AMessage | undefined = run.result
+		? { role: 'agent', parts: [{ kind: 'text', text: run.result }] }
+		: run.last_error
+			? { role: 'agent', parts: [{ kind: 'text', text: run.last_error }] }
+			: undefined
 
-  return { state, message, timestamp }
+	return { state, message, timestamp }
 }
 
 function buildArtifacts(run: Run): A2AArtifact[] | undefined {
-  if (!run.result) return undefined
+	if (!run.result) return undefined
 
-  return [
-    {
-      artifactId: `${run.id}-result`,
-      name: 'Agent Response',
-      parts: [{ kind: 'text', text: run.result }],
-      metadata: {
-        model: run.model,
-        iterations: run.iterations,
-        duration_ms: run.duration_ms,
-        ...(run.usage && {
-          input_tokens: run.usage.input_tokens,
-          output_tokens: run.usage.output_tokens,
-          total_cost_usd: run.usage.total_cost_usd,
-        }),
-      },
-    },
-  ]
+	return [
+		{
+			artifactId: `${run.id}-result`,
+			name: 'Agent Response',
+			parts: [{ kind: 'text', text: run.result }],
+			metadata: {
+				model: run.model,
+				iterations: run.iterations,
+				duration_ms: run.duration_ms,
+				...(run.usage && {
+					input_tokens: run.usage.input_tokens,
+					output_tokens: run.usage.output_tokens,
+					total_cost_usd: run.usage.total_cost_usd,
+				}),
+			},
+		},
+	]
 }
 
-export function runToA2ATask(
-  run: Run,
-  messages?: readonly ThreadMessage[],
-): A2ATask {
-  return {
-    id: run.id,
-    contextId: run.thread_id ?? undefined,
-    status: buildTaskStatus(run),
-    history: messages?.map(threadMessageToA2A),
-    artifacts: buildArtifacts(run),
-    metadata: {
-      agent_id: run.agent_id,
-      agent_name: run.agent_name,
-      stop_reason: run.stop_reason,
-    },
-  }
+export function runToA2ATask(run: Run, messages?: readonly ThreadMessage[]): A2ATask {
+	return {
+		id: run.id,
+		contextId: run.thread_id ?? undefined,
+		status: buildTaskStatus(run),
+		history: messages?.map(threadMessageToA2A),
+		artifacts: buildArtifacts(run),
+		metadata: {
+			agent_id: run.agent_id,
+			agent_name: run.agent_name,
+			stop_reason: run.stop_reason,
+		},
+	}
 }
 
 export interface CreateRunFromA2A {
-  readonly agentId: string
-  readonly input: string
-  readonly threadId?: string
-  readonly config: RunConfig
+	readonly agentId: string
+	readonly input: string
+	readonly threadId?: string
+	readonly config: RunConfig
 }
 
 export function a2aMessageToCreateRun(
-  agentId: string,
-  params: A2AMessageSendParams,
+	agentId: string,
+	params: A2AMessageSendParams,
 ): CreateRunFromA2A {
-  const input = extractTextFromA2AMessage(params.message)
-  const meta = params.metadata ?? {}
+	const input = extractTextFromA2AMessage(params.message)
+	const meta = params.metadata ?? {}
 
-  const config: RunConfig = {
-    ...(typeof meta.model === 'string' && { model: meta.model }),
-    ...(typeof meta.tokenBudget === 'number' && { tokenBudget: meta.tokenBudget }),
-    ...(typeof meta.timeoutMs === 'number' && { timeoutMs: meta.timeoutMs }),
-    ...(typeof meta.temperature === 'number' && { temperature: meta.temperature }),
-    ...(typeof meta.maxResponseTokens === 'number' && { maxResponseTokens: meta.maxResponseTokens }),
-    ...((meta.permissionMode === 'plan' || meta.permissionMode === 'auto') && { permissionMode: meta.permissionMode }),
-    ...(typeof meta.systemPrompt === 'string' && { systemPrompt: meta.systemPrompt }),
-  }
+	const config: RunConfig = {
+		...(typeof meta.model === 'string' && { model: meta.model }),
+		...(typeof meta.tokenBudget === 'number' && { tokenBudget: meta.tokenBudget }),
+		...(typeof meta.timeoutMs === 'number' && { timeoutMs: meta.timeoutMs }),
+		...(typeof meta.temperature === 'number' && { temperature: meta.temperature }),
+		...(typeof meta.maxResponseTokens === 'number' && {
+			maxResponseTokens: meta.maxResponseTokens,
+		}),
+		...((meta.permissionMode === 'plan' || meta.permissionMode === 'auto') && {
+			permissionMode: meta.permissionMode,
+		}),
+		...(typeof meta.systemPrompt === 'string' && { systemPrompt: meta.systemPrompt }),
+	}
 
-  return {
-    agentId,
-    input,
-    threadId: params.contextId,
-    config,
-  }
+	return {
+		agentId,
+		input,
+		threadId: params.contextId,
+		config,
+	}
 }

package/src/bridge/mcp/connector/adapter.ts

@@ -1,123 +1,122 @@
+import { zodToJsonSchema } from 'zod-to-json-schema'
+import type { ConnectorManager } from '../../../manager/connector/lifecycle.js'
 import type {
-  MCPToolDefinition,
-  MCPToolResult,
-  MCPConnectorBridgeToolMapping,
-  MCPJsonSchema,
-  ConnectorInstance,
-  ConnectorDefinition,
-  ConnectorMethod,
-  ConnectorExecuteResult,
+	ConnectorDefinition,
+	ConnectorExecuteResult,
+	ConnectorInstance,
+	ConnectorMethod,
+	MCPConnectorBridgeToolMapping,
+	MCPJsonSchema,
+	MCPToolDefinition,
+	MCPToolResult,
 } from '../../../types/connector/index.js'
 import type { ConnectorInstanceId } from '../../../types/ids/index.js'
-import type { ConnectorManager } from '../../../manager/connector/lifecycle.js'
-import { zodToJsonSchema } from 'zod-to-json-schema'
-import { getRootLogger, type Logger } from '../../../utils/logger.js'
+import { type Logger, getRootLogger } from '../../../utils/logger.js'
 
 export class MCPConnectorBridge {
-  private manager: ConnectorManager
-  private prefix: string
-  private mappings: MCPConnectorBridgeToolMapping[] = []
-  private log: Logger
-
-  constructor(config: { manager: ConnectorManager; prefix?: string }) {
-    this.manager = config.manager
-    this.prefix = config.prefix ?? 'namzu'
-    this.log = getRootLogger().child({ component: 'MCPConnectorBridge' })
-  }
-
-  listTools(instanceId?: ConnectorInstanceId): MCPToolDefinition[] {
-    const instances = instanceId
-      ? [this.manager.getInstance(instanceId)].filter(Boolean) as ConnectorInstance[]
-      : this.manager.listConnectedInstances()
-
-    this.mappings = []
-    const tools: MCPToolDefinition[] = []
-
-    for (const instance of instances) {
-      const definition = this.manager.getRegistry().get(instance.connectorId)
-      if (!definition) continue
-
-      for (const method of definition.methods) {
-        const mcpTool = this.methodToMCPTool(instance, definition, method)
-        tools.push(mcpTool)
-      }
-    }
-
-    this.log.info(`Bridge generated ${tools.length} MCP tools from ${instances.length} instances`)
-    return tools
-  }
-
-  async callTool(name: string, args?: Record<string, unknown>): Promise<MCPToolResult> {
-    const mapping = this.mappings.find((m) => m.mcpToolName === name)
-    if (!mapping) {
-      return {
-        content: [{ type: 'text', text: `Unknown tool: "${name}"` }],
-        isError: true,
-      }
-    }
-
-    const result = await this.manager.execute({
-      instanceId: mapping.instanceId,
-      method: mapping.methodName,
-      input: args ?? {},
-    })
-
-    return this.connectorResultToMCPResult(result)
-  }
-
-  getMappings(): MCPConnectorBridgeToolMapping[] {
-    return [...this.mappings]
-  }
-
-  private methodToMCPTool(
-    instance: ConnectorInstance,
-    definition: ConnectorDefinition,
-    method: ConnectorMethod,
-  ): MCPToolDefinition {
-    const mcpToolName = `${this.prefix}_${instance.connectorId}_${method.name}`
-
-    this.mappings.push({
-      mcpToolName,
-      connectorId: instance.connectorId,
-      instanceId: instance.id,
-      methodName: method.name,
-    })
-
-    const inputSchema = this.zodToMCPSchema(method)
-
-    return {
-      name: mcpToolName,
-      description: `[${definition.name}] ${method.description}`,
-      inputSchema,
-    }
-  }
-
-  private zodToMCPSchema(method: ConnectorMethod): MCPJsonSchema {
-    try {
-      const jsonSchema = zodToJsonSchema(method.inputSchema, { target: 'openApi3' })
-      return {
-        type: 'object',
-        ...jsonSchema,
-      } as MCPJsonSchema
-    } catch {
-      return { type: 'object' }
-    }
-  }
-
-  private connectorResultToMCPResult(result: ConnectorExecuteResult): MCPToolResult {
-    if (result.success) {
-      const text = typeof result.output === 'string'
-        ? result.output
-        : JSON.stringify(result.output, null, 2)
-      return {
-        content: [{ type: 'text', text }],
-        isError: false,
-      }
-    }
-
-    return {
-      content: [{ type: 'text', text: result.error ?? 'Unknown error' }],
-      isError: true,
-    }
-  }
+	private manager: ConnectorManager
+	private prefix: string
+	private mappings: MCPConnectorBridgeToolMapping[] = []
+	private log: Logger
+
+	constructor(config: { manager: ConnectorManager; prefix?: string }) {
+		this.manager = config.manager
+		this.prefix = config.prefix ?? 'namzu'
+		this.log = getRootLogger().child({ component: 'MCPConnectorBridge' })
+	}
+
+	listTools(instanceId?: ConnectorInstanceId): MCPToolDefinition[] {
+		const instances = instanceId
+			? ([this.manager.getInstance(instanceId)].filter(Boolean) as ConnectorInstance[])
+			: this.manager.listConnectedInstances()
+
+		this.mappings = []
+		const tools: MCPToolDefinition[] = []
+
+		for (const instance of instances) {
+			const definition = this.manager.getRegistry().get(instance.connectorId)
+			if (!definition) continue
+
+			for (const method of definition.methods) {
+				const mcpTool = this.methodToMCPTool(instance, definition, method)
+				tools.push(mcpTool)
+			}
+		}
+
+		this.log.info(`Bridge generated ${tools.length} MCP tools from ${instances.length} instances`)
+		return tools
+	}
+
+	async callTool(name: string, args?: Record<string, unknown>): Promise<MCPToolResult> {
+		const mapping = this.mappings.find((m) => m.mcpToolName === name)
+		if (!mapping) {
+			return {
+				content: [{ type: 'text', text: `Unknown tool: "${name}"` }],
+				isError: true,
+			}
+		}
+
+		const result = await this.manager.execute({
+			instanceId: mapping.instanceId,
+			method: mapping.methodName,
+			input: args ?? {},
+		})
+
+		return this.connectorResultToMCPResult(result)
+	}
+
+	getMappings(): MCPConnectorBridgeToolMapping[] {
+		return [...this.mappings]
+	}
+
+	private methodToMCPTool(
+		instance: ConnectorInstance,
+		definition: ConnectorDefinition,
+		method: ConnectorMethod,
+	): MCPToolDefinition {
+		const mcpToolName = `${this.prefix}_${instance.connectorId}_${method.name}`
+
+		this.mappings.push({
+			mcpToolName,
+			connectorId: instance.connectorId,
+			instanceId: instance.id,
+			methodName: method.name,
+		})
+
+		const inputSchema = this.zodToMCPSchema(method)
+
+		return {
+			name: mcpToolName,
+			description: `[${definition.name}] ${method.description}`,
+			inputSchema,
+		}
+	}
+
+	private zodToMCPSchema(method: ConnectorMethod): MCPJsonSchema {
+		try {
+			const jsonSchema = zodToJsonSchema(method.inputSchema, { target: 'openApi3' })
+			return {
+				type: 'object',
+				...jsonSchema,
+			} as MCPJsonSchema
+		} catch {
+			return { type: 'object' }
+		}
+	}
+
+	private connectorResultToMCPResult(result: ConnectorExecuteResult): MCPToolResult {
+		if (result.success) {
+			const text =
+				typeof result.output === 'string' ? result.output : JSON.stringify(result.output, null, 2)
+			return {
+				content: [{ type: 'text', text }],
+				isError: false,
+			}
+		}
+
+		return {
+			content: [{ type: 'text', text: result.error ?? 'Unknown error' }],
+			isError: true,
+		}
+	}
 }

package/src/bridge/sse/index.ts

@@ -1,2 +1,2 @@
-export { mapRunToStreamEvent, mapSessionToStreamEvent } from "./mapper.js";
-export type { MappedStreamEvent } from "./mapper.js";
+export { mapRunToStreamEvent, mapSessionToStreamEvent } from './mapper.js'
+export type { MappedStreamEvent } from './mapper.js'