@namzu/sdk 0.1.1 → 0.1.2

package/src/types/connector/mcp.ts

@@ -1,205 +1,213 @@
-import type { MCPServerId, MCPClientId, ConnectorInstanceId } from '../ids/index.js'
-import type { ConnectorDefinition, ConnectorInstance, ConnectorExecuteParams, ConnectorExecuteResult } from './definition.js'
+import type { ConnectorInstanceId, MCPClientId, MCPServerId } from '../ids/index.js'
+import type {
+	ConnectorDefinition,
+	ConnectorExecuteParams,
+	ConnectorExecuteResult,
+	ConnectorInstance,
+} from './definition.js'
 
 export type MCPTransportType = 'stdio' | 'http-sse'
 
 export interface MCPTransportConfigBase {
-  type: MCPTransportType
+	type: MCPTransportType
 }
 
 export interface MCPStdioTransportConfig extends MCPTransportConfigBase {
-  type: 'stdio'
-  command: string
-  args?: string[]
-  env?: Record<string, string>
-  cwd?: string
+	type: 'stdio'
+	command: string
+	args?: string[]
+	env?: Record<string, string>
+	cwd?: string
 }
 
 export interface MCPHttpSseTransportConfig extends MCPTransportConfigBase {
-  type: 'http-sse'
-  url: string
-  headers?: Record<string, string>
-  timeoutMs?: number
+	type: 'http-sse'
+	url: string
+	headers?: Record<string, string>
+	timeoutMs?: number
 }
 
 export type MCPTransportUnion = MCPStdioTransportConfig | MCPHttpSseTransportConfig
 
 export interface MCPJsonRpcError {
-  code: number
-  message: string
-  data?: unknown
+	code: number
+	message: string
+	data?: unknown
 }
 
 export interface MCPJsonRpcMessage {
-  jsonrpc: '2.0'
-  id?: string | number
-  method?: string
-  params?: Record<string, unknown>
-  result?: unknown
-  error?: MCPJsonRpcError
+	jsonrpc: '2.0'
+	id?: string | number
+	method?: string
+	params?: Record<string, unknown>
+	result?: unknown
+	error?: MCPJsonRpcError
 }
 
 export interface MCPTransport {
-  connect(): Promise<void>
-  close(): Promise<void>
-  send(message: MCPJsonRpcMessage): Promise<void>
-  onMessage(handler: (message: MCPJsonRpcMessage) => void): void
-  onClose(handler: () => void): void
-  onError(handler: (error: Error) => void): void
-  isConnected(): boolean
+	connect(): Promise<void>
+	close(): Promise<void>
+	send(message: MCPJsonRpcMessage): Promise<void>
+	onMessage(handler: (message: MCPJsonRpcMessage) => void): void
+	onClose(handler: () => void): void
+	onError(handler: (error: Error) => void): void
+	isConnected(): boolean
 }
 
 export interface MCPJsonSchema {
-  type: 'object'
-  properties?: Record<string, unknown>
-  required?: string[]
-  [key: string]: unknown
+	type: 'object'
+	properties?: Record<string, unknown>
+	required?: string[]
+	[key: string]: unknown
 }
 
 export interface MCPToolAnnotations {
-  title?: string
-  readOnlyHint?: boolean
-  destructiveHint?: boolean
-  idempotentHint?: boolean
-  openWorldHint?: boolean
+	title?: string
+	readOnlyHint?: boolean
+	destructiveHint?: boolean
+	idempotentHint?: boolean
+	openWorldHint?: boolean
 }
 
 export interface MCPToolDefinition {
-  name: string
-  description?: string
-  inputSchema: MCPJsonSchema
-  annotations?: MCPToolAnnotations
+	name: string
+	description?: string
+	inputSchema: MCPJsonSchema
+	annotations?: MCPToolAnnotations
 }
 
 export type MCPContentBlock =
-  | { type: 'text'; text: string }
-  | { type: 'image'; data: string; mimeType: string }
-  | { type: 'resource'; resource: { uri: string; mimeType?: string; text?: string } }
+	| { type: 'text'; text: string }
+	| { type: 'image'; data: string; mimeType: string }
+	| { type: 'resource'; resource: { uri: string; mimeType?: string; text?: string } }
 
 export interface MCPToolResult {
-  content: MCPContentBlock[]
-  isError?: boolean
+	content: MCPContentBlock[]
+	isError?: boolean
 }
 
 export interface MCPResource {
-  uri: string
-  name: string
-  description?: string
-  mimeType?: string
+	uri: string
+	name: string
+	description?: string
+	mimeType?: string
 }
 
 export interface MCPResourceTemplate {
-  uriTemplate: string
-  name: string
-  description?: string
-  mimeType?: string
+	uriTemplate: string
+	name: string
+	description?: string
+	mimeType?: string
 }
 
 export interface MCPPromptArgument {
-  name: string
-  description?: string
-  required?: boolean
+	name: string
+	description?: string
+	required?: boolean
 }
 
 export interface MCPPromptDefinition {
-  name: string
-  description?: string
-  arguments?: MCPPromptArgument[]
+	name: string
+	description?: string
+	arguments?: MCPPromptArgument[]
 }
 
 export interface MCPClientCapabilities {
-  roots?: { listChanged?: boolean }
-  sampling?: Record<string, never>
-  experimental?: Record<string, unknown>
+	roots?: { listChanged?: boolean }
+	sampling?: Record<string, never>
+	experimental?: Record<string, unknown>
 }
 
 export interface MCPServerCapabilities {
-  tools?: { listChanged?: boolean }
-  resources?: { subscribe?: boolean; listChanged?: boolean }
-  prompts?: { listChanged?: boolean }
-  logging?: Record<string, never>
-  experimental?: Record<string, unknown>
+	tools?: { listChanged?: boolean }
+	resources?: { subscribe?: boolean; listChanged?: boolean }
+	prompts?: { listChanged?: boolean }
+	logging?: Record<string, never>
+	experimental?: Record<string, unknown>
 }
 
 export interface MCPInitializeParams {
-  protocolVersion: string
-  capabilities: MCPClientCapabilities
-  clientInfo: { name: string; version: string }
+	protocolVersion: string
+	capabilities: MCPClientCapabilities
+	clientInfo: { name: string; version: string }
 }
 
 export interface MCPInitializeResult {
-  protocolVersion: string
-  capabilities: MCPServerCapabilities
-  serverInfo: { name: string; version?: string }
+	protocolVersion: string
+	capabilities: MCPServerCapabilities
+	serverInfo: { name: string; version?: string }
 }
 
 export type MCPConnectionStatus = 'disconnected' | 'connecting' | 'connected' | 'error'
 
 export interface MCPClientConfig {
-  id?: MCPClientId
-  serverName: string
-  transport: MCPTransportUnion
-  capabilities?: MCPClientCapabilities
-  clientInfo?: { name: string; version: string }
+	id?: MCPClientId
+	serverName: string
+	transport: MCPTransportUnion
+	capabilities?: MCPClientCapabilities
+	clientInfo?: { name: string; version: string }
 }
 
 export interface MCPClientState {
-  id: MCPClientId
-  serverName: string
-  status: MCPConnectionStatus
-  serverInfo?: { name: string; version?: string }
-  serverCapabilities?: MCPServerCapabilities
-  connectedAt?: number
-  error?: string
+	id: MCPClientId
+	serverName: string
+	status: MCPConnectionStatus
+	serverInfo?: { name: string; version?: string }
+	serverCapabilities?: MCPServerCapabilities
+	connectedAt?: number
+	error?: string
 }
 
 export interface MCPServerConfig {
-  id?: MCPServerId
-  name: string
-  version?: string
-  capabilities?: Partial<MCPServerCapabilities>
+	id?: MCPServerId
+	name: string
+	version?: string
+	capabilities?: Partial<MCPServerCapabilities>
 }
 
 export interface MCPServerState {
-  id: MCPServerId
-  name: string
-  running: boolean
-  connectedClients: number
-  startedAt?: number
+	id: MCPServerId
+	name: string
+	running: boolean
+	connectedClients: number
+	startedAt?: number
 }
 
 export interface MCPConnectorBridgeConfig {
-  manager: ConnectorManager
-  prefix?: string
+	manager: ConnectorManager
+	prefix?: string
 }
 
 export interface MCPConnectorBridgeToolMapping {
-  mcpToolName: string
-  connectorId: string
-  instanceId: ConnectorInstanceId
-  methodName: string
+	mcpToolName: string
+	connectorId: string
+	instanceId: ConnectorInstanceId
+	methodName: string
 }
 
 export interface MCPDiscoveredTool {
-  tool: MCPToolDefinition
-  clientId: MCPClientId
-  serverName: string
+	tool: MCPToolDefinition
+	clientId: MCPClientId
+	serverName: string
 }
 
 export type MCPLifecycleEvent =
-  | { type: 'mcp_client_connected'; clientId: MCPClientId; serverName: string }
-  | { type: 'mcp_client_disconnected'; clientId: MCPClientId }
-  | { type: 'mcp_client_error'; clientId: MCPClientId; error: string }
-  | { type: 'mcp_server_started'; serverId: MCPServerId }
-  | { type: 'mcp_server_stopped'; serverId: MCPServerId }
-  | { type: 'mcp_tool_called'; tool: string; clientId?: MCPClientId; serverId?: MCPServerId }
-  | { type: 'mcp_tools_changed'; clientId: MCPClientId }
+	| { type: 'mcp_client_connected'; clientId: MCPClientId; serverName: string }
+	| { type: 'mcp_client_disconnected'; clientId: MCPClientId }
+	| { type: 'mcp_client_error'; clientId: MCPClientId; error: string }
+	| { type: 'mcp_server_started'; serverId: MCPServerId }
+	| { type: 'mcp_server_stopped'; serverId: MCPServerId }
+	| { type: 'mcp_tool_called'; tool: string; clientId?: MCPClientId; serverId?: MCPServerId }
+	| { type: 'mcp_tools_changed'; clientId: MCPClientId }
 
 export type MCPEventListener = (event: MCPLifecycleEvent) => void
 
 type ConnectorManager = {
-  getInstance(instanceId: ConnectorInstanceId): ConnectorInstance | undefined
-  getRegistry(): { get(connectorId: string): ConnectorDefinition | undefined; getOrThrow(connectorId: string): ConnectorDefinition }
-  listConnectedInstances(): ConnectorInstance[]
-  execute(params: ConnectorExecuteParams): Promise<ConnectorExecuteResult>
+	getInstance(instanceId: ConnectorInstanceId): ConnectorInstance | undefined
+	getRegistry(): {
+		get(connectorId: string): ConnectorDefinition | undefined
+		getOrThrow(connectorId: string): ConnectorDefinition
+	}
+	listConnectedInstances(): ConnectorInstance[]
+	execute(params: ConnectorExecuteParams): Promise<ConnectorExecuteResult>
 }

package/src/types/connector/scope.ts

@@ -4,39 +4,39 @@ import type { ConnectorConfig } from './definition.js'
 export type ConnectorScope = 'org' | 'environment' | 'team' | 'project' | 'agent'
 
 export const CONNECTOR_SCOPE_ORDER: readonly ConnectorScope[] = [
-  'org',
-  'environment',
-  'team',
-  'project',
-  'agent',
+	'org',
+	'environment',
+	'team',
+	'project',
+	'agent',
 ] as const
 
 export interface ScopeRef {
-  scope: ConnectorScope
-  scopeId: string
+	scope: ConnectorScope
+	scopeId: string
 }
 
 export interface ScopedConnectorConfig {
-  scope: ScopeRef
-  connectorId: string
+	scope: ScopeRef
+	connectorId: string
 
-  config?: Partial<ConnectorConfig>
+	config?: Partial<ConnectorConfig>
 
-  auth?: AuthConfig
+	auth?: AuthConfig
 
-  enabled?: boolean
+	enabled?: boolean
 
-  options?: Record<string, unknown>
+	options?: Record<string, unknown>
 }
 
 export interface ResolvedConnectorConfig {
-  connectorId: string
-  config: ConnectorConfig
-  auth?: AuthConfig
-  enabled: boolean
-  options: Record<string, unknown>
+	connectorId: string
+	config: ConnectorConfig
+	auth?: AuthConfig
+	enabled: boolean
+	options: Record<string, unknown>
 
-  resolvedFrom: ScopeRef[]
+	resolvedFrom: ScopeRef[]
 }
 
 export type ScopeChain = Partial<Record<ConnectorScope, string>>

package/src/types/connector/tenant.ts

@@ -1,41 +1,46 @@
-import type { TenantId, CredentialId, EnvironmentId } from '../ids/index.js'
-import type { AuthType, AuthConfig } from './core.js'
+import type { CredentialId, EnvironmentId, TenantId } from '../ids/index.js'
+import type { AuthConfig, AuthType } from './core.js'
 
 export type EnvironmentTier = 'production' | 'staging' | 'development' | 'testing'
 
 export interface EnvironmentDescriptor {
-  id: EnvironmentId
-  name: string
-  tier: EnvironmentTier
-  orgId?: string
-  metadata?: Record<string, unknown>
+	id: EnvironmentId
+	name: string
+	tier: EnvironmentTier
+	orgId?: string
+	metadata?: Record<string, unknown>
 }
 
 export interface TenantDescriptor {
-  id: TenantId
-  name: string
-  metadata?: Record<string, unknown>
+	id: TenantId
+	name: string
+	metadata?: Record<string, unknown>
 }
 
 export interface TenantRateLimitConfig {
-  maxRequests: number
+	maxRequests: number
 
-  windowMs: number
+	windowMs: number
 }
 
 export interface CredentialRef {
-  id: CredentialId
-  connectorId: string
-  tenantId: TenantId
-  label: string
-  authType: AuthType
-  createdAt: number
-  expiresAt?: number
+	id: CredentialId
+	connectorId: string
+	tenantId: TenantId
+	label: string
+	authType: AuthType
+	createdAt: number
+	expiresAt?: number
 }
 
 export interface CredentialVault {
-  store(tenantId: TenantId, connectorId: string, label: string, auth: AuthConfig): Promise<CredentialRef>
-  retrieve(credentialId: CredentialId): Promise<AuthConfig | undefined>
-  revoke(credentialId: CredentialId): Promise<boolean>
-  list(tenantId: TenantId, connectorId?: string): Promise<CredentialRef[]>
+	store(
+		tenantId: TenantId,
+		connectorId: string,
+		label: string,
+		auth: AuthConfig,
+	): Promise<CredentialRef>
+	retrieve(credentialId: CredentialId): Promise<AuthConfig | undefined>
+	revoke(credentialId: CredentialId): Promise<boolean>
+	list(tenantId: TenantId, connectorId?: string): Promise<CredentialRef[]>
 }

package/src/types/connector/webhook.ts

@@ -1,18 +1,18 @@
 export interface WebhookConnectorConfig {
-  url: string
-  secret?: string
-  defaultHeaders?: Record<string, string>
-  timeoutMs?: number
+	url: string
+	secret?: string
+	defaultHeaders?: Record<string, string>
+	timeoutMs?: number
 }
 
 export interface WebhookSendInput {
-  payload: unknown
-  headers?: Record<string, string>
-  url?: string
+	payload: unknown
+	headers?: Record<string, string>
+	url?: string
 }
 
 export interface WebhookSendOutput {
-  status: number
-  body: unknown
-  deliveredAt: number
+	status: number
+	body: unknown
+	deliveredAt: number
 }

package/src/types/conversation/index.ts

@@ -1,8 +1,8 @@
+import type { RunId, ThreadId } from '../ids/index.js'
 import type { Message } from '../message/index.js'
-import type { ThreadId, RunId } from '../ids/index.js'
 
 export interface ConversationStore {
-  loadMessages(threadId: ThreadId): Message[]
+	loadMessages(threadId: ThreadId): Message[]
 
-  persistRunResult(threadId: ThreadId, runId: RunId, messages: Message[]): void
+	persistRunResult(threadId: ThreadId, runId: RunId, messages: Message[]): void
 }

package/src/types/decision/index.ts

@@ -1,30 +1,32 @@
 import { z } from 'zod'
 
-export const RoutingResponseSchema = z.object({
-  agentId: z.string().min(1, 'agentId is required'),
-  confidence: z.number().min(0).max(1),
-  reasoning: z.string().optional(),
-}).strict()
+export const RoutingResponseSchema = z
+	.object({
+		agentId: z.string().min(1, 'agentId is required'),
+		confidence: z.number().min(0).max(1),
+		reasoning: z.string().optional(),
+	})
+	.strict()
 
 export type RoutingResponse = z.infer<typeof RoutingResponseSchema>
 
 export interface DecisionParserConfig {
-  validAgentIds: string[]
+	validAgentIds: string[]
 
-  minConfidence: number
+	minConfidence: number
 
-  maxRetries: number
+	maxRetries: number
 
-  fallbackAgentId: string
+	fallbackAgentId: string
 }
 
 export type DecisionParseResult =
-  | { ok: true; decision: RoutingResponse; source: 'parsed' }
-  | { ok: true; decision: RoutingResponse; source: 'pattern_match' }
-  | { ok: true; decision: RoutingResponse; source: 'fallback'; reason: string }
-  | { ok: false; error: string; rawContent: string }
+	| { ok: true; decision: RoutingResponse; source: 'parsed' }
+	| { ok: true; decision: RoutingResponse; source: 'pattern_match' }
+	| { ok: true; decision: RoutingResponse; source: 'fallback'; reason: string }
+	| { ok: false; error: string; rawContent: string }
 
 export type FallbackStrategy =
-  | { type: 'fixed'; agentId: string }
-  | { type: 'pattern_match'; patterns: Map<string, string[]> }
-  | { type: 'first_route' }
+	| { type: 'fixed'; agentId: string }
+	| { type: 'pattern_match'; patterns: Map<string, string[]> }
+	| { type: 'first_route' }

package/src/types/execution/index.ts

@@ -3,46 +3,46 @@ export type ExecutionEnvironment = 'local' | 'remote' | 'hybrid'
 export type ExecutionCapability = 'filesystem' | 'process' | 'network' | 'shell'
 
 export interface CommandOptions {
-  cwd?: string
-  env?: Record<string, string>
-  timeoutMs?: number
-  shell?: string | boolean
+	cwd?: string
+	env?: Record<string, string>
+	timeoutMs?: number
+	shell?: string | boolean
 }
 
 export interface CommandResult {
-  exitCode: number
-  stdout: string
-  stderr: string
-  durationMs: number
+	exitCode: number
+	stdout: string
+	stderr: string
+	durationMs: number
 }
 
 export interface CommandExecutor {
-  executeCommand(command: string, args?: string[], options?: CommandOptions): Promise<CommandResult>
+	executeCommand(command: string, args?: string[], options?: CommandOptions): Promise<CommandResult>
 }
 
 export interface RemoteCommandHandler {
-  executeRemote(command: string, options?: CommandOptions): Promise<CommandResult>
+	executeRemote(command: string, options?: CommandOptions): Promise<CommandResult>
 }
 
 export type ExecutionRoutingStrategy = 'local-first' | 'remote-first' | 'round-robin'
 
 export interface ExecutionContextBase {
-  id: string
-  environment: ExecutionEnvironment
-  capabilities?: ExecutionCapability[]
-  metadata?: Record<string, unknown>
+	id: string
+	environment: ExecutionEnvironment
+	capabilities?: ExecutionCapability[]
+	metadata?: Record<string, unknown>
 }
 
 export interface ExecutionContextLifecycle {
-  initialize(): Promise<void>
-  isReady(): boolean
-  teardown(): Promise<void>
+	initialize(): Promise<void>
+	isReady(): boolean
+	teardown(): Promise<void>
 }
 
 export type ExecutionContextEvent =
-  | { type: 'context_initialized'; contextId: string; environment: ExecutionEnvironment }
-  | { type: 'context_ready'; contextId: string }
-  | { type: 'context_error'; contextId: string; error: string }
-  | { type: 'context_teardown'; contextId: string }
+	| { type: 'context_initialized'; contextId: string; environment: ExecutionEnvironment }
+	| { type: 'context_ready'; contextId: string }
+	| { type: 'context_error'; contextId: string; error: string }
+	| { type: 'context_teardown'; contextId: string }
 
 export type ExecutionContextEventListener = (event: ExecutionContextEvent) => void