@namzu/sdk 0.1.1 → 0.1.3

package/src/types/activity/index.ts

@@ -3,52 +3,60 @@ import type { PermissionMode } from '../permission/index.js'
 
 export type ActivityType = 'tool_call' | 'llm_turn' | 'sub_agent' | 'shell'
 
-export type ActivityStatus = 'pending' | 'running' | 'completed' | 'failed' | 'cancelled' | 'skipped'
+export type ActivityStatus =
+	| 'pending'
+	| 'running'
+	| 'completed'
+	| 'failed'
+	| 'cancelled'
+	| 'skipped'
 
 export function isTerminalActivityStatus(status: ActivityStatus): boolean {
-  return status === 'completed' || status === 'failed' || status === 'cancelled' || status === 'skipped'
+	return (
+		status === 'completed' || status === 'failed' || status === 'cancelled' || status === 'skipped'
+	)
 }
 
 export interface ActivityProgress {
-  percentage?: number
-  message?: string
-  updatedAt: number
+	percentage?: number
+	message?: string
+	updatedAt: number
 }
 
 export interface Activity<TInput = unknown, TOutput = unknown> {
-  id: ActivityId
-  runId: RunId
-  type: ActivityType
-  status: ActivityStatus
-  description: string
-  input?: TInput
-  output?: TOutput
-  error?: string
-  parentActivityId?: ActivityId
-  blockedBy: ActivityId[]
-  blocks: ActivityId[]
-  progress?: ActivityProgress
-  toolName?: string
-  toolCallId?: string
-  createdAt: number
-  startedAt?: number
-  completedAt?: number
-  durationMs?: number
+	id: ActivityId
+	runId: RunId
+	type: ActivityType
+	status: ActivityStatus
+	description: string
+	input?: TInput
+	output?: TOutput
+	error?: string
+	parentActivityId?: ActivityId
+	blockedBy: ActivityId[]
+	blocks: ActivityId[]
+	progress?: ActivityProgress
+	toolName?: string
+	toolCallId?: string
+	createdAt: number
+	startedAt?: number
+	completedAt?: number
+	durationMs?: number
 }
 
 export interface ActivityTrackingConfig {
-  enabled: boolean
-  trackToolCalls: boolean
-  trackLlmTurns: boolean
+	enabled: boolean
+	trackToolCalls: boolean
+	trackLlmTurns: boolean
 }
 
 export function resolveActivityTracking(
-  _permissionMode: PermissionMode,
-  explicit?: boolean,
+	_permissionMode: PermissionMode,
+	explicit?: boolean,
 ): ActivityTrackingConfig {
-  if (explicit === false) {
-    return { enabled: false, trackToolCalls: false, trackLlmTurns: false }
-  }
+	if (explicit === false) {
+		return { enabled: false, trackToolCalls: false, trackLlmTurns: false }
+	}
 
-  return { enabled: true, trackToolCalls: true, trackLlmTurns: true }
+	return { enabled: true, trackToolCalls: true, trackLlmTurns: true }
 }

package/src/types/agent/base.ts

@@ -1,8 +1,8 @@
+import type { AgentStatus, CostInfo, TokenUsage } from '../common/index.js'
 import type { RunId, ThreadId } from '../ids/index.js'
-import type { AgentStatus, TokenUsage, CostInfo } from '../common/index.js'
 import type { Message } from '../message/index.js'
-import type { StopReason } from '../run/index.js'
 import type { PermissionMode } from '../permission/index.js'
+import type { StopReason } from '../run/index.js'
 import type { TaskStore } from '../task/index.js'
 import type { ToolAvailability } from '../tool/index.js'
 
@@ -11,63 +11,63 @@ export type AgentType = 'reactive' | 'pipeline' | 'router' | 'supervisor'
 export type AgentContextLevel = 'full' | 'standard' | 'minimal'
 
 export interface BaseAgentConfig {
-  model: string
-  tokenBudget: number
-  timeoutMs: number
-  maxIterations?: number
-  temperature?: number
-  maxResponseTokens?: number
-  costLimitUsd?: number
-  permissionMode?: PermissionMode
-  env?: Record<string, string>
+	model: string
+	tokenBudget: number
+	timeoutMs: number
+	maxIterations?: number
+	temperature?: number
+	maxResponseTokens?: number
+	costLimitUsd?: number
+	permissionMode?: PermissionMode
+	env?: Record<string, string>
 
-  threadId?: ThreadId
+	threadId?: ThreadId
 
-  parentRunId?: RunId
+	parentRunId?: RunId
 
-  depth?: number
+	depth?: number
 
-  contextLevel?: AgentContextLevel
+	contextLevel?: AgentContextLevel
 }
 
 export type RuntimeToolOverrides = Record<string, ToolAvailability | 'disabled'>
 
 export interface AgentInput {
-  messages: Message[]
-  workingDirectory: string
-  signal?: AbortSignal
+	messages: Message[]
+	workingDirectory: string
+	signal?: AbortSignal
 
-  taskStore?: TaskStore
+	taskStore?: TaskStore
 
-  runtimeToolOverrides?: RuntimeToolOverrides
+	runtimeToolOverrides?: RuntimeToolOverrides
 }
 
 export interface BaseAgentResult {
-  runId: RunId
-  status: AgentStatus
-  stopReason?: StopReason
-  usage: TokenUsage
-  cost: CostInfo
-  iterations: number
-  durationMs: number
-  messages: Message[]
-  result?: string
-  lastError?: string
+	runId: RunId
+	status: AgentStatus
+	stopReason?: StopReason
+	usage: TokenUsage
+	cost: CostInfo
+	iterations: number
+	durationMs: number
+	messages: Message[]
+	result?: string
+	lastError?: string
 }
 
 export interface AgentCapabilities {
-  supportsTools: boolean
-  supportsStreaming: boolean
-  supportsConcurrency: boolean
-  supportsSubAgents: boolean
+	supportsTools: boolean
+	supportsStreaming: boolean
+	supportsConcurrency: boolean
+	supportsSubAgents: boolean
 }
 
 export interface AgentMetadata {
-  type: AgentType
-  id: string
-  name: string
-  version: string
-  category: string
-  description: string
-  capabilities: AgentCapabilities
+	type: AgentType
+	id: string
+	name: string
+	version: string
+	category: string
+	description: string
+	capabilities: AgentCapabilities
 }

package/src/types/agent/core.ts

@@ -1,26 +1,22 @@
 import type { RunEventListener } from '../run/index.js'
 import type {
-  AgentType,
-  AgentMetadata,
-  AgentCapabilities,
-  BaseAgentConfig,
-  BaseAgentResult,
-  AgentInput,
+	AgentCapabilities,
+	AgentInput,
+	AgentMetadata,
+	AgentType,
+	BaseAgentConfig,
+	BaseAgentResult,
 } from './base.js'
 
 export interface Agent<
-  TConfig extends BaseAgentConfig = BaseAgentConfig,
-  TResult extends BaseAgentResult = BaseAgentResult,
+	TConfig extends BaseAgentConfig = BaseAgentConfig,
+	TResult extends BaseAgentResult = BaseAgentResult,
 > {
-  readonly type: AgentType
-  readonly metadata: AgentMetadata
+	readonly type: AgentType
+	readonly metadata: AgentMetadata
 
-  run(
-    input: AgentInput,
-    config: TConfig,
-    listener?: RunEventListener,
-  ): Promise<TResult>
+	run(input: AgentInput, config: TConfig, listener?: RunEventListener): Promise<TResult>
 
-  cancel(): Promise<void>
-  getCapabilities(): AgentCapabilities
+	cancel(): Promise<void>
+	getCapabilities(): AgentCapabilities
 }

package/src/types/agent/factory.ts

@@ -1,46 +1,46 @@
 import type { AgentInfo } from '../../contracts/index.js'
-import type { BaseAgentConfig, BaseAgentResult, AgentContextLevel } from './base.js'
+import type { AgentContextLevel, BaseAgentConfig, BaseAgentResult } from './base.js'
 import type { Agent } from './core.js'
 
 export type { AgentContextLevel } from './base.js'
 
 export interface AgentDefinition {
-  info: AgentInfo
-  typedAgent: Agent<BaseAgentConfig, BaseAgentResult>
-  configBuilder?: (options: AgentFactoryOptions) => BaseAgentConfig | Promise<BaseAgentConfig>
+	info: AgentInfo
+	typedAgent: Agent<BaseAgentConfig, BaseAgentResult>
+	configBuilder?: (options: AgentFactoryOptions) => BaseAgentConfig | Promise<BaseAgentConfig>
 
-  contextLevel?: AgentContextLevel
+	contextLevel?: AgentContextLevel
 }
 
 export interface AgentFactoryOptions {
-  apiKey: string
-  model?: string
-  workingDirectory?: string
-  tokenBudget?: number
-  timeoutMs?: number
-  temperature?: number
-  maxResponseTokens?: number
-  env?: Record<string, string>
-  permissionMode?: 'plan' | 'auto'
+	apiKey: string
+	model?: string
+	workingDirectory?: string
+	tokenBudget?: number
+	timeoutMs?: number
+	temperature?: number
+	maxResponseTokens?: number
+	env?: Record<string, string>
+	permissionMode?: 'plan' | 'auto'
 
-  systemPrompt?: string
+	systemPrompt?: string
 
-  provider?: 'openrouter' | 'bedrock'
+	provider?: 'openrouter' | 'bedrock'
 
-  bedrockConfig?: {
-    region?: string
-    accessKeyId?: string
-    secretAccessKey?: string
-    sessionToken?: string
-  }
+	bedrockConfig?: {
+		region?: string
+		accessKeyId?: string
+		secretAccessKey?: string
+		sessionToken?: string
+	}
 
-  agentDefinitions?: AgentDefinition[]
+	agentDefinitions?: AgentDefinition[]
 
-  threadId?: string
+	threadId?: string
 
-  runId?: string
+	runId?: string
 
-  parentRunId?: string
+	parentRunId?: string
 
-  depth?: number
+	depth?: number
 }

package/src/types/agent/gateway.ts

@@ -1,38 +1,38 @@
 import type { TaskId } from '../ids/index.js'
-import type { AgentTaskState } from './task.js'
 import type { BaseAgentResult } from './base.js'
+import type { AgentTaskState } from './task.js'
 
 export interface TaskHandle {
-  readonly taskId: TaskId
-  readonly agentId: string
-  readonly state: AgentTaskState
-  readonly result?: BaseAgentResult
-  readonly createdAt: number
-  readonly completedAt?: number
+	readonly taskId: TaskId
+	readonly agentId: string
+	readonly state: AgentTaskState
+	readonly result?: BaseAgentResult
+	readonly createdAt: number
+	readonly completedAt?: number
 }
 
 export interface CreateTaskOptions {
-  agentId: string
+	agentId: string
 
-  prompt: string
+	prompt: string
 
-  workingDirectory: string
+	workingDirectory: string
 
-  configOverrides?: Record<string, unknown>
+	configOverrides?: Record<string, unknown>
 }
 
 export interface TaskGateway {
-  createTask(options: CreateTaskOptions): Promise<TaskHandle>
+	createTask(options: CreateTaskOptions): Promise<TaskHandle>
 
-  waitForTask(taskId: TaskId): Promise<TaskHandle>
+	waitForTask(taskId: TaskId): Promise<TaskHandle>
 
-  continueTask(taskId: TaskId, message: string): Promise<void>
+	continueTask(taskId: TaskId, message: string): Promise<void>
 
-  cancelTask(taskId: TaskId): void
+	cancelTask(taskId: TaskId): void
 
-  getTask(taskId: TaskId): TaskHandle | undefined
+	getTask(taskId: TaskId): TaskHandle | undefined
 
-  listTasks(): TaskHandle[]
+	listTasks(): TaskHandle[]
 
-  onTaskCompleted(callback: (handle: TaskHandle) => void): () => void
+	onTaskCompleted(callback: (handle: TaskHandle) => void): () => void
 }

package/src/types/agent/lifecycle-event.ts

@@ -1,21 +1,19 @@
-import type { TaskId } from "../ids/index.js";
-import type { BaseAgentResult } from "./base.js";
-import type { AgentTaskProgress } from "./task.js";
+import type { TaskId } from '../ids/index.js'
+import type { BaseAgentResult } from './base.js'
+import type { AgentTaskProgress } from './task.js'
 
 export type AgentLifecycleEvent =
 	| {
-			type: "pending";
-			taskId: TaskId;
-			agentId: string;
-			parentAgentId: string;
-			depth: number;
+			type: 'pending'
+			taskId: TaskId
+			agentId: string
+			parentAgentId: string
+			depth: number
 	  }
-	| { type: "running"; taskId: TaskId }
-	| { type: "progress_updated"; taskId: TaskId; progress: AgentTaskProgress }
-	| { type: "completed"; taskId: TaskId; result: BaseAgentResult }
-	| { type: "failed"; taskId: TaskId; error: string }
-	| { type: "canceled"; taskId: TaskId };
+	| { type: 'running'; taskId: TaskId }
+	| { type: 'progress_updated'; taskId: TaskId; progress: AgentTaskProgress }
+	| { type: 'completed'; taskId: TaskId; result: BaseAgentResult }
+	| { type: 'failed'; taskId: TaskId; error: string }
+	| { type: 'canceled'; taskId: TaskId }
 
-export type AgentLifecycleListener = (
-	event: AgentLifecycleEvent,
-) => void | Promise<void>;
+export type AgentLifecycleListener = (event: AgentLifecycleEvent) => void | Promise<void>

package/src/types/agent/pipeline.ts

@@ -3,39 +3,39 @@ import type { LLMProvider } from '../provider/index.js'
 import type { BaseAgentConfig, BaseAgentResult } from './base.js'
 
 export interface StepContext {
-  runId: RunId
-  stepIndex: number
-  totalSteps: number
-  previousResults: Map<string, unknown>
-  provider?: LLMProvider
-  signal?: AbortSignal
-  env: Record<string, string>
+	runId: RunId
+	stepIndex: number
+	totalSteps: number
+	previousResults: Map<string, unknown>
+	provider?: LLMProvider
+	signal?: AbortSignal
+	env: Record<string, string>
 }
 
 export interface PipelineStep<TInput = unknown, TOutput = unknown> {
-  name: string
-  description?: string
-  execute(input: TInput, context: StepContext): Promise<TOutput>
-  rollback?(input: TInput, context: StepContext): Promise<void>
-  validate?(input: TInput): boolean
+	name: string
+	description?: string
+	execute(input: TInput, context: StepContext): Promise<TOutput>
+	rollback?(input: TInput, context: StepContext): Promise<void>
+	validate?(input: TInput): boolean
 }
 
 export interface PipelineAgentConfig extends BaseAgentConfig {
-  steps: PipelineStep[]
-  provider?: LLMProvider
-  continueOnError?: boolean
+	steps: PipelineStep[]
+	provider?: LLMProvider
+	continueOnError?: boolean
 }
 
 export interface PipelineStepResult {
-  stepName: string
-  status: 'completed' | 'failed' | 'skipped'
-  output?: unknown
-  error?: string
-  durationMs: number
+	stepName: string
+	status: 'completed' | 'failed' | 'skipped'
+	output?: unknown
+	error?: string
+	durationMs: number
 }
 
 export interface PipelineAgentResult extends BaseAgentResult {
-  stepResults: PipelineStepResult[]
-  completedSteps: number
-  totalSteps: number
+	stepResults: PipelineStepResult[]
+	completedSteps: number
+	totalSteps: number
 }

package/src/types/agent/reactive.ts

@@ -1,21 +1,21 @@
-import type { BaseAgentConfig, BaseAgentResult } from './base.js'
-import type { LLMProvider } from '../provider/index.js'
 import type { ToolRegistry } from '../../registry/tool/execute.js'
 import type { AgentPersona } from '../persona/index.js'
+import type { LLMProvider } from '../provider/index.js'
 import type { Skill } from '../skills/index.js'
+import type { BaseAgentConfig, BaseAgentResult } from './base.js'
 
 export interface ReactiveAgentConfig extends BaseAgentConfig {
-  systemPrompt?: string
+	systemPrompt?: string
 
-  persona?: AgentPersona
+	persona?: AgentPersona
 
-  skills?: Skill[]
+	skills?: Skill[]
 
-  basePrompt?: string
-  provider: LLMProvider
-  tools: ToolRegistry
+	basePrompt?: string
+	provider: LLMProvider
+	tools: ToolRegistry
 }
 
 export interface ReactiveAgentResult extends BaseAgentResult {
-  toolCallCount: number
+	toolCallCount: number
 }

package/src/types/agent/router.ts

@@ -5,30 +5,30 @@ import type { Agent } from './core.js'
 export type RoutingDecisionSource = 'provider' | 'fallback' | 'hard_fail'
 
 export interface RoutingDecision {
-  agentId: string
-  confidence: number
-  reasoning?: string
-  routingSource: RoutingDecisionSource
+	agentId: string
+	confidence: number
+	reasoning?: string
+	routingSource: RoutingDecisionSource
 }
 
 export interface RouteDefinition {
-  agentId: string
-  agent: Agent<BaseAgentConfig, BaseAgentResult>
-  description: string
-  matchPatterns?: string[]
+	agentId: string
+	agent: Agent<BaseAgentConfig, BaseAgentResult>
+	description: string
+	matchPatterns?: string[]
 }
 
 export interface RouterAgentConfig extends BaseAgentConfig {
-  routes: RouteDefinition[]
-  provider: LLMProvider
-  routingPrompt?: string
-  fallbackAgentId?: string
-  minConfidence?: number
-  maxRoutingRetries?: number
+	routes: RouteDefinition[]
+	provider: LLMProvider
+	routingPrompt?: string
+	fallbackAgentId?: string
+	minConfidence?: number
+	maxRoutingRetries?: number
 }
 
 export interface RouterAgentResult extends BaseAgentResult {
-  selectedRoute: string
-  routingDecision: RoutingDecision
-  delegateResult: BaseAgentResult
+	selectedRoute: string
+	routingDecision: RoutingDecision
+	delegateResult: BaseAgentResult
 }

package/src/types/agent/supervisor.ts

@@ -1,32 +1,32 @@
+import type { AgentManager } from '../../manager/agent/lifecycle.js'
 import type { LLMProvider } from '../provider/index.js'
 import type { BaseAgentConfig, BaseAgentResult } from './base.js'
 import type { AgentFactoryOptions } from './factory.js'
 import type { TaskGateway } from './gateway.js'
-import type { AgentManager } from '../../manager/agent/lifecycle.js'
 
 export interface SupervisorAgentConfig extends BaseAgentConfig {
-  provider: LLMProvider
+	provider: LLMProvider
 
-  agentIds: string[]
+	agentIds: string[]
 
-  gateway?: TaskGateway
-  agentManager?: AgentManager
+	gateway?: TaskGateway
+	agentManager?: AgentManager
 
-  systemPrompt: string
+	systemPrompt: string
 
-  maxDepth?: number
+	maxDepth?: number
 
-  factoryOptions?: AgentFactoryOptions
+	factoryOptions?: AgentFactoryOptions
 }
 
 export interface AgentTaskResult {
-  agentId: string
-  result: BaseAgentResult
-  taskIndex: number
+	agentId: string
+	result: BaseAgentResult
+	taskIndex: number
 }
 
 export interface SupervisorAgentResult extends BaseAgentResult {
-  taskResults: AgentTaskResult[]
-  completedTasks: number
-  totalTasks: number
+	taskResults: AgentTaskResult[]
+	completedTasks: number
+	totalTasks: number
 }