@namzu/sdk 0.1.1

package/src/utils/abort.ts

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

package/src/utils/conversation.ts

@@ -0,0 +1,16 @@
+import type { Message, AssistantMessage } 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
+}

package/src/utils/cost.ts

@@ -0,0 +1,51 @@
+import type { TokenUsage, CostInfo } from '../types/common/index.js'
+
+export interface ModelPricing {
+  inputCostPer1M: number
+  outputCostPer1M: number
+}
+
+export const ZERO_COST: CostInfo = {
+  inputCostPer1M: 0,
+  outputCostPer1M: 0,
+  totalCost: 0,
+  cacheDiscount: 0,
+}
+
+export function calculateCost(
+  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
+
+  return {
+    inputCostPer1M: pricing.inputCostPer1M,
+    outputCostPer1M: pricing.outputCostPer1M,
+    totalCost: gross - cacheDiscount,
+    cacheDiscount,
+  }
+}
+
+export function accumulateCost(
+  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,
+  }
+}
+
+export function formatCost(usd: number): string {
+  if (usd === 0) return '$0.00'
+  if (usd < 0.01) return `$${usd.toFixed(4)}`
+  return `$${usd.toFixed(2)}`
+}

package/src/utils/error.ts

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

package/src/utils/hash.ts

@@ -0,0 +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)
+}
+
+export function buildToolResultHashes(
+  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
+}

package/src/utils/id.ts

@@ -0,0 +1,116 @@
+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'
+
+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}`
+}
+
+export function generateThreadId(): ThreadId {
+  return generateId('thd_')
+}
+
+export function generateRunId(): RunId {
+  return generateId('run_')
+}
+
+export function generateMessageId(): MessageId {
+  return generateId('msg_')
+}
+
+export function generateSessionId(): SessionId {
+  return generateId('sess_')
+}
+
+export function generateToolCallId(): ToolCallId {
+  return generateId('call_', 8)
+}
+
+export function generateActivityId(): ActivityId {
+  return generateId('act_')
+}
+
+export function generateTaskId(): TaskId {
+  return generateId('task_')
+}
+
+export function generatePlanId(): PlanId {
+  return generateId('plan_')
+}
+
+export function generateKnowledgeBaseId(): KnowledgeBaseId {
+  return generateId('kb_')
+}
+
+export function generateDocumentId(): DocumentId {
+  return generateId('doc_')
+}
+
+export function generateChunkId(): ChunkId {
+  return generateId('chk_')
+}
+
+export function generateConnectorId(): ConnectorId {
+  return generateId('conn_')
+}
+
+export function generateConnectorInstanceId(): ConnectorInstanceId {
+  return generateId('ci_')
+}
+
+export function generateTenantId(): TenantId {
+  return generateId('ten_')
+}
+
+export function generateCredentialId(): CredentialId {
+  return generateId('cred_')
+}
+
+export function generateExecutionContextId(): ExecutionContextId {
+  return generateId('ectx_')
+}
+
+export function generateMCPServerId(): MCPServerId {
+  return generateId('mcp_')
+}
+
+export function generateMCPClientId(): MCPClientId {
+  return generateId('mcpc_')
+}
+
+export function generateMCPSessionId(): MCPSessionId {
+  return generateId('mcps_')
+}
+
+export function generateEnvironmentId(): EnvironmentId {
+  return generateId('env_')
+}
+
+export function generateCheckpointId(): CheckpointId {
+  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
+}
+
+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

@@ -0,0 +1,74 @@
+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,
+}
+
+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
+}
+
+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
+
+    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)
+    }
+  }
+
+  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,
+  }
+}
+
+let _rootLogger: Logger | null = null
+
+export function getRootLogger(): Logger {
+  if (!_rootLogger) {
+    _rootLogger = createLoggerImpl('namzu', 'info', {})
+  }
+  return _rootLogger
+}
+
+export function configureLogger(options: { level?: LogLevel }): void {
+  _rootLogger = createLoggerImpl('namzu', options.level ?? 'info', {})
+}

package/src/utils/memoize.ts

@@ -0,0 +1,16 @@
+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
+  }
+
+  wrapper.invalidate = () => {
+    cached = undefined
+  }
+
+  return wrapper
+}

package/src/vault/InMemoryCredentialVault.ts

@@ -0,0 +1,64 @@
+import type {
+  CredentialVault,
+  CredentialRef,
+  AuthConfig,
+} from '../types/connector/index.js'
+import type { TenantId, CredentialId } from '../types/ids/index.js'
+import { generateCredentialId } from '../utils/id.js'
+import { getRootLogger, type Logger } from '../utils/logger.js'
+
+export class InMemoryCredentialVault implements CredentialVault {
+  private refs: Map<CredentialId, CredentialRef> = new Map()
+  private secrets: Map<CredentialId, AuthConfig> = new Map()
+  private log: Logger
+
+  constructor() {
+    this.log = getRootLogger().child({ component: 'InMemoryCredentialVault' })
+  }
+
+  async store(
+    tenantId: TenantId,
+    connectorId: string,
+    label: string,
+    auth: AuthConfig,
+  ): Promise<CredentialRef> {
+    const id = generateCredentialId()
+    const ref: CredentialRef = {
+      id,
+      connectorId,
+      tenantId,
+      label,
+      authType: auth.type,
+      createdAt: Date.now(),
+    }
+
+    this.refs.set(id, ref)
+    this.secrets.set(id, auth)
+    this.log.info(`Credential stored: ${id} (${label}) for tenant ${tenantId}`)
+    return ref
+  }
+
+  async retrieve(credentialId: CredentialId): Promise<AuthConfig | undefined> {
+    return this.secrets.get(credentialId)
+  }
+
+  async revoke(credentialId: CredentialId): Promise<boolean> {
+    const existed = this.refs.has(credentialId)
+    this.refs.delete(credentialId)
+    this.secrets.delete(credentialId)
+    if (existed) {
+      this.log.info(`Credential revoked: ${credentialId}`)
+    }
+    return existed
+  }
+
+  async list(tenantId: TenantId, connectorId?: string): Promise<CredentialRef[]> {
+    const results: CredentialRef[] = []
+    for (const ref of this.refs.values()) {
+      if (ref.tenantId !== tenantId) continue
+      if (connectorId && ref.connectorId !== connectorId) continue
+      results.push(ref)
+    }
+    return results
+  }
+}

package/src/vault/index.ts

@@ -0,0 +1 @@
+export { InMemoryCredentialVault } from './InMemoryCredentialVault.js'

package/src/version.ts

@@ -0,0 +1,6 @@
+import { createRequire } from 'node:module'
+
+const require = createRequire(import.meta.url)
+const pkg = require('../package.json') as { version: string }
+
+export const VERSION: string = pkg.version