@namzu/sdk 0.1.1 → 0.1.2

package/src/types/agent/task.ts

@@ -1,101 +1,92 @@
-import type { TokenUsage } from "../common/index.js";
-import type { RunId, TaskId, ThreadId } from "../ids/index.js";
-import type { Message } from "../message/index.js";
-import type { RunEventListener } from "../run/events.js";
-import type { AgentInput, BaseAgentConfig, BaseAgentResult } from "./base.js";
-import type { Agent } from "./core.js";
-import type { AgentFactoryOptions } from "./factory.js";
+import type { TokenUsage } from '../common/index.js'
+import type { RunId, TaskId, ThreadId } from '../ids/index.js'
+import type { Message } from '../message/index.js'
+import type { RunEventListener } from '../run/events.js'
+import type { AgentInput, BaseAgentConfig, BaseAgentResult } from './base.js'
+import type { Agent } from './core.js'
+import type { AgentFactoryOptions } from './factory.js'
 
 export type AgentTaskState =
-	| "pending"
-	| "running"
-	| "completed"
-	| "failed"
-	| "canceled"
-	| "rejected"
-	| "input-required";
+	| 'pending'
+	| 'running'
+	| 'completed'
+	| 'failed'
+	| 'canceled'
+	| 'rejected'
+	| 'input-required'
 
 export function isTerminalAgentTaskState(state: AgentTaskState): boolean {
-	return (
-		state === "completed" ||
-		state === "failed" ||
-		state === "canceled" ||
-		state === "rejected"
-	);
+	return state === 'completed' || state === 'failed' || state === 'canceled' || state === 'rejected'
 }
 
 export interface AgentTaskContext {
-	parentRunId: RunId;
+	parentRunId: RunId
 
-	parentAgentId: string;
+	parentAgentId: string
 
-	parentAbortController: AbortController;
+	parentAbortController: AbortController
 
-	depth: number;
+	depth: number
 
-	budgetTracker: AgentTaskBudget;
+	budgetTracker: AgentTaskBudget
 
-	factoryOptions?: AgentFactoryOptions;
+	factoryOptions?: AgentFactoryOptions
 
-	threadId?: ThreadId;
+	threadId?: ThreadId
 }
 
 export interface AgentTaskBudget {
-	total: number;
+	total: number
 
-	remaining: number;
+	remaining: number
 }
 
 export interface AgentTask {
-	taskId: TaskId;
-	agentId: string;
-	agent: Agent<BaseAgentConfig, BaseAgentResult>;
-	childAbortController: AbortController;
-	context: AgentTaskContext;
-	state: AgentTaskState;
-	result?: BaseAgentResult;
-	progress?: AgentTaskProgress;
-
-	pendingMessages: Message[];
-	createdAt: number;
-	completedAt?: number;
-
-	evictAfter?: number;
-
-	runEventListener?: RunEventListener;
+	taskId: TaskId
+	agentId: string
+	agent: Agent<BaseAgentConfig, BaseAgentResult>
+	childAbortController: AbortController
+	context: AgentTaskContext
+	state: AgentTaskState
+	result?: BaseAgentResult
+	progress?: AgentTaskProgress
+
+	pendingMessages: Message[]
+	createdAt: number
+	completedAt?: number
+
+	evictAfter?: number
+
+	runEventListener?: RunEventListener
 }
 
 export interface AgentTaskProgress {
-	toolUseCount: number;
-	usage: TokenUsage;
-	recentActivities: string[];
+	toolUseCount: number
+	usage: TokenUsage
+	recentActivities: string[]
 }
 
-export const MAX_RECENT_ACTIVITIES = 5;
+export { MAX_RECENT_ACTIVITIES } from '../../constants/agent/index.js'
 
 export interface SendMessageOptions {
-	agentId: string;
+	agentId: string
 
-	input: AgentInput;
+	input: AgentInput
 
-	configOverrides?: Partial<BaseAgentConfig>;
+	configOverrides?: Partial<BaseAgentConfig>
 
 	budgetAllocation?: {
-		tokenBudget?: number;
-		timeoutMs?: number;
-	};
+		tokenBudget?: number
+		timeoutMs?: number
+	}
 }
 
 export interface AgentManagerConfig {
-	maxDepth: number;
+	maxDepth: number
 
-	evictionMs: number;
+	evictionMs: number
 
-	maxBudgetFraction: number;
+	maxBudgetFraction: number
 }
 
-export const AGENT_MANAGER_DEFAULTS: Readonly<AgentManagerConfig> = {
-	maxDepth: 3,
-	evictionMs: 30_000,
-	maxBudgetFraction: 0.5,
-};
+export { AGENT_MANAGER_DEFAULTS } from '../../constants/agent/index.js'

package/src/types/common/index.ts

@@ -1,54 +1,39 @@
-export type AgentStatus =
-  | 'idle'
-  | 'pending'
-  | 'running'
-  | 'completed'
-  | 'failed'
-  | 'cancelled'
+export type AgentStatus = 'idle' | 'pending' | 'running' | 'completed' | 'failed' | 'cancelled'
 
 export function isTerminalStatus(status: AgentStatus): boolean {
-  return status === 'completed' || status === 'failed' || status === 'cancelled'
+	return status === 'completed' || status === 'failed' || status === 'cancelled'
 }
 
 export interface TokenUsage {
-  promptTokens: number
-  completionTokens: number
-  totalTokens: number
-  cachedTokens: number
-  cacheWriteTokens: number
+	promptTokens: number
+	completionTokens: number
+	totalTokens: number
+	cachedTokens: number
+	cacheWriteTokens: number
 }
 
-export const EMPTY_TOKEN_USAGE: TokenUsage = {
-  promptTokens: 0,
-  completionTokens: 0,
-  totalTokens: 0,
-  cachedTokens: 0,
-  cacheWriteTokens: 0,
-}
+export { EMPTY_TOKEN_USAGE } from '../../constants/limits.js'
 
-export function accumulateTokenUsage(
-  current: TokenUsage,
-  addition: TokenUsage,
-): TokenUsage {
-  return {
-    promptTokens: current.promptTokens + addition.promptTokens,
-    completionTokens: current.completionTokens + addition.completionTokens,
-    totalTokens: current.totalTokens + addition.totalTokens,
-    cachedTokens: current.cachedTokens + addition.cachedTokens,
-    cacheWriteTokens: current.cacheWriteTokens + addition.cacheWriteTokens,
-  }
+export function accumulateTokenUsage(current: TokenUsage, addition: TokenUsage): TokenUsage {
+	return {
+		promptTokens: current.promptTokens + addition.promptTokens,
+		completionTokens: current.completionTokens + addition.completionTokens,
+		totalTokens: current.totalTokens + addition.totalTokens,
+		cachedTokens: current.cachedTokens + addition.cachedTokens,
+		cacheWriteTokens: current.cacheWriteTokens + addition.cacheWriteTokens,
+	}
 }
 
 export interface CostInfo {
-  inputCostPer1M: number
-  outputCostPer1M: number
-  totalCost: number
-  cacheDiscount: number
+	inputCostPer1M: number
+	outputCostPer1M: number
+	totalCost: number
+	cacheDiscount: number
 }
 
 export interface PlatformError {
-  code: string
-  message: string
-  details?: Record<string, unknown>
-  retryable: boolean
+	code: string
+	message: string
+	details?: Record<string, unknown>
+	retryable: boolean
 }

package/src/types/connector/core.ts

@@ -6,42 +6,42 @@ export type ConnectionType = 'http' | 'webhook' | 'custom'
 export type ConnectorStatus = 'disconnected' | 'connecting' | 'connected' | 'error'
 
 export function isConnectorActive(status: ConnectorStatus): boolean {
-  return status === 'connected' || status === 'connecting'
+	return status === 'connected' || status === 'connecting'
 }
 
 export type AuthType = 'none' | 'api_key' | 'bearer' | 'basic' | 'oauth2' | 'custom'
 
 export interface AuthConfig {
-  type: AuthType
-  credentials?: Record<string, string>
+	type: AuthType
+	credentials?: Record<string, string>
 }
 
 export type ConnectorCategory =
-  | 'communication'
-  | 'data'
-  | 'development'
-  | 'productivity'
-  | 'integration'
-  | 'custom'
+	| 'communication'
+	| 'data'
+	| 'development'
+	| 'productivity'
+	| 'integration'
+	| 'custom'
 
 export interface ConnectorMethod<TInput = unknown, TOutput = unknown> {
-  name: string
-  description: string
-  inputSchema: z.ZodType<TInput, z.ZodTypeDef, unknown>
-  outputSchema?: z.ZodType<TOutput, z.ZodTypeDef, unknown>
+	name: string
+	description: string
+	inputSchema: z.ZodType<TInput, z.ZodTypeDef, unknown>
+	outputSchema?: z.ZodType<TOutput, z.ZodTypeDef, unknown>
 }
 
 export interface ConnectorTrigger {
-  name: string
-  description: string
-  event: string
-  configSchema?: z.ZodType
+	name: string
+	description: string
+	event: string
+	configSchema?: z.ZodType
 }
 
 export interface ConnectorEvent {
-  connectorId: string
-  instanceId: ConnectorInstanceId
-  trigger: string
-  payload: unknown
-  timestamp: number
+	connectorId: string
+	instanceId: ConnectorInstanceId
+	trigger: string
+	payload: unknown
+	timestamp: number
 }

package/src/types/connector/definition.ts

@@ -1,69 +1,83 @@
 import type { z } from 'zod'
 import type { ConnectorInstanceId } from '../ids/index.js'
-import type { ConnectorCategory, ConnectionType, AuthType, ConnectorMethod, ConnectorTrigger, ConnectorStatus, AuthConfig } from './core.js'
+import type {
+	AuthConfig,
+	AuthType,
+	ConnectionType,
+	ConnectorCategory,
+	ConnectorMethod,
+	ConnectorStatus,
+	ConnectorTrigger,
+} from './core.js'
 
 export interface ConnectorDefinition<TConfig = unknown> {
-  id: string
-  name: string
-  description: string
-  version?: string
-  category?: ConnectorCategory
-  connectionType: ConnectionType
-  supportedAuth?: AuthType[]
-  configSchema: z.ZodType<TConfig, z.ZodTypeDef, unknown>
-  methods: ConnectorMethod[]
-  triggers?: ConnectorTrigger[]
+	id: string
+	name: string
+	description: string
+	version?: string
+	category?: ConnectorCategory
+	connectionType: ConnectionType
+	supportedAuth?: AuthType[]
+	configSchema: z.ZodType<TConfig, z.ZodTypeDef, unknown>
+	methods: ConnectorMethod[]
+	triggers?: ConnectorTrigger[]
 }
 
 export interface ConnectorConfig {
-  connectorId: string
-  name: string
-  auth?: AuthConfig
-  options?: Record<string, unknown>
+	connectorId: string
+	name: string
+	auth?: AuthConfig
+	options?: Record<string, unknown>
 }
 
 export interface ConnectorInstance {
-  id: ConnectorInstanceId
-  connectorId: string
-  config: ConnectorConfig
-  status: ConnectorStatus
-  createdAt: number
-  connectedAt?: number
-  lastUsedAt?: number
-  error?: string
+	id: ConnectorInstanceId
+	connectorId: string
+	config: ConnectorConfig
+	status: ConnectorStatus
+	createdAt: number
+	connectedAt?: number
+	lastUsedAt?: number
+	error?: string
 }
 
 export interface ConnectorExecuteParams {
-  instanceId: ConnectorInstanceId
-  method: string
-  input: unknown
+	instanceId: ConnectorInstanceId
+	method: string
+	input: unknown
 }
 
 export interface ConnectorExecuteResult {
-  success: boolean
-  output: unknown
-  error?: string
-  durationMs: number
-  metadata?: Record<string, unknown>
+	success: boolean
+	output: unknown
+	error?: string
+	durationMs: number
+	metadata?: Record<string, unknown>
 }
 
 export interface ConnectorLifecycle<TConfig = unknown> {
-  connect(config: TConfig, auth?: AuthConfig): Promise<void>
-  disconnect(): Promise<void>
-  healthCheck(): Promise<boolean>
-  execute(method: string, input: unknown): Promise<ConnectorExecuteResult>
+	connect(config: TConfig, auth?: AuthConfig): Promise<void>
+	disconnect(): Promise<void>
+	healthCheck(): Promise<boolean>
+	execute(method: string, input: unknown): Promise<ConnectorExecuteResult>
 }
 
 export type ConnectorLifecycleEvent =
-  | { type: 'connector_registered'; connectorId: string }
-  | { type: 'connector_unregistered'; connectorId: string }
-  | { type: 'instance_created'; instanceId: ConnectorInstanceId; connectorId: string }
-  | { type: 'instance_connecting'; instanceId: ConnectorInstanceId }
-  | { type: 'instance_connected'; instanceId: ConnectorInstanceId }
-  | { type: 'instance_disconnected'; instanceId: ConnectorInstanceId }
-  | { type: 'instance_error'; instanceId: ConnectorInstanceId; error: string }
-  | { type: 'instance_removed'; instanceId: ConnectorInstanceId }
-  | { type: 'action_executing'; instanceId: ConnectorInstanceId; method: string }
-  | { type: 'action_completed'; instanceId: ConnectorInstanceId; method: string; success: boolean; durationMs: number }
+	| { type: 'connector_registered'; connectorId: string }
+	| { type: 'connector_unregistered'; connectorId: string }
+	| { type: 'instance_created'; instanceId: ConnectorInstanceId; connectorId: string }
+	| { type: 'instance_connecting'; instanceId: ConnectorInstanceId }
+	| { type: 'instance_connected'; instanceId: ConnectorInstanceId }
+	| { type: 'instance_disconnected'; instanceId: ConnectorInstanceId }
+	| { type: 'instance_error'; instanceId: ConnectorInstanceId; error: string }
+	| { type: 'instance_removed'; instanceId: ConnectorInstanceId }
+	| { type: 'action_executing'; instanceId: ConnectorInstanceId; method: string }
+	| {
+			type: 'action_completed'
+			instanceId: ConnectorInstanceId
+			method: string
+			success: boolean
+			durationMs: number
+	  }
 
 export type ConnectorEventListener = (event: ConnectorLifecycleEvent) => void

package/src/types/connector/execution-context.ts

@@ -1,51 +1,58 @@
-import type { AuthConfig } from './core.js'
 import type {
-  ExecutionEnvironment,
-  ExecutionCapability,
-  ExecutionContextBase,
-  ExecutionContextEvent,
-  ExecutionRoutingStrategy,
+	ExecutionContextBase,
+	ExecutionContextEvent,
+	ExecutionRoutingStrategy,
 } from '../execution/index.js'
+import type { AuthConfig } from './core.js'
 
-export type { ExecutionEnvironment, ExecutionCapability, ExecutionContextBase } from '../execution/index.js'
-export type { CommandOptions, CommandResult, CommandExecutor, RemoteCommandHandler } from '../execution/index.js'
+export type {
+	ExecutionEnvironment,
+	ExecutionCapability,
+	ExecutionContextBase,
+} from '../execution/index.js'
+export type {
+	CommandOptions,
+	CommandResult,
+	CommandExecutor,
+	RemoteCommandHandler,
+} from '../execution/index.js'
 export type { ExecutionRoutingStrategy, ExecutionContextLifecycle } from '../execution/index.js'
 export type { ExecutionContextEventListener } from '../execution/index.js'
 
 export interface RemoteTarget {
-  type: 'ssh' | 'rdp' | 'api'
-  host: string
-  port?: number
-  auth?: AuthConfig
-  metadata?: Record<string, unknown>
+	type: 'ssh' | 'rdp' | 'api'
+	host: string
+	port?: number
+	auth?: AuthConfig
+	metadata?: Record<string, unknown>
 }
 
 export interface LocalExecutionContextConfig extends ExecutionContextBase {
-  environment: 'local'
-  cwd: string
-  fsAccess: boolean
-  envVars?: Record<string, string>
-  shell?: string
+	environment: 'local'
+	cwd: string
+	fsAccess: boolean
+	envVars?: Record<string, string>
+	shell?: string
 }
 
 export interface RemoteExecutionContextConfig extends ExecutionContextBase {
-  environment: 'remote'
-  target: RemoteTarget
+	environment: 'remote'
+	target: RemoteTarget
 }
 
 export interface HybridExecutionContextConfig extends ExecutionContextBase {
-  environment: 'hybrid'
-  local: Omit<LocalExecutionContextConfig, 'id' | 'environment'>
-  remotes: RemoteTarget[]
-  routingStrategy?: ExecutionRoutingStrategy
+	environment: 'hybrid'
+	local: Omit<LocalExecutionContextConfig, 'id' | 'environment'>
+	remotes: RemoteTarget[]
+	routingStrategy?: ExecutionRoutingStrategy
 }
 
 export type ExecutionContextConfig =
-  | LocalExecutionContextConfig
-  | RemoteExecutionContextConfig
-  | HybridExecutionContextConfig
+	| LocalExecutionContextConfig
+	| RemoteExecutionContextConfig
+	| HybridExecutionContextConfig
 
 export type ConnectorExecutionContextEvent =
-  | ExecutionContextEvent
-  | { type: 'remote_connected'; contextId: string; target: RemoteTarget }
-  | { type: 'remote_disconnected'; contextId: string; host: string }
+	| ExecutionContextEvent
+	| { type: 'remote_connected'; contextId: string; target: RemoteTarget }
+	| { type: 'remote_disconnected'; contextId: string; host: string }

package/src/types/connector/http.ts

@@ -1,22 +1,22 @@
 export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD'
 
 export interface HttpConnectorConfig {
-  baseUrl: string
-  defaultHeaders?: Record<string, string>
-  timeoutMs?: number
+	baseUrl: string
+	defaultHeaders?: Record<string, string>
+	timeoutMs?: number
 }
 
 export interface HttpRequestInput {
-  method: HttpMethod
-  path: string
-  headers?: Record<string, string>
-  query?: Record<string, string>
-  body?: unknown
+	method: HttpMethod
+	path: string
+	headers?: Record<string, string>
+	query?: Record<string, string>
+	body?: unknown
 }
 
 export interface HttpResponseOutput {
-  status: number
-  statusText: string
-  headers: Record<string, string>
-  body: unknown
+	status: number
+	statusText: string
+	headers: Record<string, string>
+	body: unknown
 }