@namzu/sdk 0.1.1

package/src/bridge/a2a/mapper.ts

@@ -0,0 +1,172 @@
+import type {
+	A2AStreamEvent,
+	TaskArtifactUpdateEvent,
+	TaskStatusUpdateEvent,
+} from "../../types/a2a/index.js";
+
+import type { RunEvent } from "../../types/run/events.js";
+
+function statusEvent(
+	taskId: string,
+	state: TaskStatusUpdateEvent["status"]["state"],
+	isFinal: boolean,
+	contextId?: string,
+	message?: TaskStatusUpdateEvent["status"]["message"],
+): TaskStatusUpdateEvent {
+	return {
+		taskId,
+		contextId,
+		status: {
+			state,
+			message,
+			timestamp: new Date().toISOString(),
+		},
+		final: isFinal,
+	};
+}
+
+function artifactEvent(
+	taskId: string,
+	contextId: string | undefined,
+	artifact: TaskArtifactUpdateEvent["artifact"],
+): TaskArtifactUpdateEvent {
+	return {
+		taskId,
+		contextId,
+		artifact,
+	};
+}
+
+type A2ATransform<K extends RunEvent["type"]> =
+	| ((
+			event: Extract<RunEvent, { type: K }>,
+			contextId?: string,
+	  ) => A2AStreamEvent | null)
+	| null;
+
+const MAPPING: {
+	[K in RunEvent["type"]]: A2ATransform<K>;
+} = {
+	run_started: (e, ctx) => statusEvent(e.runId, "running", false, ctx),
+
+	run_completed: (e, ctx) => {
+		const completedEvent = statusEvent(e.runId, "completed", true, ctx, {
+			role: "agent",
+			parts: [{ kind: "text", text: e.result }],
+		});
+		return completedEvent;
+	},
+
+	run_failed: (e, ctx) =>
+		statusEvent(e.runId, "failed", true, ctx, {
+			role: "agent",
+			parts: [{ kind: "text", text: e.error }],
+		}),
+
+	iteration_started: (e, ctx) =>
+		statusEvent(e.runId, "running", false, ctx, {
+			role: "agent",
+			parts: [{ kind: "text", text: `Iteration ${e.iteration} started` }],
+		}),
+
+	llm_response: (e, ctx) => {
+		if (!e.content) return null;
+		return statusEvent(e.runId, "running", false, ctx, {
+			role: "agent",
+			parts: [{ kind: "text", text: e.content }],
+		});
+	},
+
+	tool_completed: (e, ctx) =>
+		artifactEvent(e.runId, ctx, {
+			artifactId: `tool-${e.toolName}-${Date.now()}`,
+			name: `${e.toolName} result`,
+			parts: [{ kind: "text", text: e.result }],
+			metadata: { toolName: e.toolName },
+		}),
+
+	tool_review_requested: (e, ctx) => {
+		const toolNames = e.toolCalls.map((tc) => tc.name).join(", ");
+		return statusEvent(e.runId, "input-required", false, ctx, {
+			role: "agent",
+			parts: [
+				{ kind: "text", text: `Review requested for tools: ${toolNames}` },
+				{
+					kind: "data",
+					data: {
+						toolCalls: e.toolCalls.map((tc) => ({
+							id: tc.id,
+							name: tc.name,
+							isDestructive: tc.isDestructive,
+						})),
+					},
+					mimeType: "application/x-namzu-review-request",
+				},
+			],
+		});
+	},
+
+	plan_ready: (e, ctx) =>
+		statusEvent(e.runId, "input-required", false, ctx, {
+			role: "agent",
+			parts: [
+				{ kind: "text", text: `Plan ready: ${e.title}` },
+				{
+					kind: "data",
+					data: {
+						planId: e.planId,
+						title: e.title,
+						summary: e.summary,
+						steps: e.steps.map((s) => ({
+							id: s.id,
+							description: s.description,
+							toolName: s.toolName,
+						})),
+					},
+					mimeType: "application/x-namzu-plan",
+				},
+			],
+		}),
+
+	run_paused: (e, ctx) =>
+		statusEvent(e.runId, "input-required", false, ctx, {
+			role: "agent",
+			parts: [{ kind: "text", text: `Session paused: ${e.reason}` }],
+		}),
+
+	iteration_completed: null,
+	tool_executing: null,
+	tool_review_completed: null,
+	checkpoint_created: null,
+	run_resuming: null,
+	token_usage_updated: null,
+	activity_created: null,
+	activity_updated: null,
+	plan_approved: null,
+	plan_rejected: null,
+	plan_step_updated: null,
+
+	agent_pending: null,
+	agent_completed: null,
+	agent_failed: null,
+	agent_canceled: null,
+
+	task_created: null,
+	task_updated: null,
+};
+
+export function mapRunToA2AEvent(
+	event: RunEvent,
+	contextId?: string,
+): A2AStreamEvent | null {
+	const transform = MAPPING[event.type];
+	if (!transform) return null;
+	return (
+		transform as (
+			event: RunEvent,
+			contextId?: string,
+		) => A2AStreamEvent | null
+	)(event, contextId);
+}
+
+export const mapSessionToA2AEvent = mapRunToA2AEvent;

package/src/bridge/a2a/message.ts

@@ -0,0 +1,97 @@
+import type { ThreadMessage } from '../../contracts/index.js'
+import type { MessageRole } from '../../types/message/index.js'
+import type { Message } from '../../types/message/index.js'
+import type {
+  A2AMessage,
+  A2AMessageRole,
+  A2APart,
+  TextPart,
+} from '../../types/a2a/index.js'
+
+function toA2ARole(role: MessageRole): A2AMessageRole {
+  switch (role) {
+    case 'user':
+      return 'user'
+    case 'assistant':
+    case 'system':
+    case 'tool':
+      return 'agent'
+    default: {
+      const _exhaustive: never = role
+      throw new Error(`Unhandled message role: ${_exhaustive}`)
+    }
+  }
+}
+
+export function messageToA2A(msg: Message): A2AMessage {
+  const parts: A2APart[] = []
+
+  if (msg.content) {
+    parts.push({ kind: 'text', text: msg.content })
+  }
+
+  if (msg.role === 'assistant' && 'toolCalls' in msg && msg.toolCalls) {
+    for (const tc of msg.toolCalls) {
+      parts.push({
+        kind: 'data',
+        data: {
+          toolCallId: tc.id,
+          name: tc.function.name,
+          arguments: tc.function.arguments,
+        },
+        mimeType: 'application/x-namzu-tool-call',
+      })
+    }
+  }
+
+  if (parts.length === 0) {
+    parts.push({ kind: 'text', text: '' })
+  }
+
+  return {
+    role: toA2ARole(msg.role),
+    parts,
+  }
+}
+
+export function threadMessageToA2A(msg: ThreadMessage): A2AMessage {
+  const parts: A2APart[] = []
+
+  if (msg.content) {
+    parts.push({ kind: 'text', text: msg.content })
+  }
+
+  if (msg.tool_calls) {
+    for (const tc of msg.tool_calls) {
+      parts.push({
+        kind: 'data',
+        data: {
+          toolCallId: tc.id,
+          name: tc.function.name,
+          arguments: tc.function.arguments,
+        },
+        mimeType: 'application/x-namzu-tool-call',
+      })
+    }
+  }
+
+  if (parts.length === 0) {
+    parts.push({ kind: 'text', text: '' })
+  }
+
+  return {
+    role: toA2ARole(msg.role),
+    parts,
+  }
+}
+
+export function extractTextFromA2AMessage(msg: A2AMessage): string {
+  return msg.parts
+    .filter((p): p is TextPart => p.kind === 'text')
+    .map((p) => p.text)
+    .join('\n')
+}
+
+export function a2aMessageToInput(msg: A2AMessage): string {
+  return extractTextFromA2AMessage(msg)
+}

package/src/bridge/a2a/task.ts

@@ -0,0 +1,125 @@
+import type {
+  Run,
+  RunStatus,
+  ThreadMessage,
+  RunConfig,
+} from '../../contracts/index.js'
+import type {
+  A2ATask,
+  A2ATaskState,
+  A2ATaskStatus,
+  A2AArtifact,
+  A2AMessage,
+  A2AMessageSendParams,
+} 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',
+])
+
+export function isTerminalState(state: A2ATaskState): boolean {
+  return TERMINAL_STATES.has(state)
+}
+
+export function runStatusToA2AState(status: RunStatus): A2ATaskState {
+  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 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 }
+}
+
+function buildArtifacts(run: Run): A2AArtifact[] | 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,
+        }),
+      },
+    },
+  ]
+}
+
+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
+}
+
+export function a2aMessageToCreateRun(
+  agentId: string,
+  params: A2AMessageSendParams,
+): CreateRunFromA2A {
+  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 }),
+  }
+
+  return {
+    agentId,
+    input,
+    threadId: params.contextId,
+    config,
+  }
+}

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

@@ -0,0 +1,123 @@
+import type {
+  MCPToolDefinition,
+  MCPToolResult,
+  MCPConnectorBridgeToolMapping,
+  MCPJsonSchema,
+  ConnectorInstance,
+  ConnectorDefinition,
+  ConnectorMethod,
+  ConnectorExecuteResult,
+} 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'
+
+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,
+    }
+  }
+}

package/src/bridge/sse/index.ts

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