@namzu/sdk 0.1.1 → 0.1.2

package/src/types/hitl/index.ts

@@ -1,106 +1,117 @@
-import type { RunId, PlanId } from '../ids/index.js'
-import type { TokenUsage, CostInfo } from '../common/index.js'
-import type { PlanStep, PlanStatus } from '../plan/index.js'
+import type { CostInfo, TokenUsage } from '../common/index.js'
+import type { PlanId, RunId } from '../ids/index.js'
 import type { Message } from '../message/index.js'
+import type { PlanStatus } from '../plan/index.js'
 
 import type { CheckpointId } from '../ids/index.js'
 export type { CheckpointId }
 
 export type HITLResumeDecision =
-  | { action: 'continue' }
-  | { action: 'approve_plan' }
-  | { action: 'reject_plan'; feedback: string }
-  | { action: 'approve_tools' }
-  | { action: 'modify_tools'; modifications: ToolModification[] }
-  | { action: 'reject_tools'; feedback: string }
-  | { action: 'pause'; reason: string }
-  | { action: 'abort'; reason: string }
+	| { action: 'continue' }
+	| { action: 'approve_plan' }
+	| { action: 'reject_plan'; feedback: string }
+	| { action: 'approve_tools' }
+	| { action: 'modify_tools'; modifications: ToolModification[] }
+	| { action: 'reject_tools'; feedback: string }
+	| { action: 'pause'; reason: string }
+	| { action: 'abort'; reason: string }
 
 export type HITLDecisionRequest =
-  | { type: 'plan_approval'; runId: RunId; checkpointId: CheckpointId; plan: PlanApprovalData }
-  | { type: 'tool_review'; runId: RunId; checkpointId: CheckpointId; toolCalls: ToolCallSummary[] }
-  | { type: 'iteration_checkpoint'; runId: RunId; checkpointId: CheckpointId; summary: CheckpointSummary }
+	| { type: 'plan_approval'; runId: RunId; checkpointId: CheckpointId; plan: PlanApprovalData }
+	| { type: 'tool_review'; runId: RunId; checkpointId: CheckpointId; toolCalls: ToolCallSummary[] }
+	| {
+			type: 'iteration_checkpoint'
+			runId: RunId
+			checkpointId: CheckpointId
+			summary: CheckpointSummary
+	  }
 
 export type ResumeHandler = (request: HITLDecisionRequest) => Promise<HITLResumeDecision>
 
 export interface ToolCallSummary {
-  id: string
-  name: string
-  input: unknown
-  isDestructive: boolean
+	id: string
+	name: string
+	input: unknown
+	isDestructive: boolean
 }
 
 export interface ToolModification {
-  toolCallId: string
-  action: 'approve' | 'deny' | 'modify'
-  modifiedInput?: unknown
+	toolCallId: string
+	action: 'approve' | 'deny' | 'modify'
+	modifiedInput?: unknown
 }
 
 export interface PlanApprovalData {
-  planId: PlanId
-  title: string
-  steps: Array<{ id: string; description: string; toolName?: string; dependsOn: string[]; order: number }>
-  summary?: string
+	planId: PlanId
+	title: string
+	steps: Array<{
+		id: string
+		description: string
+		toolName?: string
+		dependsOn: string[]
+		order: number
+	}>
+	summary?: string
 }
 
 export interface CheckpointSummary {
-  iteration: number
-  messageCount: number
-  tokenUsage: TokenUsage
-  costInfo: CostInfo
-  lastAssistantMessage?: string
+	iteration: number
+	messageCount: number
+	tokenUsage: TokenUsage
+	costInfo: CostInfo
+	lastAssistantMessage?: string
 }
 
 export interface ActiveNodeInfo {
-  agentId: string
-  agentType: 'reactive' | 'pipeline' | 'router' | 'supervisor'
+	agentId: string
+	agentType: 'reactive' | 'pipeline' | 'router' | 'supervisor'
 
-  nodeRef?: string
+	nodeRef?: string
 
-  parentAgentId?: string
+	parentAgentId?: string
 
-  depth: number
+	depth: number
 }
 
 export interface BranchStackEntry {
-  agentId: string
-  decision: string
-  confidence: number
-  timestamp: number
+	agentId: string
+	decision: string
+	confidence: number
+	timestamp: number
 }
 
 export interface IterationCheckpoint {
-  id: CheckpointId
-  runId: RunId
-  iteration: number
-  messages: Message[]
-  tokenUsage: TokenUsage
-  costInfo: CostInfo
-  planStatus?: PlanStatus
-  guardState: {
-    iterationCount: number
-    elapsedMs: number
-  }
-  createdAt: number
-
-  toolResultHashes?: Record<string, string>
-
-  branchStack?: BranchStackEntry[]
-
-  activeNode?: ActiveNodeInfo
+	id: CheckpointId
+	runId: RunId
+	iteration: number
+	messages: Message[]
+	tokenUsage: TokenUsage
+	costInfo: CostInfo
+	planStatus?: PlanStatus
+	guardState: {
+		iterationCount: number
+		elapsedMs: number
+	}
+	createdAt: number
+
+	toolResultHashes?: Record<string, string>
+
+	branchStack?: BranchStackEntry[]
+
+	activeNode?: ActiveNodeInfo
 }
 
 export function autoApproveHandler(request: HITLDecisionRequest): Promise<HITLResumeDecision> {
-  switch (request.type) {
-    case 'plan_approval':
-      return Promise.resolve({ action: 'approve_plan' })
-    case 'tool_review':
-      return Promise.resolve({ action: 'approve_tools' })
-    case 'iteration_checkpoint':
-      return Promise.resolve({ action: 'continue' })
-    default: {
-      const _exhaustive: never = request
-      throw new Error(`Unhandled HITL request type: ${(_exhaustive as HITLDecisionRequest).type}`)
-    }
-  }
+	switch (request.type) {
+		case 'plan_approval':
+			return Promise.resolve({ action: 'approve_plan' })
+		case 'tool_review':
+			return Promise.resolve({ action: 'approve_tools' })
+		case 'iteration_checkpoint':
+			return Promise.resolve({ action: 'continue' })
+		default: {
+			const _exhaustive: never = request
+			throw new Error(`Unhandled HITL request type: ${(_exhaustive as HITLDecisionRequest).type}`)
+		}
+	}
 }

package/src/types/message/index.ts

@@ -1,62 +1,59 @@
 export type MessageRole = 'system' | 'user' | 'assistant' | 'tool'
 
 export interface ToolCall {
-  id: string
-  type: 'function'
-  function: {
-    name: string
-    arguments: string
-  }
+	id: string
+	type: 'function'
+	function: {
+		name: string
+		arguments: string
+	}
 }
 
 export interface BaseMessage {
-  role: MessageRole
-  content: string | null
-  timestamp?: number
+	role: MessageRole
+	content: string | null
+	timestamp?: number
 }
 
 export interface SystemMessage extends BaseMessage {
-  role: 'system'
-  content: string
+	role: 'system'
+	content: string
 }
 
 export interface UserMessage extends BaseMessage {
-  role: 'user'
-  content: string
+	role: 'user'
+	content: string
 }
 
 export interface AssistantMessage extends BaseMessage {
-  role: 'assistant'
-  content: string | null
-  toolCalls?: ToolCall[]
+	role: 'assistant'
+	content: string | null
+	toolCalls?: ToolCall[]
 }
 
 export interface ToolMessage extends BaseMessage {
-  role: 'tool'
-  content: string
-  toolCallId: string
+	role: 'tool'
+	content: string
+	toolCallId: string
 }
 
 export type Message = SystemMessage | UserMessage | AssistantMessage | ToolMessage
 
 export function createSystemMessage(content: string): SystemMessage {
-  return { role: 'system', content, timestamp: Date.now() }
+	return { role: 'system', content, timestamp: Date.now() }
 }
 
 export function createUserMessage(content: string): UserMessage {
-  return { role: 'user', content, timestamp: Date.now() }
+	return { role: 'user', content, timestamp: Date.now() }
 }
 
 export function createAssistantMessage(
-  content: string | null,
-  toolCalls?: ToolCall[],
+	content: string | null,
+	toolCalls?: ToolCall[],
 ): AssistantMessage {
-  return { role: 'assistant', content, toolCalls, timestamp: Date.now() }
+	return { role: 'assistant', content, toolCalls, timestamp: Date.now() }
 }
 
-export function createToolMessage(
-  content: string,
-  toolCallId: string,
-): ToolMessage {
-  return { role: 'tool', content, toolCallId, timestamp: Date.now() }
+export function createToolMessage(content: string, toolCallId: string): ToolMessage {
+	return { role: 'tool', content, toolCallId, timestamp: Date.now() }
 }

package/src/types/persona/index.ts

@@ -1,55 +1,55 @@
 export type PersonaLayer =
-  | 'system'
-  | 'identity'
-  | 'expertise'
-  | 'reflexes'
-  | 'skills'
-  | 'tools'
-  | 'output'
-  | 'task-context'
+	| 'system'
+	| 'identity'
+	| 'expertise'
+	| 'reflexes'
+	| 'skills'
+	| 'tools'
+	| 'output'
+	| 'task-context'
 
 export interface PersonaIdentity {
-  role: string
+	role: string
 
-  description: string
+	description: string
 }
 
 export interface PersonaExpertise {
-  domains: string[]
+	domains: string[]
 }
 
 export interface PersonaReflexes {
-  constraints: string[]
+	constraints: string[]
 
-  toolGuidance?: string
+	toolGuidance?: string
 }
 
 export interface PersonaOutput {
-  format: string
+	format: string
 }
 
 export interface AgentPersona {
-  identity: PersonaIdentity
-  expertise?: PersonaExpertise
-  reflexes?: PersonaReflexes
-  output?: PersonaOutput
-  sessionContext?: string
+	identity: PersonaIdentity
+	expertise?: PersonaExpertise
+	reflexes?: PersonaReflexes
+	output?: PersonaOutput
+	sessionContext?: string
 }
 
 export interface BehavioralConstraints {
-  prohibitions: string[]
-  requirements?: string[]
-  scope?: string
+	prohibitions: string[]
+	requirements?: string[]
+	scope?: string
 }
 
 export interface PersonaDefinition {
-  schemaVersion: 1
-  agentId?: string
-  personaId?: string
-
-  extends?: string
-  identity: PersonaIdentity
-  expertise?: PersonaExpertise
-  reflexes?: PersonaReflexes
-  output?: PersonaOutput
+	schemaVersion: 1
+	agentId?: string
+	personaId?: string
+
+	extends?: string
+	identity: PersonaIdentity
+	expertise?: PersonaExpertise
+	reflexes?: PersonaReflexes
+	output?: PersonaOutput
 }

package/src/types/plan/index.ts

@@ -1,56 +1,56 @@
 import type { PlanId, RunId } from '../ids/index.js'
 
 export type PlanStatus =
-  | 'generating'
-  | 'ready'
-  | 'pending_approval'
-  | 'approved'
-  | 'rejected'
-  | 'executing'
-  | 'completed'
-  | 'failed'
+	| 'generating'
+	| 'ready'
+	| 'pending_approval'
+	| 'approved'
+	| 'rejected'
+	| 'executing'
+	| 'completed'
+	| 'failed'
 
 export function isTerminalPlanStatus(status: PlanStatus): boolean {
-  return status === 'completed' || status === 'failed' || status === 'rejected'
+	return status === 'completed' || status === 'failed' || status === 'rejected'
 }
 
 export interface PlanStep {
-  id: string
-  description: string
-  toolName?: string
-  estimatedInput?: unknown
-  dependsOn: string[]
-  status: 'pending' | 'running' | 'completed' | 'skipped' | 'failed'
-  error?: string
-  order: number
+	id: string
+	description: string
+	toolName?: string
+	estimatedInput?: unknown
+	dependsOn: string[]
+	status: 'pending' | 'running' | 'completed' | 'skipped' | 'failed'
+	error?: string
+	order: number
 }
 
 export interface Plan {
-  id: PlanId
-  runId: RunId
-  status: PlanStatus
-  title: string
-  summary?: string
-  steps: PlanStep[]
-  rawContent?: string
-  createdAt: number
-  readyAt?: number
-  approvedAt?: number
-  rejectedAt?: number
-  completedAt?: number
-  rejectionReason?: string
+	id: PlanId
+	runId: RunId
+	status: PlanStatus
+	title: string
+	summary?: string
+	steps: PlanStep[]
+	rawContent?: string
+	createdAt: number
+	readyAt?: number
+	approvedAt?: number
+	rejectedAt?: number
+	completedAt?: number
+	rejectionReason?: string
 }
 
 export interface PlanApprovalRequest {
-  planId: PlanId
-  runId: RunId
-  title: string
-  steps: PlanStep[]
-  summary?: string
+	planId: PlanId
+	runId: RunId
+	title: string
+	steps: PlanStep[]
+	summary?: string
 }
 
 export interface PlanApprovalResponse {
-  approved: boolean
-  feedback?: string
-  modifiedSteps?: PlanStep[]
+	approved: boolean
+	feedback?: string
+	modifiedSteps?: PlanStep[]
 }

package/src/types/provider/chat.ts

@@ -1,59 +1,62 @@
+import type { TokenUsage } from '../common/index.js'
 import type { Message } from '../message/index.js'
 import type { LLMToolSchema } from '../tool/index.js'
-import type { TokenUsage } from '../common/index.js'
 
 export type ToolChoice =
-  | 'auto'
-  | 'none'
-  | 'required'
-  | { type: 'function'; function: { name: string } }
+	| 'auto'
+	| 'none'
+	| 'required'
+	| { type: 'function'; function: { name: string } }
 
 export type ResponseFormat =
-  | { type: 'json_object' }
-  | { type: 'json_schema'; json_schema: { name: string; schema: Record<string, unknown>; strict?: boolean } }
+	| { type: 'json_object' }
+	| {
+			type: 'json_schema'
+			json_schema: { name: string; schema: Record<string, unknown>; strict?: boolean }
+	  }
 
 export interface CacheControl {
-  type: 'auto' | 'ephemeral'
+	type: 'auto' | 'ephemeral'
 }
 
 export interface ChatCompletionParams {
-  model: string
-  messages: Message[]
-  tools?: LLMToolSchema[]
-  temperature?: number
-  maxTokens?: number
-  stream?: boolean
-  stop?: string[]
-
-  toolChoice?: ToolChoice
-  parallelToolCalls?: boolean
-
-  cacheControl?: CacheControl
-
-  topP?: number
-  topK?: number
-  frequencyPenalty?: number
-  presencePenalty?: number
-  repetitionPenalty?: number
-
-  responseFormat?: ResponseFormat
+	model: string
+	messages: Message[]
+	tools?: LLMToolSchema[]
+	temperature?: number
+	maxTokens?: number
+	stream?: boolean
+	stop?: string[]
+
+	toolChoice?: ToolChoice
+	parallelToolCalls?: boolean
+
+	cacheControl?: CacheControl
+
+	topP?: number
+	topK?: number
+	frequencyPenalty?: number
+	presencePenalty?: number
+	repetitionPenalty?: number
+
+	responseFormat?: ResponseFormat
 }
 
 export interface ChatCompletionResponse {
-  id: string
-  model: string
-  message: {
-    role: 'assistant'
-    content: string | null
-    toolCalls?: Array<{
-      id: string
-      type: 'function'
-      function: {
-        name: string
-        arguments: string
-      }
-    }>
-  }
-  finishReason: 'stop' | 'tool_calls' | 'length' | 'content_filter'
-  usage: TokenUsage
+	id: string
+	model: string
+	message: {
+		role: 'assistant'
+		content: string | null
+		toolCalls?: Array<{
+			id: string
+			type: 'function'
+			function: {
+				name: string
+				arguments: string
+			}
+		}>
+	}
+	finishReason: 'stop' | 'tool_calls' | 'length' | 'content_filter'
+	usage: TokenUsage
 }

package/src/types/provider/config.ts

@@ -3,48 +3,51 @@ import type { LLMProvider } from './interface.js'
 export type ProviderType = 'openrouter' | 'bedrock' | 'mock'
 
 export interface OpenRouterConfig {
-  apiKey: string
-  baseUrl?: string
-  siteUrl?: string
-  siteName?: string
-  timeout?: number
+	apiKey: string
+	baseUrl?: string
+	siteUrl?: string
+	siteName?: string
+	timeout?: number
 }
 
 export interface OpenRouterProviderConfig extends OpenRouterConfig {
-  type: 'openrouter'
+	type: 'openrouter'
 }
 
 export interface BedrockConfig {
-  region?: string
+	region?: string
 
-  accessKeyId?: string
-  secretAccessKey?: string
-  sessionToken?: string
+	accessKeyId?: string
+	secretAccessKey?: string
+	sessionToken?: string
 
-  timeout?: number
+	timeout?: number
 }
 
 export interface BedrockProviderConfig extends BedrockConfig {
-  type: 'bedrock'
+	type: 'bedrock'
 }
 
 export interface MockProviderConfig {
-  type: 'mock'
-  model?: string
-  responseText?: string
-  responseDelayMs?: number
+	type: 'mock'
+	model?: string
+	responseText?: string
+	responseDelayMs?: number
 }
 
-export type ProviderFactoryConfig = OpenRouterProviderConfig | BedrockProviderConfig | MockProviderConfig
+export type ProviderFactoryConfig =
+	| OpenRouterProviderConfig
+	| BedrockProviderConfig
+	| MockProviderConfig
 
 export interface ProviderCapabilities {
-  supportsTools: boolean
-  supportsStreaming: boolean
-  supportsFunctionCalling: boolean
-  maxOutputTokens?: number
+	supportsTools: boolean
+	supportsStreaming: boolean
+	supportsFunctionCalling: boolean
+	maxOutputTokens?: number
 }
 
 export interface ProviderFactoryResult {
-  provider: LLMProvider
-  capabilities: ProviderCapabilities
+	provider: LLMProvider
+	capabilities: ProviderCapabilities
 }

package/src/types/provider/index.ts

@@ -1,15 +1,21 @@
-export type { ToolChoice, ResponseFormat, CacheControl, ChatCompletionParams, ChatCompletionResponse } from './chat.js'
+export type {
+	ToolChoice,
+	ResponseFormat,
+	CacheControl,
+	ChatCompletionParams,
+	ChatCompletionResponse,
+} from './chat.js'
 export type { StreamChunk } from './stream.js'
 export type { ModelInfo } from './model.js'
 export type { LLMProvider } from './interface.js'
 export type {
-  ProviderType,
-  OpenRouterConfig,
-  OpenRouterProviderConfig,
-  BedrockConfig,
-  BedrockProviderConfig,
-  MockProviderConfig,
-  ProviderFactoryConfig,
-  ProviderCapabilities,
-  ProviderFactoryResult,
+	ProviderType,
+	OpenRouterConfig,
+	OpenRouterProviderConfig,
+	BedrockConfig,
+	BedrockProviderConfig,
+	MockProviderConfig,
+	ProviderFactoryConfig,
+	ProviderCapabilities,
+	ProviderFactoryResult,
 } from './config.js'