@namzu/sdk 0.1.1 → 0.1.2

package/src/bridge/tools/connector/definitions.ts

@@ -1,143 +1,123 @@
 import { z } from 'zod'
+import type { ConnectorManager } from '../../../manager/connector/lifecycle.js'
 import { defineTool } from '../../../tools/defineTool.js'
 import type { ToolDefinition } from '../../../types/tool/index.js'
-import type { ConnectorInstanceId } from '../../../types/ids/index.js'
-import type { ConnectorManager } from '../../../manager/connector/lifecycle.js'
 import { parseConnectorInstanceId } from '../../../utils/id.js'
 
 export interface ConnectorToolConfig {
-  manager: ConnectorManager
+	manager: ConnectorManager
 }
 
 const connectorExecuteInputSchema = z.object({
-  instance_id: z
-    .string()
-    .describe('The connector instance ID to execute against'),
-  method: z
-    .string()
-    .describe('The connector method to invoke (e.g. "request", "send")'),
-  input: z
-    .record(z.unknown())
-    .describe('Input parameters for the connector method'),
+	instance_id: z.string().describe('The connector instance ID to execute against'),
+	method: z.string().describe('The connector method to invoke (e.g. "request", "send")'),
+	input: z.record(z.unknown()).describe('Input parameters for the connector method'),
 })
 
 const connectorListInputSchema = z.object({})
 
-export function createConnectorExecuteTool(
-  config: ConnectorToolConfig,
-): ToolDefinition {
-  return defineTool({
-    name: 'connector_execute',
-    description:
-      'Execute a method on a connected external service. Use this to make HTTP requests, send webhooks, or interact with any configured connector.',
-    inputSchema: connectorExecuteInputSchema,
-    category: 'network',
-    permissions: ['network_access'],
-    readOnly: false,
-    destructive: false,
-    concurrencySafe: true,
-
-    async execute(input) {
-      const instanceId = parseConnectorInstanceId(String(input.instance_id))
-      const instance = config.manager.getInstance(instanceId)
-
-      if (!instance) {
-        return {
-          success: false,
-          output: '',
-          error: `Connector instance not found: "${instanceId}"`,
-        }
-      }
-
-      if (instance.status !== 'connected') {
-        return {
-          success: false,
-          output: '',
-          error: `Connector "${instanceId}" is not connected (status: ${instance.status})`,
-        }
-      }
-
-      const result = await config.manager.execute({
-        instanceId,
-        method: input.method,
-        input: input.input,
-      })
-
-      if (!result.success) {
-        return {
-          success: false,
-          output: '',
-          error: result.error ?? 'Connector execution failed',
-        }
-      }
-
-      const outputStr =
-        typeof result.output === 'string'
-          ? result.output
-          : JSON.stringify(result.output, null, 2)
-
-      return {
-        success: true,
-        output: outputStr,
-        data: {
-          durationMs: result.durationMs,
-          metadata: result.metadata,
-        },
-      }
-    },
-  })
+export function createConnectorExecuteTool(config: ConnectorToolConfig): ToolDefinition {
+	return defineTool({
+		name: 'connector_execute',
+		description:
+			'Execute a method on a connected external service. Use this to make HTTP requests, send webhooks, or interact with any configured connector.',
+		inputSchema: connectorExecuteInputSchema,
+		category: 'network',
+		permissions: ['network_access'],
+		readOnly: false,
+		destructive: false,
+		concurrencySafe: true,
+
+		async execute(input) {
+			const instanceId = parseConnectorInstanceId(String(input.instance_id))
+			const instance = config.manager.getInstance(instanceId)
+
+			if (!instance) {
+				return {
+					success: false,
+					output: '',
+					error: `Connector instance not found: "${instanceId}"`,
+				}
+			}
+
+			if (instance.status !== 'connected') {
+				return {
+					success: false,
+					output: '',
+					error: `Connector "${instanceId}" is not connected (status: ${instance.status})`,
+				}
+			}
+
+			const result = await config.manager.execute({
+				instanceId,
+				method: input.method,
+				input: input.input,
+			})
+
+			if (!result.success) {
+				return {
+					success: false,
+					output: '',
+					error: result.error ?? 'Connector execution failed',
+				}
+			}
+
+			const outputStr =
+				typeof result.output === 'string' ? result.output : JSON.stringify(result.output, null, 2)
+
+			return {
+				success: true,
+				output: outputStr,
+				data: {
+					durationMs: result.durationMs,
+					metadata: result.metadata,
+				},
+			}
+		},
+	})
 }
 
-export function createConnectorListTool(
-  config: ConnectorToolConfig,
-): ToolDefinition {
-  return defineTool({
-    name: 'connector_list',
-    description:
-      'List all available connector instances and their connection status.',
-    inputSchema: connectorListInputSchema,
-    category: 'network',
-    permissions: [],
-    readOnly: true,
-    destructive: false,
-    concurrencySafe: true,
-
-    async execute() {
-      const instances = config.manager.listInstances()
-
-      if (instances.length === 0) {
-        return {
-          success: true,
-          output: 'No connector instances configured.',
-        }
-      }
-
-      const lines = instances.map(
-        (i) =>
-          `- ${i.id} (${i.connectorId}): ${i.config.name} [${i.status}]`,
-      )
-
-      return {
-        success: true,
-        output: lines.join('\n'),
-        data: {
-          instances: instances.map((i) => ({
-            id: i.id,
-            connectorId: i.connectorId,
-            name: i.config.name,
-            status: i.status,
-          })),
-        },
-      }
-    },
-  })
+export function createConnectorListTool(config: ConnectorToolConfig): ToolDefinition {
+	return defineTool({
+		name: 'connector_list',
+		description: 'List all available connector instances and their connection status.',
+		inputSchema: connectorListInputSchema,
+		category: 'network',
+		permissions: [],
+		readOnly: true,
+		destructive: false,
+		concurrencySafe: true,
+
+		async execute() {
+			const instances = config.manager.listInstances()
+
+			if (instances.length === 0) {
+				return {
+					success: true,
+					output: 'No connector instances configured.',
+				}
+			}
+
+			const lines = instances.map(
+				(i) => `- ${i.id} (${i.connectorId}): ${i.config.name} [${i.status}]`,
+			)
+
+			return {
+				success: true,
+				output: lines.join('\n'),
+				data: {
+					instances: instances.map((i) => ({
+						id: i.id,
+						connectorId: i.connectorId,
+						name: i.config.name,
+						status: i.status,
+					})),
+				},
+			}
+		},
+	})
 }
 
-export function createConnectorTools(
-  config: ConnectorToolConfig,
-): ToolDefinition[] {
-  return [
-    createConnectorExecuteTool(config),
-    createConnectorListTool(config),
-  ]
+export function createConnectorTools(config: ConnectorToolConfig): ToolDefinition[] {
+	return [createConnectorExecuteTool(config), createConnectorListTool(config)]
 }

package/src/bridge/tools/connector/index.ts

@@ -1,15 +1,15 @@
 export {
-  createConnectorExecuteTool,
-  createConnectorListTool,
-  createConnectorTools,
+	createConnectorExecuteTool,
+	createConnectorListTool,
+	createConnectorTools,
 } from './definitions.js'
 export type { ConnectorToolConfig } from './definitions.js'
 
 export {
-  connectorMethodToTool,
-  connectorInstanceToTools,
-  allConnectorTools,
-  createConnectorRouterTool,
+	connectorMethodToTool,
+	connectorInstanceToTools,
+	allConnectorTools,
+	createConnectorRouterTool,
 } from './adapter.js'
 export type { ConnectorRouterInput } from './adapter.js'
 

package/src/bridge/tools/connector/router.ts

@@ -1,71 +1,68 @@
-import type { ToolDefinition } from '../../../types/tool/index.js'
 import type { ConnectorManager } from '../../../manager/connector/lifecycle.js'
 import type { ToolRegistry } from '../../../registry/tool/execute.js'
-import {
-  connectorInstanceToTools,
-  createConnectorRouterTool,
-} from './adapter.js'
-import { getRootLogger, type Logger } from '../../../utils/logger.js'
+import type { ToolDefinition } from '../../../types/tool/index.js'
 import { toErrorMessage } from '../../../utils/error.js'
+import { type Logger, getRootLogger } from '../../../utils/logger.js'
+import { connectorInstanceToTools, createConnectorRouterTool } from './adapter.js'
 
 export type ConnectorToolStrategy = 'per-method' | 'router'
 
 export interface ConnectorToolRouterConfig {
-  manager: ConnectorManager
-  strategy?: ConnectorToolStrategy
+	manager: ConnectorManager
+	strategy?: ConnectorToolStrategy
 }
 
 export class ConnectorToolRouter {
-  private manager: ConnectorManager
-  private strategy: ConnectorToolStrategy
-  private log: Logger
+	private manager: ConnectorManager
+	private strategy: ConnectorToolStrategy
+	private log: Logger
 
-  constructor(config: ConnectorToolRouterConfig) {
-    this.manager = config.manager
-    this.strategy = config.strategy ?? 'per-method'
-    this.log = getRootLogger().child({ component: 'ConnectorToolRouter' })
-  }
+	constructor(config: ConnectorToolRouterConfig) {
+		this.manager = config.manager
+		this.strategy = config.strategy ?? 'per-method'
+		this.log = getRootLogger().child({ component: 'ConnectorToolRouter' })
+	}
 
-  getTools(): ToolDefinition[] {
-    if (this.strategy === 'router') {
-      const connected = this.manager.listConnectedInstances()
-      if (connected.length === 0) return []
-      return [createConnectorRouterTool(this.manager)]
-    }
+	getTools(): ToolDefinition[] {
+		if (this.strategy === 'router') {
+			const connected = this.manager.listConnectedInstances()
+			if (connected.length === 0) return []
+			return [createConnectorRouterTool(this.manager)]
+		}
 
-    const tools: ToolDefinition[] = []
-    for (const instance of this.manager.listConnectedInstances()) {
-      try {
-        tools.push(...connectorInstanceToTools(instance.id, this.manager))
-      } catch (err) {
-        this.log.error(`Failed to create tools for instance ${instance.id}`, {
-          error: toErrorMessage(err),
-        })
-      }
-    }
-    return tools
-  }
+		const tools: ToolDefinition[] = []
+		for (const instance of this.manager.listConnectedInstances()) {
+			try {
+				tools.push(...connectorInstanceToTools(instance.id, this.manager))
+			} catch (err) {
+				this.log.error(`Failed to create tools for instance ${instance.id}`, {
+					error: toErrorMessage(err),
+				})
+			}
+		}
+		return tools
+	}
 
-  registerTools(toolRegistry: ToolRegistry): string[] {
-    const tools = this.getTools()
-    const names: string[] = []
-    for (const tool of tools) {
-      toolRegistry.register(tool)
-      names.push(tool.name)
-    }
-    this.log.info(`Registered ${names.length} connector tools`, { tools: names })
-    return names
-  }
+	registerTools(toolRegistry: ToolRegistry): string[] {
+		const tools = this.getTools()
+		const names: string[] = []
+		for (const tool of tools) {
+			toolRegistry.register(tool)
+			names.push(tool.name)
+		}
+		this.log.info(`Registered ${names.length} connector tools`, { tools: names })
+		return names
+	}
 
-  unregisterTools(toolRegistry: ToolRegistry, toolNames: string[]): void {
-    for (const name of toolNames) {
-      toolRegistry.unregister(name)
-    }
-    this.log.info(`Unregistered ${toolNames.length} connector tools`)
-  }
+	unregisterTools(toolRegistry: ToolRegistry, toolNames: string[]): void {
+		for (const name of toolNames) {
+			toolRegistry.unregister(name)
+		}
+		this.log.info(`Unregistered ${toolNames.length} connector tools`)
+	}
 
-  refreshTools(toolRegistry: ToolRegistry, previousNames: string[]): string[] {
-    this.unregisterTools(toolRegistry, previousNames)
-    return this.registerTools(toolRegistry)
-  }
+	refreshTools(toolRegistry: ToolRegistry, previousNames: string[]): string[] {
+		this.unregisterTools(toolRegistry, previousNames)
+		return this.registerTools(toolRegistry)
+	}
 }

package/src/config/runtime.ts

@@ -1,12 +1,12 @@
 import { z } from 'zod'
 
 export const RuntimeConfigSchema = z.object({
-  model: z.string().default('qwen/qwen3.6-plus:free'),
-  temperature: z.number().min(0).max(2).default(0.3),
-  tokenBudget: z.number().positive().default(100_000),
-  maxResponseTokens: z.number().positive().default(8192),
-  timeoutMs: z.number().positive().default(600_000),
-  maxIterations: z.number().positive().default(200),
+	model: z.string().default('qwen/qwen3.6-plus:free'),
+	temperature: z.number().min(0).max(2).default(0.3),
+	tokenBudget: z.number().positive().default(100_000),
+	maxResponseTokens: z.number().positive().default(8192),
+	timeoutMs: z.number().positive().default(600_000),
+	maxIterations: z.number().positive().default(200),
 })
 
 export type RuntimeConfig = z.infer<typeof RuntimeConfigSchema>

package/src/connector/BaseConnector.ts

@@ -1,81 +1,77 @@
+import type { z } from 'zod'
 import type {
-  ConnectorDefinition,
-  ConnectorLifecycle,
-  ConnectorExecuteResult,
-  ConnectorMethod,
-  ConnectionType,
-  AuthConfig,
+	AuthConfig,
+	ConnectionType,
+	ConnectorDefinition,
+	ConnectorExecuteResult,
+	ConnectorLifecycle,
+	ConnectorMethod,
 } from '../types/connector/index.js'
-import type { z } from 'zod'
-import { getRootLogger, type Logger } from '../utils/logger.js'
+import { type Logger, getRootLogger } from '../utils/logger.js'
 
-export abstract class BaseConnector<TConfig = unknown>
-  implements ConnectorLifecycle<TConfig>
-{
-  abstract readonly id: string
-  abstract readonly name: string
-  abstract readonly description: string
-  abstract readonly connectionType: ConnectionType
-  abstract readonly configSchema: z.ZodType<TConfig, z.ZodTypeDef, unknown>
-  abstract readonly methods: ConnectorMethod[]
+export abstract class BaseConnector<TConfig = unknown> implements ConnectorLifecycle<TConfig> {
+	abstract readonly id: string
+	abstract readonly name: string
+	abstract readonly description: string
+	abstract readonly connectionType: ConnectionType
+	abstract readonly configSchema: z.ZodType<TConfig, z.ZodTypeDef, unknown>
+	abstract readonly methods: ConnectorMethod[]
 
-  protected log: Logger
-  protected config: TConfig | null = null
-  protected auth: AuthConfig | undefined
+	protected log: Logger
+	protected config: TConfig | null = null
+	protected auth: AuthConfig | undefined
 
-  constructor() {
-    this.log = getRootLogger().child({ component: this.constructor.name })
-  }
+	constructor() {
+		this.log = getRootLogger().child({ component: this.constructor.name })
+	}
 
-  abstract connect(config: TConfig, auth?: AuthConfig): Promise<void>
-  abstract disconnect(): Promise<void>
-  abstract healthCheck(): Promise<boolean>
-  abstract execute(method: string, input: unknown): Promise<ConnectorExecuteResult>
+	abstract connect(config: TConfig, auth?: AuthConfig): Promise<void>
+	abstract disconnect(): Promise<void>
+	abstract healthCheck(): Promise<boolean>
+	abstract execute(method: string, input: unknown): Promise<ConnectorExecuteResult>
 
-  toDefinition(): ConnectorDefinition<TConfig> {
-    return {
-      id: this.id,
-      name: this.name,
-      description: this.description,
-      connectionType: this.connectionType,
-      configSchema: this.configSchema,
-      methods: this.methods,
-    }
-  }
+	toDefinition(): ConnectorDefinition<TConfig> {
+		return {
+			id: this.id,
+			name: this.name,
+			description: this.description,
+			connectionType: this.connectionType,
+			configSchema: this.configSchema,
+			methods: this.methods,
+		}
+	}
 
-  protected findMethod(methodName: string): ConnectorMethod | undefined {
-    return this.methods.find((m) => m.name === methodName)
-  }
+	protected findMethod(methodName: string): ConnectorMethod | undefined {
+		return this.methods.find((m) => m.name === methodName)
+	}
 
-  protected requireMethod(methodName: string): ConnectorMethod {
-    const method = this.findMethod(methodName)
-    if (!method) {
-      throw new Error(
-        `Method "${methodName}" not found on connector "${this.id}". ` +
-          `Available: ${this.methods.map((m) => m.name).join(', ')}`,
-      )
-    }
-    return method
-  }
+	protected requireMethod(methodName: string): ConnectorMethod {
+		const method = this.findMethod(methodName)
+		if (!method) {
+			throw new Error(
+				`Method "${methodName}" not found on connector "${this.id}". ` +
+					`Available: ${this.methods.map((m) => m.name).join(', ')}`,
+			)
+		}
+		return method
+	}
 
-  protected validateInput(method: ConnectorMethod, input: unknown): unknown {
-    const result = method.inputSchema.safeParse(input)
-    if (!result.success) {
-      const errors = result.error.issues
-        .map((i) => `${i.path.join('.')}: ${i.message}`)
-        .join('; ')
-      throw new Error(`Invalid input for method "${method.name}": ${errors}`)
-    }
-    return result.data
-  }
+	protected validateInput(method: ConnectorMethod, input: unknown): unknown {
+		const result = method.inputSchema.safeParse(input)
+		if (!result.success) {
+			const errors = result.error.issues.map((i) => `${i.path.join('.')}: ${i.message}`).join('; ')
+			throw new Error(`Invalid input for method "${method.name}": ${errors}`)
+		}
+		return result.data
+	}
 
-  protected measureExecution<TResult>(
-    fn: () => Promise<TResult>,
-  ): Promise<{ result: TResult; durationMs: number }> {
-    const start = performance.now()
-    return fn().then((result) => ({
-      result,
-      durationMs: Math.round(performance.now() - start),
-    }))
-  }
+	protected measureExecution<TResult>(
+		fn: () => Promise<TResult>,
+	): Promise<{ result: TResult; durationMs: number }> {
+		const start = performance.now()
+		return fn().then((result) => ({
+			result,
+			durationMs: Math.round(performance.now() - start),
+		}))
+	}
 }