@namzu/sdk 0.1.1 → 0.1.2

package/src/agents/defineAgent.ts

@@ -1,73 +1,63 @@
-import type { RunEventListener } from '../types/run/index.js'
+import { DEFAULT_CAPABILITIES } from '../constants/agent/index.js'
 import type {
-  AgentType,
-  AgentMetadata,
-  AgentCapabilities,
-  BaseAgentConfig,
-  BaseAgentResult,
-  AgentInput,
-  Agent,
+	Agent,
+	AgentCapabilities,
+	AgentInput,
+	AgentMetadata,
+	AgentType,
+	BaseAgentConfig,
+	BaseAgentResult,
 } from '../types/agent/index.js'
+import type { RunEventListener } from '../types/run/index.js'
 
 export interface DefineAgentOptions<
-  TConfig extends BaseAgentConfig = BaseAgentConfig,
-  TResult extends BaseAgentResult = BaseAgentResult,
+	TConfig extends BaseAgentConfig = BaseAgentConfig,
+	TResult extends BaseAgentResult = BaseAgentResult,
 > {
-  type: AgentType
-  id: string
-  name: string
-  version: string
-  category: string
-  description: string
-  capabilities?: Partial<AgentCapabilities>
-  run(input: AgentInput, config: TConfig, listener?: RunEventListener): Promise<TResult>
-  cancel?(): Promise<void>
-}
-
-const DEFAULT_CAPABILITIES: AgentCapabilities = {
-  supportsTools: false,
-  supportsStreaming: false,
-  supportsConcurrency: false,
-  supportsSubAgents: false,
+	type: AgentType
+	id: string
+	name: string
+	version: string
+	category: string
+	description: string
+	capabilities?: Partial<AgentCapabilities>
+	run(input: AgentInput, config: TConfig, listener?: RunEventListener): Promise<TResult>
+	cancel?(): Promise<void>
 }
 
 export function defineAgent<
-  TConfig extends BaseAgentConfig = BaseAgentConfig,
-  TResult extends BaseAgentResult = BaseAgentResult,
+	TConfig extends BaseAgentConfig = BaseAgentConfig,
+	TResult extends BaseAgentResult = BaseAgentResult,
 >(options: DefineAgentOptions<TConfig, TResult>): Agent<TConfig, TResult> {
-  const abortController = new AbortController()
-
-  const metadata: AgentMetadata = {
-    type: options.type,
-    id: options.id,
-    name: options.name,
-    version: options.version,
-    category: options.category,
-    description: options.description,
-    capabilities: { ...DEFAULT_CAPABILITIES, ...options.capabilities },
-  }
-
-  return {
-    type: options.type,
-    metadata,
-
-    async run(
-      input: AgentInput,
-      config: TConfig,
-      listener?: RunEventListener,
-    ): Promise<TResult> {
-      return options.run(input, config, listener)
-    },
-
-    async cancel(): Promise<void> {
-      abortController.abort()
-      if (options.cancel) {
-        await options.cancel()
-      }
-    },
-
-    getCapabilities(): AgentCapabilities {
-      return metadata.capabilities
-    },
-  }
+	const abortController = new AbortController()
+
+	const metadata: AgentMetadata = {
+		type: options.type,
+		id: options.id,
+		name: options.name,
+		version: options.version,
+		category: options.category,
+		description: options.description,
+		capabilities: { ...DEFAULT_CAPABILITIES, ...options.capabilities },
+	}
+
+	return {
+		type: options.type,
+		metadata,
+
+		async run(input: AgentInput, config: TConfig, listener?: RunEventListener): Promise<TResult> {
+			return options.run(input, config, listener)
+		},
+
+		async cancel(): Promise<void> {
+			abortController.abort()
+			if (options.cancel) {
+				await options.cancel()
+			}
+		},
+
+		getCapabilities(): AgentCapabilities {
+			return metadata.capabilities
+		},
+	}
 }

package/src/bridge/a2a/agent-card.ts

@@ -1,77 +1,72 @@
+import { A2A_PROTOCOL_VERSION } from '../../constants/a2a/index.js'
 import type { AgentInfo } from '../../contracts/index.js'
-import type {
-  A2AAgentCard,
-  A2AAgentSkill,
-  A2AServerConfig,
-} from '../../types/a2a/index.js'
+import type { A2AAgentCard, A2AAgentSkill, A2AServerConfig } from '../../types/a2a/index.js'
 import type { Skill } from '../../types/skills/index.js'
 
-const A2A_PROTOCOL_VERSION = '0.3.0'
-
 function toolToA2ASkill(toolName: string): A2AAgentSkill {
-  return {
-    id: `tool-${toolName}`,
-    name: toolName,
-    description: `Execute ${toolName} tool`,
-    tags: ['tool'],
-  }
+	return {
+		id: `tool-${toolName}`,
+		name: toolName,
+		description: `Execute ${toolName} tool`,
+		tags: ['tool'],
+	}
 }
 
 function skillToA2ASkill(skill: Skill): A2AAgentSkill {
-  return {
-    id: skill.metadata.name,
-    name: skill.metadata.name,
-    description: skill.metadata.description,
-    tags: ['procedure'],
-  }
+	return {
+		id: skill.metadata.name,
+		name: skill.metadata.name,
+		description: skill.metadata.description,
+		tags: ['procedure'],
+	}
 }
 
 export function buildAgentCard(
-  info: AgentInfo,
-  config: A2AServerConfig,
-  skills?: readonly Skill[],
+	info: AgentInfo,
+	config: A2AServerConfig,
+	skills?: readonly Skill[],
 ): A2AAgentCard {
-  const a2aSkills: A2AAgentSkill[] = []
+	const a2aSkills: A2AAgentSkill[] = []
 
-  for (const toolName of info.tools) {
-    a2aSkills.push(toolToA2ASkill(toolName))
-  }
+	for (const toolName of info.tools) {
+		a2aSkills.push(toolToA2ASkill(toolName))
+	}
 
-  if (skills) {
-    for (const skill of skills) {
-      a2aSkills.push(skillToA2ASkill(skill))
-    }
-  }
+	if (skills) {
+		for (const skill of skills) {
+			a2aSkills.push(skillToA2ASkill(skill))
+		}
+	}
 
-  return {
-    name: info.name,
-    description: info.description,
-    version: info.version,
-    protocolVersion: A2A_PROTOCOL_VERSION,
-    provider: {
-      organization: config.providerOrganization ?? 'Namzu',
-      url: config.providerUrl,
-    },
-    capabilities: {
-      streaming: info.capabilities?.supportsStreaming ?? false,
-      pushNotifications: false,
-      extendedAgentCard: false,
-    },
-    defaultInputModes: ['text'],
-    defaultOutputModes: ['text'],
-    skills: a2aSkills,
-    supportedInterfaces: [
-      {
-        url: `${config.baseUrl}/a2a/${info.id}`,
-        transport: config.transport,
-      },
-    ],
-    securitySchemes: {
-      bearer: {
-        type: 'http',
-        scheme: 'bearer',
-      },
-    },
-    securityRequirements: [{ bearer: [] }],
-  }
+	return {
+		name: info.name,
+		description: info.description,
+		version: info.version,
+		protocolVersion: A2A_PROTOCOL_VERSION,
+		provider: {
+			organization: config.providerOrganization ?? 'Namzu',
+			url: config.providerUrl,
+		},
+		capabilities: {
+			streaming: info.capabilities?.supportsStreaming ?? false,
+			pushNotifications: false,
+			extendedAgentCard: false,
+		},
+		defaultInputModes: ['text'],
+		defaultOutputModes: ['text'],
+		skills: a2aSkills,
+		supportedInterfaces: [
+			{
+				url: `${config.baseUrl}/a2a/${info.id}`,
+				transport: config.transport,
+			},
+		],
+		securitySchemes: {
+			bearer: {
+				type: 'http',
+				scheme: 'bearer',
+			},
+		},
+		securityRequirements: [{ bearer: [] }],
+	}
 }

package/src/bridge/a2a/index.ts

@@ -1,18 +1,18 @@
 export { buildAgentCard } from './agent-card.js'
 
 export {
-  runToA2ATask,
-  isTerminalState,
-  runStatusToA2AState,
-  a2aMessageToCreateRun,
-  type CreateRunFromA2A,
+	runToA2ATask,
+	isTerminalState,
+	runStatusToA2AState,
+	a2aMessageToCreateRun,
+	type CreateRunFromA2A,
 } from './task.js'
 
 export {
-  messageToA2A,
-  threadMessageToA2A,
-  extractTextFromA2AMessage,
-  a2aMessageToInput,
+	messageToA2A,
+	threadMessageToA2A,
+	extractTextFromA2AMessage,
+	a2aMessageToInput,
 } from './message.js'
 
 export { mapRunToA2AEvent, mapSessionToA2AEvent } from './mapper.js'

package/src/bridge/a2a/mapper.ts

@@ -2,16 +2,16 @@ import type {
 	A2AStreamEvent,
 	TaskArtifactUpdateEvent,
 	TaskStatusUpdateEvent,
-} from "../../types/a2a/index.js";
+} from '../../types/a2a/index.js'
 
-import type { RunEvent } from "../../types/run/events.js";
+import type { RunEvent } from '../../types/run/events.js'
 
 function statusEvent(
 	taskId: string,
-	state: TaskStatusUpdateEvent["status"]["state"],
+	state: TaskStatusUpdateEvent['status']['state'],
 	isFinal: boolean,
 	contextId?: string,
-	message?: TaskStatusUpdateEvent["status"]["message"],
+	message?: TaskStatusUpdateEvent['status']['message'],
 ): TaskStatusUpdateEvent {
 	return {
 		taskId,
@@ -22,77 +22,74 @@ function statusEvent(
 			timestamp: new Date().toISOString(),
 		},
 		final: isFinal,
-	};
+	}
 }
 
 function artifactEvent(
 	taskId: string,
 	contextId: string | undefined,
-	artifact: TaskArtifactUpdateEvent["artifact"],
+	artifact: TaskArtifactUpdateEvent['artifact'],
 ): TaskArtifactUpdateEvent {
 	return {
 		taskId,
 		contextId,
 		artifact,
-	};
+	}
 }
 
-type A2ATransform<K extends RunEvent["type"]> =
-	| ((
-			event: Extract<RunEvent, { type: K }>,
-			contextId?: string,
-	  ) => A2AStreamEvent | null)
-	| null;
+type A2ATransform<K extends RunEvent['type']> =
+	| ((event: Extract<RunEvent, { type: K }>, contextId?: string) => A2AStreamEvent | null)
+	| null
 
 const MAPPING: {
-	[K in RunEvent["type"]]: A2ATransform<K>;
+	[K in RunEvent['type']]: A2ATransform<K>
 } = {
-	run_started: (e, ctx) => statusEvent(e.runId, "running", false, ctx),
+	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;
+		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 }],
+		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` }],
+		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 }],
-		});
+		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 }],
+			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",
+		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: 'text', text: `Review requested for tools: ${toolNames}` },
 				{
-					kind: "data",
+					kind: 'data',
 					data: {
 						toolCalls: e.toolCalls.map((tc) => ({
 							id: tc.id,
@@ -100,19 +97,19 @@ const MAPPING: {
 							isDestructive: tc.isDestructive,
 						})),
 					},
-					mimeType: "application/x-namzu-review-request",
+					mimeType: 'application/x-namzu-review-request',
 				},
 			],
-		});
+		})
 	},
 
 	plan_ready: (e, ctx) =>
-		statusEvent(e.runId, "input-required", false, ctx, {
-			role: "agent",
+		statusEvent(e.runId, 'input-required', false, ctx, {
+			role: 'agent',
 			parts: [
-				{ kind: "text", text: `Plan ready: ${e.title}` },
+				{ kind: 'text', text: `Plan ready: ${e.title}` },
 				{
-					kind: "data",
+					kind: 'data',
 					data: {
 						planId: e.planId,
 						title: e.title,
@@ -123,15 +120,15 @@ const MAPPING: {
 							toolName: s.toolName,
 						})),
 					},
-					mimeType: "application/x-namzu-plan",
+					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}` }],
+		statusEvent(e.runId, 'input-required', false, ctx, {
+			role: 'agent',
+			parts: [{ kind: 'text', text: `Session paused: ${e.reason}` }],
 		}),
 
 	iteration_completed: null,
@@ -153,20 +150,15 @@ const MAPPING: {
 
 	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 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;
+export const mapSessionToA2AEvent = mapRunToA2AEvent

package/src/bridge/a2a/message.ts

@@ -1,97 +1,92 @@
 import type { ThreadMessage } from '../../contracts/index.js'
+import type { A2AMessage, A2AMessageRole, A2APart, TextPart } from '../../types/a2a/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}`)
-    }
-  }
+	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[] = []
+	const parts: A2APart[] = []
 
-  if (msg.content) {
-    parts.push({ kind: 'text', text: msg.content })
-  }
+	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 (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: '' })
-  }
+	if (parts.length === 0) {
+		parts.push({ kind: 'text', text: '' })
+	}
 
-  return {
-    role: toA2ARole(msg.role),
-    parts,
-  }
+	return {
+		role: toA2ARole(msg.role),
+		parts,
+	}
 }
 
 export function threadMessageToA2A(msg: ThreadMessage): A2AMessage {
-  const parts: A2APart[] = []
+	const parts: A2APart[] = []
 
-  if (msg.content) {
-    parts.push({ kind: 'text', text: msg.content })
-  }
+	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 (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: '' })
-  }
+	if (parts.length === 0) {
+		parts.push({ kind: 'text', text: '' })
+	}
 
-  return {
-    role: toA2ARole(msg.role),
-    parts,
-  }
+	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')
+	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)
+	return extractTextFromA2AMessage(msg)
 }