kode-sdk 2.7.0

package/dist/core/todo.d.ts

@@ -0,0 +1,34 @@
+import { Store } from '../infra/store';
+export type TodoStatus = 'pending' | 'in_progress' | 'completed';
+export interface TodoItem {
+    id: string;
+    title: string;
+    status: TodoStatus;
+    assignee?: string;
+    notes?: string;
+    createdAt: number;
+    updatedAt: number;
+}
+export interface TodoSnapshot {
+    todos: TodoItem[];
+    version: number;
+    updatedAt: number;
+}
+export type TodoInput = Omit<TodoItem, 'createdAt' | 'updatedAt'> & {
+    createdAt?: number;
+    updatedAt?: number;
+};
+export declare class TodoService {
+    private readonly store;
+    private readonly agentId;
+    private snapshot;
+    constructor(store: Store, agentId: string);
+    load(): Promise<void>;
+    list(): TodoItem[];
+    setTodos(todos: TodoInput[]): Promise<void>;
+    update(todo: TodoInput): Promise<void>;
+    delete(id: string): Promise<void>;
+    private validateTodos;
+    private persist;
+    private normalize;
+}

package/dist/core/todo.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TodoService = void 0;
+const MAX_IN_PROGRESS = 1;
+class TodoService {
+    constructor(store, agentId) {
+        this.store = store;
+        this.agentId = agentId;
+        this.snapshot = { todos: [], version: 1, updatedAt: Date.now() };
+    }
+    async load() {
+        const existing = await this.store.loadTodos?.(this.agentId);
+        if (existing) {
+            this.snapshot = existing;
+        }
+    }
+    list() {
+        return [...this.snapshot.todos];
+    }
+    async setTodos(todos) {
+        const normalized = todos.map((todo) => this.normalize(todo));
+        this.validateTodos(normalized);
+        this.snapshot = {
+            todos: normalized.map((todo) => ({ ...todo, updatedAt: Date.now() })),
+            version: this.snapshot.version + 1,
+            updatedAt: Date.now(),
+        };
+        await this.persist();
+    }
+    async update(todo) {
+        const existing = this.snapshot.todos.find((t) => t.id === todo.id);
+        if (!existing) {
+            throw new Error(`Todo not found: ${todo.id}`);
+        }
+        const normalized = this.normalize({ ...existing, ...todo });
+        const updated = { ...existing, ...normalized, updatedAt: Date.now() };
+        const next = this.snapshot.todos.map((t) => (t.id === todo.id ? updated : t));
+        this.validateTodos(next);
+        this.snapshot.todos = next;
+        this.snapshot.version += 1;
+        this.snapshot.updatedAt = Date.now();
+        await this.persist();
+    }
+    async delete(id) {
+        const next = this.snapshot.todos.filter((t) => t.id !== id);
+        this.snapshot.todos = next;
+        this.snapshot.version += 1;
+        this.snapshot.updatedAt = Date.now();
+        await this.persist();
+    }
+    validateTodos(todos) {
+        const ids = new Set();
+        let inProgress = 0;
+        for (const todo of todos) {
+            if (!todo.id)
+                throw new Error('Todo id is required');
+            if (ids.has(todo.id)) {
+                throw new Error(`Duplicate todo id: ${todo.id}`);
+            }
+            ids.add(todo.id);
+            if (todo.status === 'in_progress')
+                inProgress += 1;
+            if (!todo.title?.trim()) {
+                throw new Error(`Todo ${todo.id} must have a title`);
+            }
+        }
+        if (inProgress > MAX_IN_PROGRESS) {
+            throw new Error('Only one todo can be in progress');
+        }
+    }
+    async persist() {
+        if (!this.store.saveTodos)
+            return;
+        await this.store.saveTodos(this.agentId, this.snapshot);
+    }
+    normalize(todo) {
+        const now = Date.now();
+        return {
+            id: todo.id,
+            title: todo.title,
+            status: todo.status,
+            assignee: todo.assignee,
+            notes: todo.notes,
+            createdAt: todo.createdAt ?? now,
+            updatedAt: todo.updatedAt ?? now,
+        };
+    }
+}
+exports.TodoService = TodoService;

package/dist/core/types.d.ts

@@ -0,0 +1,380 @@
+export type MessageRole = 'user' | 'assistant' | 'system';
+export type ContentBlock = {
+    type: 'text';
+    text: string;
+} | {
+    type: 'tool_use';
+    id: string;
+    name: string;
+    input: any;
+} | {
+    type: 'tool_result';
+    tool_use_id: string;
+    content: any;
+    is_error?: boolean;
+};
+export interface Message {
+    role: MessageRole;
+    content: ContentBlock[];
+}
+export interface Bookmark {
+    seq: number;
+    timestamp: number;
+}
+export type AgentChannel = 'progress' | 'control' | 'monitor';
+export type AgentRuntimeState = 'READY' | 'WORKING' | 'PAUSED';
+export type BreakpointState = 'READY' | 'PRE_MODEL' | 'STREAMING_MODEL' | 'TOOL_PENDING' | 'AWAITING_APPROVAL' | 'PRE_TOOL' | 'TOOL_EXECUTING' | 'POST_TOOL';
+export type ToolCallState = 'PENDING' | 'APPROVAL_REQUIRED' | 'APPROVED' | 'EXECUTING' | 'COMPLETED' | 'FAILED' | 'DENIED' | 'SEALED';
+export interface ToolCallApproval {
+    required: boolean;
+    decision?: 'allow' | 'deny';
+    decidedBy?: string;
+    decidedAt?: number;
+    note?: string;
+    meta?: Record<string, any>;
+}
+export interface ToolCallAuditEntry {
+    state: ToolCallState;
+    timestamp: number;
+    note?: string;
+}
+export interface ToolCallRecord {
+    id: string;
+    name: string;
+    input: any;
+    state: ToolCallState;
+    approval: ToolCallApproval;
+    result?: any;
+    error?: string;
+    isError?: boolean;
+    startedAt?: number;
+    completedAt?: number;
+    durationMs?: number;
+    createdAt: number;
+    updatedAt: number;
+    auditTrail: ToolCallAuditEntry[];
+}
+export type ToolCallSnapshot = Pick<ToolCallRecord, 'id' | 'name' | 'state' | 'approval' | 'result' | 'error' | 'isError' | 'durationMs' | 'startedAt' | 'completedAt'> & {
+    inputPreview?: any;
+    auditTrail?: ToolCallAuditEntry[];
+};
+export interface ProgressThinkChunkStartEvent {
+    channel: 'progress';
+    type: 'think_chunk_start';
+    step: number;
+    bookmark?: Bookmark;
+}
+export interface ProgressThinkChunkEvent {
+    channel: 'progress';
+    type: 'think_chunk';
+    step: number;
+    delta: string;
+    bookmark?: Bookmark;
+}
+export interface ProgressThinkChunkEndEvent {
+    channel: 'progress';
+    type: 'think_chunk_end';
+    step: number;
+    bookmark?: Bookmark;
+}
+export interface ProgressTextChunkStartEvent {
+    channel: 'progress';
+    type: 'text_chunk_start';
+    step: number;
+    bookmark?: Bookmark;
+}
+export interface ProgressTextChunkEvent {
+    channel: 'progress';
+    type: 'text_chunk';
+    step: number;
+    delta: string;
+    bookmark?: Bookmark;
+}
+export interface ProgressTextChunkEndEvent {
+    channel: 'progress';
+    type: 'text_chunk_end';
+    step: number;
+    text: string;
+    bookmark?: Bookmark;
+}
+export interface ProgressToolStartEvent {
+    channel: 'progress';
+    type: 'tool:start';
+    call: ToolCallSnapshot;
+    bookmark?: Bookmark;
+}
+export interface ProgressToolEndEvent {
+    channel: 'progress';
+    type: 'tool:end';
+    call: ToolCallSnapshot;
+    bookmark?: Bookmark;
+}
+export interface ProgressToolErrorEvent {
+    channel: 'progress';
+    type: 'tool:error';
+    call: ToolCallSnapshot;
+    error: string;
+    bookmark?: Bookmark;
+}
+export interface ProgressDoneEvent {
+    channel: 'progress';
+    type: 'done';
+    step: number;
+    reason: 'completed' | 'interrupted';
+    bookmark?: Bookmark;
+}
+export type ProgressEvent = ProgressThinkChunkStartEvent | ProgressThinkChunkEvent | ProgressThinkChunkEndEvent | ProgressTextChunkStartEvent | ProgressTextChunkEvent | ProgressTextChunkEndEvent | ProgressToolStartEvent | ProgressToolEndEvent | ProgressToolErrorEvent | ProgressDoneEvent;
+export interface ControlPermissionRequiredEvent {
+    channel: 'control';
+    type: 'permission_required';
+    call: ToolCallSnapshot;
+    respond(decision: 'allow' | 'deny', opts?: {
+        note?: string;
+    }): Promise<void>;
+    bookmark?: Bookmark;
+}
+export interface ControlPermissionDecidedEvent {
+    channel: 'control';
+    type: 'permission_decided';
+    callId: string;
+    decision: 'allow' | 'deny';
+    decidedBy: string;
+    note?: string;
+    bookmark?: Bookmark;
+}
+export type ControlEvent = ControlPermissionRequiredEvent | ControlPermissionDecidedEvent;
+export interface MonitorStateChangedEvent {
+    channel: 'monitor';
+    type: 'state_changed';
+    state: AgentRuntimeState;
+    bookmark?: Bookmark;
+}
+export interface MonitorStepCompleteEvent {
+    channel: 'monitor';
+    type: 'step_complete';
+    step: number;
+    durationMs?: number;
+    bookmark: Bookmark;
+}
+export interface MonitorErrorEvent {
+    channel: 'monitor';
+    type: 'error';
+    severity: 'info' | 'warn' | 'error';
+    phase: 'model' | 'tool' | 'system' | 'lifecycle';
+    message: string;
+    detail?: any;
+    bookmark?: Bookmark;
+}
+export interface MonitorTokenUsageEvent {
+    channel: 'monitor';
+    type: 'token_usage';
+    inputTokens: number;
+    outputTokens: number;
+    totalTokens: number;
+    bookmark?: Bookmark;
+}
+export interface MonitorToolExecutedEvent {
+    channel: 'monitor';
+    type: 'tool_executed';
+    call: ToolCallSnapshot;
+    bookmark?: Bookmark;
+}
+export interface MonitorAgentResumedEvent {
+    channel: 'monitor';
+    type: 'agent_resumed';
+    strategy: 'crash' | 'manual';
+    sealed: ToolCallSnapshot[];
+    bookmark?: Bookmark;
+}
+export interface MonitorBreakpointChangedEvent {
+    channel: 'monitor';
+    type: 'breakpoint_changed';
+    previous: BreakpointState;
+    current: BreakpointState;
+    timestamp: number;
+    bookmark?: Bookmark;
+}
+export interface MonitorTodoChangedEvent {
+    channel: 'monitor';
+    type: 'todo_changed';
+    current: import('./todo').TodoItem[];
+    previous: import('./todo').TodoItem[];
+    bookmark?: Bookmark;
+}
+export interface MonitorTodoReminderEvent {
+    channel: 'monitor';
+    type: 'todo_reminder';
+    todos: import('./todo').TodoItem[];
+    reason: string;
+    bookmark?: Bookmark;
+}
+export interface MonitorFileChangedEvent {
+    channel: 'monitor';
+    type: 'file_changed';
+    path: string;
+    mtime: number;
+    bookmark?: Bookmark;
+}
+export interface MonitorReminderSentEvent {
+    channel: 'monitor';
+    type: 'reminder_sent';
+    category: 'file' | 'todo' | 'security' | 'performance' | 'general';
+    content: string;
+    bookmark?: Bookmark;
+}
+export interface MonitorContextCompressionEvent {
+    channel: 'monitor';
+    type: 'context_compression';
+    /** 压缩阶段：start（开始）、summarizing（生成摘要中）、end（完成）、fallback（降级） */
+    phase: 'start' | 'summarizing' | 'end' | 'fallback';
+    /** 使用的压缩算法 */
+    algorithm?: 'simple' | 'ai';
+    /** 生成的摘要内容 */
+    summary?: string;
+    /** 压缩比例（保留消息数/总消息数） */
+    ratio?: number;
+    /** 压缩掉的 token 数（估算） */
+    tokensRemoved?: number;
+    /** 保留的 token 数（估算） */
+    tokensRetained?: number;
+    /** 降级时的错误信息 */
+    error?: string;
+    bookmark?: Bookmark;
+}
+export interface MonitorSchedulerTriggeredEvent {
+    channel: 'monitor';
+    type: 'scheduler_triggered';
+    taskId: string;
+    spec: string;
+    kind: 'steps' | 'time' | 'cron';
+    triggeredAt: number;
+    bookmark?: Bookmark;
+}
+export interface MonitorToolManualUpdatedEvent {
+    channel: 'monitor';
+    type: 'tool_manual_updated';
+    tools: string[];
+    timestamp: number;
+    bookmark?: Bookmark;
+}
+export interface MonitorToolCustomEvent {
+    channel: 'monitor';
+    type: 'tool_custom_event';
+    toolName: string;
+    eventType: string;
+    data?: any;
+    timestamp: number;
+    bookmark?: Bookmark;
+}
+export interface MonitorSkillDiscoveredEvent {
+    channel: 'monitor';
+    type: 'skill_discovered';
+    skills: string[];
+    timestamp: number;
+    bookmark?: Bookmark;
+}
+export interface MonitorSkillActivatedEvent {
+    channel: 'monitor';
+    type: 'skill_activated';
+    /** 单个 skill 名称或多个 skill 名称（逗号分隔） */
+    skill: string;
+    activatedBy: 'auto' | 'agent' | 'user';
+    timestamp: number;
+    bookmark?: Bookmark;
+}
+export interface MonitorSkillDeactivatedEvent {
+    channel: 'monitor';
+    type: 'skill_deactivated';
+    name: string;
+    timestamp: number;
+    bookmark?: Bookmark;
+}
+export type MonitorEvent = MonitorStateChangedEvent | MonitorStepCompleteEvent | MonitorErrorEvent | MonitorTokenUsageEvent | MonitorToolExecutedEvent | MonitorAgentResumedEvent | MonitorTodoChangedEvent | MonitorTodoReminderEvent | MonitorFileChangedEvent | MonitorReminderSentEvent | MonitorContextCompressionEvent | MonitorSchedulerTriggeredEvent | MonitorBreakpointChangedEvent | MonitorToolManualUpdatedEvent | MonitorToolCustomEvent | MonitorSkillDiscoveredEvent | MonitorSkillActivatedEvent | MonitorSkillDeactivatedEvent;
+export type AgentEvent = ProgressEvent | ControlEvent | MonitorEvent;
+export interface AgentEventEnvelope<T extends AgentEvent = AgentEvent> {
+    cursor: number;
+    bookmark: Bookmark;
+    event: T;
+}
+export interface Timeline {
+    cursor: number;
+    bookmark: Bookmark;
+    event: AgentEvent;
+}
+export type SnapshotId = string;
+export interface Snapshot {
+    id: SnapshotId;
+    messages: Message[];
+    lastSfpIndex: number;
+    lastBookmark: Bookmark;
+    createdAt: string;
+    metadata?: Record<string, any>;
+}
+export interface AgentStatus {
+    agentId: string;
+    state: AgentRuntimeState;
+    stepCount: number;
+    lastSfpIndex: number;
+    lastBookmark?: Bookmark;
+    cursor: number;
+    breakpoint: BreakpointState;
+}
+export interface AgentInfo {
+    agentId: string;
+    templateId: string;
+    createdAt: string;
+    lineage: string[];
+    configVersion: string;
+    messageCount: number;
+    lastSfpIndex: number;
+    lastBookmark?: Bookmark;
+    breakpoint?: BreakpointState;
+    metadata?: Record<string, any>;
+}
+export interface ReminderOptions {
+    skipStandardEnding?: boolean;
+    priority?: 'low' | 'medium' | 'high';
+    category?: 'file' | 'todo' | 'security' | 'performance' | 'general';
+    /** 是否持久化（用于 Skills 等需要在整个对话中保持的内容） */
+    persistent?: boolean;
+    /** 标签（用于去重和识别） */
+    label?: string;
+}
+export type ResumeStrategy = 'crash' | 'manual';
+export interface ToolOutcome {
+    id: string;
+    name: string;
+    ok: boolean;
+    content: any;
+    durationMs?: number;
+}
+export interface ToolCall {
+    id: string;
+    name: string;
+    args: any;
+    agentId: string;
+}
+export type HookDecision = {
+    decision: 'ask';
+    meta?: any;
+} | {
+    decision: 'deny';
+    reason?: string;
+    toolResult?: any;
+} | {
+    result: any;
+} | void;
+export type PostHookResult = void | {
+    update: Partial<ToolOutcome>;
+} | {
+    replace: ToolOutcome;
+};
+export interface ToolContext {
+    agentId: string;
+    callId?: string;
+    sandbox: import('../infra/sandbox').Sandbox;
+    agent: any;
+    services?: Record<string, any>;
+    signal?: AbortSignal;
+    emit?: (eventType: string, data?: any) => void;
+}

package/dist/core/types.js

@@ -0,0 +1,3 @@
+"use strict";
+// Core type definitions for KODE SDK v2.7
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/index.d.ts

@@ -0,0 +1,51 @@
+export { Agent, AgentConfig, AgentDependencies, CompleteResult, StreamOptions, SubscribeOptions, SendOptions, } from './core/agent';
+export { AgentPool } from './core/pool';
+export { Room } from './core/room';
+export { Scheduler, AgentSchedulerHandle } from './core/scheduler';
+export { EventBus } from './core/events';
+export { HookManager, Hooks } from './core/hooks';
+export { ContextManager, ContextManagerOptions, ContextUsage, CompressionResult } from './core/context-manager';
+export { FilePool } from './core/file-pool';
+export { ICompressionStrategy, CompressionEventEmitter, CompressionEventPayload, SimpleCompressionStrategy, AICompressionStrategy, SimpleCompressionStrategyOptions, AICompressionStrategyOptions, estimateTotalTokens, estimateMessageTokens, } from './core/compression';
+export { AgentTemplateRegistry, AgentTemplateDefinition, PermissionConfig, SubAgentConfig, TodoConfig, TemplateRuntimeConfig, TemplateSkillsConfig, } from './core/template';
+export { TodoService, TodoItem, TodoSnapshot } from './core/todo';
+export { TimeBridge } from './core/time-bridge';
+export { BreakpointManager } from './core/agent/breakpoint-manager';
+export { PermissionManager } from './core/agent/permission-manager';
+export { MessageQueue } from './core/agent/message-queue';
+export { TodoManager } from './core/agent/todo-manager';
+export { ToolRunner } from './core/agent/tool-runner';
+export { permissionModes, PermissionModeRegistry, PermissionModeHandler, PermissionEvaluationContext, PermissionDecision, } from './core/permission-modes';
+export { Checkpointer, Checkpoint, CheckpointMetadata, AgentState, MemoryCheckpointer, } from './core/checkpointer';
+export { FileCheckpointer, RedisCheckpointer } from './core/checkpointers';
+export * from './core/types';
+export { ResumeError, ResumeErrorCode } from './core/errors';
+export { Store, JSONStore } from './infra/store';
+export { Sandbox, LocalSandbox, SandboxKind } from './infra/sandbox';
+export { ModelProvider, ModelConfig, ModelResponse, ModelStreamChunk, AnthropicRetryConfig, AnthropicProviderOptions, AnthropicProvider, } from './infra/provider';
+export { SandboxFactory } from './infra/sandbox-factory';
+export { FsRead } from './tools/fs_read';
+export { FsWrite } from './tools/fs_write';
+export { FsEdit } from './tools/fs_edit';
+export { FsGlob } from './tools/fs_glob';
+export { FsGrep } from './tools/fs_grep';
+export { FsMultiEdit } from './tools/fs_multi_edit';
+export { FsRm } from './tools/fs_rm';
+export { BashRun } from './tools/bash_run';
+export { BashLogs } from './tools/bash_logs';
+export { BashKill } from './tools/bash_kill';
+export { createTaskRunTool, AgentTemplate } from './tools/task_run';
+export { TodoRead } from './tools/todo_read';
+export { TodoWrite } from './tools/todo_write';
+export { SkillList } from './tools/skill_list';
+export { SkillActivate } from './tools/skill_activate';
+export { SkillResource } from './tools/skill_resource';
+export { builtin } from './tools/builtin';
+export { ToolInstance, ToolDescriptor, ToolRegistry, globalToolRegistry } from './tools/registry';
+export { defineTool, defineTools, extractTools, ToolAttributes, ParamDef, SimpleToolDef, } from './tools/define';
+export { tool, tools, ToolDefinition, EnhancedToolContext } from './tools/tool';
+export { getMCPTools, disconnectMCP, disconnectAllMCP, MCPConfig, MCPTransportType } from './tools/mcp';
+export { ToolKit, toolMethod } from './tools/toolkit';
+export { inferFromExample, schema, patterns, SchemaBuilder, mergeSchemas, extendSchema, } from './tools/type-inference';
+export { SkillsParser, SkillsValidator, SkillsLoader, SkillsManager, SkillsInjector, SkillMetadata, Skill, SkillsConfig, SkillsState, SkillResources, SkillActivation, SkillParseResult, SkillValidationResult, } from './skills';
+export { generateAgentId } from './utils/agent-id';