@namzu/sdk 0.1.1 → 0.1.2

package/src/types/tool/index.ts

@@ -1,69 +1,69 @@
-import type { z } from "zod";
-import type { Logger } from "../../utils/logger.js";
-import type { RunId } from "../ids/index.js";
-import type { PermissionMode } from "../permission/index.js";
+import type { z } from 'zod'
+import type { Logger } from '../../utils/logger.js'
+import type { RunId } from '../ids/index.js'
+import type { PermissionMode } from '../permission/index.js'
 
 export interface ToolRegistryRef {
-	searchDeferred(query: string): ToolDefinition[];
-	activate(names: string[]): void;
-	getAvailability(name: string): ToolAvailability;
+	searchDeferred(query: string): ToolDefinition[]
+	activate(names: string[]): void
+	getAvailability(name: string): ToolAvailability
 }
 
 export interface ToolContext {
-	runId: RunId;
-	workingDirectory: string;
-	abortSignal: AbortSignal;
-	env: Record<string, string>;
-	log: (level: "info" | "warn" | "error", message: string) => void;
+	runId: RunId
+	workingDirectory: string
+	abortSignal: AbortSignal
+	env: Record<string, string>
+	log: (level: 'info' | 'warn' | 'error', message: string) => void
 	permissionContext?: {
-		mode: PermissionMode;
-		sessionId: string;
-		workingDirectory: string;
-	};
+		mode: PermissionMode
+		sessionId: string
+		workingDirectory: string
+	}
 
-	toolRegistry?: ToolRegistryRef;
+	toolRegistry?: ToolRegistryRef
 }
 
 export interface ToolResult {
-	success: boolean;
-	output: string;
-	data?: unknown;
-	error?: string;
+	success: boolean
+	output: string
+	data?: unknown
+	error?: string
 }
 
 export interface ToolDefinition<TInput = unknown> {
-	name: string;
-	description: string;
-	inputSchema: z.ZodType<TInput, z.ZodTypeDef, unknown>;
-	execute(input: TInput, context: ToolContext): Promise<ToolResult>;
-	permissions?: ToolPermission[];
-	category?: "filesystem" | "shell" | "network" | "analysis" | "custom";
+	name: string
+	description: string
+	inputSchema: z.ZodType<TInput, z.ZodTypeDef, unknown>
+	execute(input: TInput, context: ToolContext): Promise<ToolResult>
+	permissions?: ToolPermission[]
+	category?: 'filesystem' | 'shell' | 'network' | 'analysis' | 'custom'
 
-	isReadOnly?(input: TInput): boolean;
-	isDestructive?(input: TInput): boolean;
-	isConcurrencySafe?(input: TInput): boolean;
+	isReadOnly?(input: TInput): boolean
+	isDestructive?(input: TInput): boolean
+	isConcurrencySafe?(input: TInput): boolean
 }
 
 export type ToolPermission =
-	| "file_read"
-	| "file_write"
-	| "shell_execute"
-	| "network_access"
-	| "env_access";
+	| 'file_read'
+	| 'file_write'
+	| 'shell_execute'
+	| 'network_access'
+	| 'env_access'
 
 export interface LLMToolSchema {
-	type: "function";
+	type: 'function'
 	function: {
-		name: string;
-		description: string;
-		parameters: Record<string, unknown>;
-	};
+		name: string
+		description: string
+		parameters: Record<string, unknown>
+	}
 }
 
-export type ToolAvailability = "deferred" | "active" | "suspended";
+export type ToolAvailability = 'deferred' | 'active' | 'suspended'
 
-export type ZodToJsonSchema = (schema: z.ZodType) => Record<string, unknown>;
+export type ZodToJsonSchema = (schema: z.ZodType) => Record<string, unknown>
 
 export interface ToolRegistryConfig {
-	logger?: Logger;
+	logger?: Logger
 }

package/src/utils/abort.ts

@@ -1,31 +1,29 @@
-export function createChildAbortController(
-	parent: AbortController,
-): AbortController {
-	const child = new AbortController();
+export function createChildAbortController(parent: AbortController): AbortController {
+	const child = new AbortController()
 
 	if (parent.signal.aborted) {
-		child.abort(parent.signal.reason);
-		return child;
+		child.abort(parent.signal.reason)
+		return child
 	}
 
-	const weakChild = new WeakRef(child);
+	const weakChild = new WeakRef(child)
 
 	const onParentAbort = (): void => {
-		const ref = weakChild.deref();
+		const ref = weakChild.deref()
 		if (ref && !ref.signal.aborted) {
-			ref.abort(parent.signal.reason);
+			ref.abort(parent.signal.reason)
 		}
-	};
+	}
 
-	parent.signal.addEventListener("abort", onParentAbort, { once: true });
+	parent.signal.addEventListener('abort', onParentAbort, { once: true })
 
 	child.signal.addEventListener(
-		"abort",
+		'abort',
 		() => {
-			parent.signal.removeEventListener("abort", onParentAbort);
+			parent.signal.removeEventListener('abort', onParentAbort)
 		},
 		{ once: true },
-	);
+	)
 
-	return child;
+	return child
 }

package/src/utils/conversation.ts

@@ -1,16 +1,17 @@
-import type { Message, AssistantMessage } from '../types/message/index.js'
+import type { AssistantMessage, Message } from '../types/message/index.js'
 
 export function extractFinalResponse(messages: Message[]): AssistantMessage | undefined {
-  for (let i = messages.length - 1; i >= 0; i--) {
-    const msg = messages[i]
-    if (
-      msg.role === 'assistant' &&
-      msg.content !== null &&
-      msg.content !== undefined &&
-      msg.content.length > 0
-    ) {
-      return msg as AssistantMessage
-    }
-  }
-  return undefined
+	for (let i = messages.length - 1; i >= 0; i--) {
+		const msg = messages[i]
+		if (!msg) continue
+		if (
+			msg.role === 'assistant' &&
+			msg.content !== null &&
+			msg.content !== undefined &&
+			msg.content.length > 0
+		) {
+			return msg as AssistantMessage
+		}
+	}
+	return undefined
 }

package/src/utils/cost.ts

@@ -1,51 +1,47 @@
-import type { TokenUsage, CostInfo } from '../types/common/index.js'
+import { ZERO_COST } from '../constants/limits.js'
+import type { CostInfo, TokenUsage } from '../types/common/index.js'
 
 export interface ModelPricing {
-  inputCostPer1M: number
-  outputCostPer1M: number
+	inputCostPer1M: number
+	outputCostPer1M: number
 }
 
-export const ZERO_COST: CostInfo = {
-  inputCostPer1M: 0,
-  outputCostPer1M: 0,
-  totalCost: 0,
-  cacheDiscount: 0,
-}
+export { ZERO_COST }
 
 export function calculateCost(
-  usage: TokenUsage,
-  pricing: ModelPricing,
-  cacheDiscount = 0,
+	usage: TokenUsage,
+	pricing: ModelPricing,
+	cacheDiscount = 0,
 ): CostInfo {
-  const inputCost = (usage.promptTokens / 1_000_000) * pricing.inputCostPer1M
-  const outputCost = (usage.completionTokens / 1_000_000) * pricing.outputCostPer1M
-  const gross = inputCost + outputCost
+	const inputCost = (usage.promptTokens / 1_000_000) * pricing.inputCostPer1M
+	const outputCost = (usage.completionTokens / 1_000_000) * pricing.outputCostPer1M
+	const gross = inputCost + outputCost
 
-  return {
-    inputCostPer1M: pricing.inputCostPer1M,
-    outputCostPer1M: pricing.outputCostPer1M,
-    totalCost: gross - cacheDiscount,
-    cacheDiscount,
-  }
+	return {
+		inputCostPer1M: pricing.inputCostPer1M,
+		outputCostPer1M: pricing.outputCostPer1M,
+		totalCost: gross - cacheDiscount,
+		cacheDiscount,
+	}
 }
 
 export function accumulateCost(
-  current: CostInfo,
-  additionalUsage: TokenUsage,
-  pricing: ModelPricing,
-  cacheDiscount = 0,
+	current: CostInfo,
+	additionalUsage: TokenUsage,
+	pricing: ModelPricing,
+	cacheDiscount = 0,
 ): CostInfo {
-  const additional = calculateCost(additionalUsage, pricing, cacheDiscount)
-  return {
-    inputCostPer1M: pricing.inputCostPer1M,
-    outputCostPer1M: pricing.outputCostPer1M,
-    totalCost: current.totalCost + additional.totalCost,
-    cacheDiscount: current.cacheDiscount + additional.cacheDiscount,
-  }
+	const additional = calculateCost(additionalUsage, pricing, cacheDiscount)
+	return {
+		inputCostPer1M: pricing.inputCostPer1M,
+		outputCostPer1M: pricing.outputCostPer1M,
+		totalCost: current.totalCost + additional.totalCost,
+		cacheDiscount: current.cacheDiscount + additional.cacheDiscount,
+	}
 }
 
 export function formatCost(usd: number): string {
-  if (usd === 0) return '$0.00'
-  if (usd < 0.01) return `$${usd.toFixed(4)}`
-  return `$${usd.toFixed(2)}`
+	if (usd === 0) return '$0.00'
+	if (usd < 0.01) return `$${usd.toFixed(4)}`
+	return `$${usd.toFixed(2)}`
 }

package/src/utils/error.ts

@@ -1,3 +1,3 @@
 export function toErrorMessage(err: unknown): string {
-  return err instanceof Error ? err.message : String(err)
+	return err instanceof Error ? err.message : String(err)
 }

package/src/utils/hash.ts

@@ -1,16 +1,16 @@
 import { createHash } from 'node:crypto'
 
 export function hashToolResult(toolName: string, input: unknown, output: string): string {
-  const data = JSON.stringify({ toolName, input, output })
-  return createHash('sha256').update(data).digest('hex').slice(0, 16)
+	const data = JSON.stringify({ toolName, input, output })
+	return createHash('sha256').update(data).digest('hex').slice(0, 16)
 }
 
 export function buildToolResultHashes(
-  toolResults: Array<{ toolCallId: string; toolName: string; input: unknown; output: string }>,
+	toolResults: Array<{ toolCallId: string; toolName: string; input: unknown; output: string }>,
 ): Record<string, string> {
-  const hashes: Record<string, string> = {}
-  for (const result of toolResults) {
-    hashes[result.toolCallId] = hashToolResult(result.toolName, result.input, result.output)
-  }
-  return hashes
+	const hashes: Record<string, string> = {}
+	for (const result of toolResults) {
+		hashes[result.toolCallId] = hashToolResult(result.toolName, result.input, result.output)
+	}
+	return hashes
 }

package/src/utils/id.ts

@@ -1,116 +1,145 @@
 import { randomBytes } from 'node:crypto'
-import type { ThreadId, RunId, MessageId, SessionId, ToolCallId, ActivityId, TaskId, PlanId, KnowledgeBaseId, DocumentId, ChunkId, ConnectorId, ConnectorInstanceId, TenantId, CredentialId, ExecutionContextId, MCPServerId, MCPClientId, MCPSessionId, EnvironmentId, CheckpointId } from '../types/ids/index.js'
+import type {
+	ActivityId,
+	CheckpointId,
+	ChunkId,
+	ConnectorId,
+	ConnectorInstanceId,
+	CredentialId,
+	DocumentId,
+	EnvironmentId,
+	ExecutionContextId,
+	KnowledgeBaseId,
+	MCPClientId,
+	MCPServerId,
+	MCPSessionId,
+	MessageId,
+	PlanId,
+	RunId,
+	SessionId,
+	TaskId,
+	TenantId,
+	ThreadId,
+	ToolCallId,
+} from '../types/ids/index.js'
 
 const ALPHABET = '0123456789abcdefghijklmnopqrstuvwxyz'
 const ALPHABET_LEN = ALPHABET.length
 const MAX_UNIFORM_BYTE = Math.floor(256 / ALPHABET_LEN) * ALPHABET_LEN
 
 function generateId<T extends string>(prefix: T, length = 12): `${T}${string}` {
-  let suffix = ''
-  let remaining = length
-  while (remaining > 0) {
-    const bytes = randomBytes(remaining + 8)
-    for (let i = 0; i < bytes.length && remaining > 0; i++) {
-      if (bytes[i]! < MAX_UNIFORM_BYTE) {
-        suffix += ALPHABET[bytes[i]! % ALPHABET_LEN]
-        remaining--
-      }
-    }
-  }
-  return `${prefix}${suffix}` as `${T}${string}`
+	let suffix = ''
+	let remaining = length
+	while (remaining > 0) {
+		const bytes = randomBytes(remaining + 8)
+		for (const byte of bytes) {
+			if (remaining <= 0) break
+			if (byte < MAX_UNIFORM_BYTE) {
+				suffix += ALPHABET[byte % ALPHABET_LEN]
+				remaining--
+			}
+		}
+	}
+	return `${prefix}${suffix}` as `${T}${string}`
 }
 
 export function generateThreadId(): ThreadId {
-  return generateId('thd_')
+	return generateId('thd_')
 }
 
 export function generateRunId(): RunId {
-  return generateId('run_')
+	return generateId('run_')
 }
 
 export function generateMessageId(): MessageId {
-  return generateId('msg_')
+	return generateId('msg_')
 }
 
 export function generateSessionId(): SessionId {
-  return generateId('sess_')
+	return generateId('sess_')
 }
 
 export function generateToolCallId(): ToolCallId {
-  return generateId('call_', 8)
+	return generateId('call_', 8)
 }
 
 export function generateActivityId(): ActivityId {
-  return generateId('act_')
+	return generateId('act_')
 }
 
 export function generateTaskId(): TaskId {
-  return generateId('task_')
+	return generateId('task_')
 }
 
 export function generatePlanId(): PlanId {
-  return generateId('plan_')
+	return generateId('plan_')
 }
 
 export function generateKnowledgeBaseId(): KnowledgeBaseId {
-  return generateId('kb_')
+	return generateId('kb_')
 }
 
 export function generateDocumentId(): DocumentId {
-  return generateId('doc_')
+	return generateId('doc_')
 }
 
 export function generateChunkId(): ChunkId {
-  return generateId('chk_')
+	return generateId('chk_')
 }
 
 export function generateConnectorId(): ConnectorId {
-  return generateId('conn_')
+	return generateId('conn_')
 }
 
 export function generateConnectorInstanceId(): ConnectorInstanceId {
-  return generateId('ci_')
+	return generateId('ci_')
 }
 
 export function generateTenantId(): TenantId {
-  return generateId('ten_')
+	return generateId('ten_')
 }
 
 export function generateCredentialId(): CredentialId {
-  return generateId('cred_')
+	return generateId('cred_')
 }
 
 export function generateExecutionContextId(): ExecutionContextId {
-  return generateId('ectx_')
+	return generateId('ectx_')
 }
 
 export function generateMCPServerId(): MCPServerId {
-  return generateId('mcp_')
+	return generateId('mcp_')
 }
 
 export function generateMCPClientId(): MCPClientId {
-  return generateId('mcpc_')
+	return generateId('mcpc_')
 }
 
 export function generateMCPSessionId(): MCPSessionId {
-  return generateId('mcps_')
+	return generateId('mcps_')
 }
 
 export function generateEnvironmentId(): EnvironmentId {
-  return generateId('env_')
+	return generateId('env_')
 }
 
 export function generateCheckpointId(): CheckpointId {
-  return generateId('cp_')
+	return generateId('cp_')
 }
 
 function parseId<T extends string>(raw: string, prefix: string, typeName: string): T {
-  if (!raw.startsWith(prefix)) {
-    throw new Error(`Invalid ${typeName}: expected "${prefix}" prefix, got "${raw}"`)
-  }
-  return raw as T
+	if (!raw.startsWith(prefix)) {
+		throw new Error(`Invalid ${typeName}: expected "${prefix}" prefix, got "${raw}"`)
+	}
+	return raw as T
 }
 
-export function parseThreadId(raw: string): ThreadId { return parseId<ThreadId>(raw, 'thd_', 'ThreadId') }
-export function parseRunId(raw: string): RunId { return parseId<RunId>(raw, 'run_', 'RunId') }
-export function parseConnectorInstanceId(raw: string): ConnectorInstanceId { return parseId<ConnectorInstanceId>(raw, 'ci_', 'ConnectorInstanceId') }
+export function parseThreadId(raw: string): ThreadId {
+	return parseId<ThreadId>(raw, 'thd_', 'ThreadId')
+}
+export function parseRunId(raw: string): RunId {
+	return parseId<RunId>(raw, 'run_', 'RunId')
+}
+export function parseConnectorInstanceId(raw: string): ConnectorInstanceId {
+	return parseId<ConnectorInstanceId>(raw, 'ci_', 'ConnectorInstanceId')
+}

package/src/utils/logger.ts

@@ -3,72 +3,63 @@ export type LogLevel = 'debug' | 'info' | 'warn' | 'error'
 export type LogContext = Record<string, unknown>
 
 const LOG_LEVELS: Record<LogLevel, number> = {
-  debug: 0,
-  info: 1,
-  warn: 2,
-  error: 3,
+	debug: 0,
+	info: 1,
+	warn: 2,
+	error: 3,
 }
 
 export interface Logger {
-  debug(message: string, data?: LogContext): void
-  info(message: string, data?: LogContext): void
-  warn(message: string, data?: LogContext): void
-  error(message: string, data?: LogContext): void
-  child(context: LogContext): Logger
+	debug(message: string, data?: LogContext): void
+	info(message: string, data?: LogContext): void
+	warn(message: string, data?: LogContext): void
+	error(message: string, data?: LogContext): void
+	child(context: LogContext): Logger
 }
 
-function createLoggerImpl(
-  name: string,
-  minLevel: LogLevel,
-  parentContext: LogContext,
-): Logger {
-  const minLevelNum = LOG_LEVELS[minLevel]
+function createLoggerImpl(name: string, minLevel: LogLevel, parentContext: LogContext): Logger {
+	const minLevelNum = LOG_LEVELS[minLevel]
 
-  function log(
-    level: LogLevel,
-    message: string,
-    data?: LogContext,
-  ): void {
-    if (LOG_LEVELS[level] < minLevelNum) return
+	function log(level: LogLevel, message: string, data?: LogContext): void {
+		if (LOG_LEVELS[level] < minLevelNum) return
 
-    const timestamp = new Date().toISOString()
-    const prefix = `[${timestamp}] [${level.toUpperCase()}] [${name}]`
-    const merged = { ...parentContext, ...data }
-    const hasContext = Object.keys(merged).length > 0
+		const timestamp = new Date().toISOString()
+		const prefix = `[${timestamp}] [${level.toUpperCase()}] [${name}]`
+		const merged = { ...parentContext, ...data }
+		const hasContext = Object.keys(merged).length > 0
 
-    if (hasContext) {
-      console[level === 'debug' ? 'log' : level](prefix, message, merged)
-    } else {
-      console[level === 'debug' ? 'log' : level](prefix, message)
-    }
-  }
+		if (hasContext) {
+			process.stderr.write(`${prefix} ${message} ${JSON.stringify(merged)}\n`)
+		} else {
+			process.stderr.write(`${prefix} ${message}\n`)
+		}
+	}
 
-  function child(context: LogContext): Logger {
-    return createLoggerImpl(
-      context.component ? String(context.component) : name,
-      minLevel,
-      { ...parentContext, ...context },
-    )
-  }
+	function child(context: LogContext): Logger {
+		return createLoggerImpl(context.component ? String(context.component) : name, minLevel, {
+			...parentContext,
+			...context,
+		})
+	}
 
-  return {
-    debug: (msg, data) => log('debug', msg, data),
-    info: (msg, data) => log('info', msg, data),
-    warn: (msg, data) => log('warn', msg, data),
-    error: (msg, data) => log('error', msg, data),
-    child,
-  }
+	return {
+		debug: (msg, data) => log('debug', msg, data),
+		info: (msg, data) => log('info', msg, data),
+		warn: (msg, data) => log('warn', msg, data),
+		error: (msg, data) => log('error', msg, data),
+		child,
+	}
 }
 
 let _rootLogger: Logger | null = null
 
 export function getRootLogger(): Logger {
-  if (!_rootLogger) {
-    _rootLogger = createLoggerImpl('namzu', 'info', {})
-  }
-  return _rootLogger
+	if (!_rootLogger) {
+		_rootLogger = createLoggerImpl('namzu', 'info', {})
+	}
+	return _rootLogger
 }
 
 export function configureLogger(options: { level?: LogLevel }): void {
-  _rootLogger = createLoggerImpl('namzu', options.level ?? 'info', {})
+	_rootLogger = createLoggerImpl('namzu', options.level ?? 'info', {})
 }

package/src/utils/memoize.ts

@@ -1,16 +1,18 @@
-export function memoizeAsync<T>(fn: () => Promise<T>): (() => Promise<T>) & { invalidate: () => void } {
-  let cached: { value: T } | undefined
+export function memoizeAsync<T>(
+	fn: () => Promise<T>,
+): (() => Promise<T>) & { invalidate: () => void } {
+	let cached: { value: T } | undefined
 
-  const wrapper = async (): Promise<T> => {
-    if (cached) return cached.value
-    const value = await fn()
-    cached = { value }
-    return value
-  }
+	const wrapper = async (): Promise<T> => {
+		if (cached) return cached.value
+		const value = await fn()
+		cached = { value }
+		return value
+	}
 
-  wrapper.invalidate = () => {
-    cached = undefined
-  }
+	wrapper.invalidate = () => {
+		cached = undefined
+	}
 
-  return wrapper
+	return wrapper
 }