nanobot-agent-sdk 0.1.0

package/README.md

@@ -0,0 +1,164 @@
+# nanobot-agent-sdk
+
+一个可长期运行、可调度、可审批、可接 MCP 的**纯 Agent SDK 内核**。
+
+> 说明：
+> - 这个仓库不是酒店运营产品。
+> - 酒店运营只是当前最早的参考场景之一。
+> - 内核保持领域无关，你可以在外层包任意业务壳。
+
+## 它是什么
+
+它是一个纯 SDK，不做这些事情：
+
+- 不做登录
+- 不做账号体系
+- 不做 Web 客户端壳
+- 不做审批 UI
+- 不做企业后台
+- 不把某个行业的业务规则硬编码进内核
+
+它专注做这些核心能力：
+
+- Agent loop
+- Tools runtime
+- Skills
+- MCP 接入
+- Background tasks
+- Scheduler / Cron
+- Daily memory
+- Brief / 事件流
+- Human-in-the-loop approval
+- Policy / guardrails
+- Session persistence
+
+## 适合怎么用
+
+你可以把它当成真正的“内核层”，外部再包：
+
+- 酒店 OTA 运营机器人
+- 内容运营机器人
+- CRM / 销售助理
+- 报表巡检机器人
+- 企业内部自动化 agent
+- 任意需要 Python MCP、Web 后台、IM 入口、审批台的 agent 产品
+
+## 设计原则
+
+1. **纯内核**：业务通过 MCP / 宿主注入
+2. **长期运行**：不只是一问一答
+3. **可恢复**：任务、schedule、session 都可持久化
+4. **可观察**：brief、notification、task event 全都往外发
+5. **可控**：policy + approval 控制高风险动作
+6. **可扩展**：skills、custom tools、MCP tools 都是一等公民
+
+## 当前已实现
+
+- `Agent` / `createAgent()`
+- Anthropic 驱动的 `QueryEngine`
+- 内置工具注册与 preset
+- 文件读写 / 搜索 / Bash / Brief
+- 后台任务运行时
+- 定时任务运行时
+- Daily memory
+- Approval manager
+- Session 持久化
+- Skills loader + Skill tool
+- MCP client bridge
+
+## 快速开始
+
+```ts
+import { createAgent } from 'nanobot-agent-sdk'
+
+const agent = await createAgent({
+  model: 'claude-sonnet-4-20250514',
+  assistant: {
+    enabled: true,
+    id: 'main-agent',
+    name: 'Main Agent',
+    proactive: true,
+    brief: true,
+  },
+  tools: { type: 'preset', preset: 'operations' },
+  remoteApproval: {
+    enabled: true,
+    defaultDecision: 'deny',
+  },
+  onEvent(event) {
+    console.log('[event]', event)
+  },
+})
+
+const result = await agent.run('Read the workspace context and tell me what this project does.')
+console.log(result.text)
+```
+
+## 接 Python MCP
+
+如果你已经有 Python 脚本，可以把它们暴露成 MCP server，然后直接交给 SDK 调用。
+
+```ts
+import { createAgent } from 'nanobot-agent-sdk'
+
+const agent = await createAgent({
+  assistant: true,
+  tools: { type: 'preset', preset: 'operations' },
+  mcpServers: {
+    hotelOps: {
+      type: 'stdio',
+      command: '/usr/local/bin/python3.9',
+      args: ['/path/to/your/mcp_server.py'],
+      env: {
+        PYTHONUNBUFFERED: '1',
+      },
+    },
+  },
+})
+```
+
+这样 SDK 内核负责：
+
+- reasoning
+- tool orchestration
+- approval
+- background tasks
+- scheduling
+- memory
+
+你的 Python 负责：
+
+- 开关房
+- 调价
+- 查订单
+- 查库存
+- 任意行业业务动作
+
+## 重要边界
+
+### SDK 内核负责
+- agent loop
+- runtime
+- tools
+- skills
+- MCP bridge
+- policy / approval
+- persistence
+
+### 业务宿主负责
+- 行业业务规则
+- 后台管理台
+- 审批页面
+- IM / Web 接入
+- 用户体系
+- 数据库与配置中心
+
+## 文档
+
+- `docs/architecture.md`
+- `docs/business-requirements.md`
+- `docs/python-mcp-integration.md`
+
+## 当前状态
+
+现在已经可以作为一个干净的纯 SDK 地基继续往上开发。

package/dist/core/agent.d.ts

@@ -0,0 +1,60 @@
+import type { AgentOptions, ApprovalDecision, QueryResult, RuntimeTask, SDKMessage, ScheduledTask } from '../types.js';
+export declare class Agent {
+    private readonly baseOptions;
+    private readonly cwd;
+    private readonly sessionId;
+    private readonly history;
+    private readonly setupPromise;
+    private readonly mcpConnections;
+    private readonly skillRegistry;
+    private model;
+    private policy;
+    private assistantOptions?;
+    private assistant?;
+    private memoryRuntime?;
+    private taskRuntime;
+    private scheduler;
+    private approvalManager?;
+    private baseTools;
+    private loadedSkills;
+    private skillTool?;
+    private closed;
+    constructor(options?: AgentOptions);
+    ready(): Promise<this>;
+    query(prompt: string, overrides?: Partial<AgentOptions>): AsyncGenerator<SDKMessage, QueryResult>;
+    run(prompt: string, overrides?: Partial<AgentOptions>): Promise<QueryResult>;
+    runBackgroundPrompt(prompt: string, options: {
+        subject: string;
+        description?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<RuntimeTask>;
+    listTasks(): Promise<RuntimeTask[]>;
+    getTask(id: string): Promise<RuntimeTask | undefined>;
+    getTaskOutput(id: string, maxChars?: number): Promise<string>;
+    stopTask(id: string, reason?: string): Promise<boolean>;
+    listSchedules(): Promise<ScheduledTask[]>;
+    createSchedule(input: {
+        name: string;
+        schedule: string;
+        prompt: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<ScheduledTask>;
+    runScheduleNow(id: string): Promise<boolean>;
+    deleteSchedule(id: string): Promise<boolean>;
+    listPendingApprovals(): import("../types.js").PermissionRequest[];
+    resolveApproval(requestId: string, result: ApprovalDecision): Promise<boolean>;
+    listSkills(): import("../skills/types.js").SkillDefinition[];
+    close(): Promise<void>;
+    private setup;
+    private buildBaseTools;
+    private connectMcpServers;
+    private mergeOptions;
+    private resolveTools;
+    private resolveSystemPrompt;
+    private buildCanUseTool;
+    private handleScheduledTask;
+    private emitEvent;
+    private ensureOpen;
+}
+export declare function createAgent(options?: AgentOptions): Promise<Agent>;
+//# sourceMappingURL=agent.d.ts.map

package/dist/core/agent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../../src/core/agent.ts"],"names":[],"mappings":"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"}

package/dist/core/agent.js

@@ -0,0 +1,438 @@
+import { randomUUID } from 'crypto';
+import { resolve } from 'path';
+import { QueryEngine } from './engine.js';
+import { buildSystemPrompt } from './system-prompt.js';
+import { connectMCPServer, closeAllConnections } from '../mcp/client.js';
+import { EventedApprovalManager } from '../runtime/approval.js';
+import { createAssistantContext, resolveAssistantOptions } from '../runtime/assistant.js';
+import { DailyMemoryRuntime } from '../runtime/memory.js';
+import { ensureRuntimePaths } from '../runtime/paths.js';
+import { applyPolicyToTools, resolvePolicy } from '../runtime/policy.js';
+import { FileSchedulerRuntime } from '../runtime/scheduler.js';
+import { loadSession, saveSession } from '../runtime/session.js';
+import { FileTaskRuntime } from '../runtime/task-runtime.js';
+import { createSkillRegistry } from '../skills/loader.js';
+import { createSkillTool } from '../skills/tool.js';
+import { dedupeTools, filterTools, getAllBaseTools, getToolPreset } from '../tools/index.js';
+const DEFAULT_MODEL = 'claude-sonnet-4-20250514';
+export class Agent {
+    baseOptions;
+    cwd;
+    sessionId;
+    history = [];
+    setupPromise;
+    mcpConnections = [];
+    skillRegistry = createSkillRegistry();
+    model;
+    policy;
+    assistantOptions;
+    assistant;
+    memoryRuntime;
+    taskRuntime;
+    scheduler;
+    approvalManager;
+    baseTools = [];
+    loadedSkills = [];
+    skillTool;
+    closed = false;
+    constructor(options = {}) {
+        this.baseOptions = { ...options };
+        this.cwd = resolve(options.cwd || process.cwd());
+        this.sessionId = options.sessionId || options.resume || randomUUID();
+        this.model = options.model || DEFAULT_MODEL;
+        this.setupPromise = this.setup();
+    }
+    async ready() {
+        await this.setupPromise;
+        return this;
+    }
+    async *query(prompt, overrides = {}) {
+        await this.setupPromise;
+        this.ensureOpen();
+        const merged = this.mergeOptions(overrides);
+        const tools = this.resolveTools(merged);
+        const systemPrompt = await this.resolveSystemPrompt(merged, tools);
+        const canUseTool = this.buildCanUseTool(merged);
+        if (this.assistant && this.memoryRuntime) {
+            await this.memoryRuntime.appendDaily({
+                category: 'user',
+                message: summarizePrompt(prompt),
+            }).catch(() => { });
+        }
+        const initEvent = {
+            type: 'system',
+            subtype: 'init',
+            session_id: this.sessionId,
+            tools: tools.map((tool) => tool.name),
+            model: this.model,
+            cwd: this.cwd,
+            mcp_servers: this.mcpConnections.map((connection) => ({ name: connection.name, status: connection.status })),
+            permission_mode: merged.permissionMode || 'default',
+        };
+        await this.emitEvent(initEvent, merged);
+        yield initEvent;
+        const engine = new QueryEngine({
+            cwd: this.cwd,
+            model: this.model,
+            apiKey: merged.apiKey,
+            baseURL: merged.baseURL,
+            tools,
+            systemPrompt,
+            maxTurns: merged.maxTurns || 12,
+            maxBudgetUsd: merged.maxBudgetUsd,
+            maxTokens: merged.maxTokens || 4096,
+            thinking: merged.thinking,
+            estimateCostUsd: merged.estimateCostUsd || defaultEstimateCostUsd,
+            jsonSchema: merged.jsonSchema,
+            canUseTool,
+            includePartialMessages: merged.includePartialMessages ?? true,
+            abortSignal: merged.abortSignal || merged.abortController?.signal || this.baseOptions.abortSignal || this.baseOptions.abortController?.signal,
+            sessionId: this.sessionId,
+            onEvent: (event) => this.emitEvent(event, merged),
+            taskRuntime: this.taskRuntime,
+            scheduler: this.scheduler,
+            approvalManager: this.approvalManager,
+            memoryRuntime: this.memoryRuntime,
+            assistant: this.assistant,
+            initialMessages: [...this.history],
+            startBackgroundAgentTask: (input) => this.runBackgroundPrompt(input.prompt, {
+                subject: input.subject,
+                description: input.description,
+                metadata: input.metadata,
+            }),
+        });
+        const iterator = engine.submit(prompt);
+        try {
+            while (true) {
+                const next = await iterator.next();
+                if (next.done) {
+                    this.history.splice(0, this.history.length, ...engine.messages);
+                    if (shouldPersistSession(merged)) {
+                        await saveSession(this.sessionId, this.history, {
+                            cwd: this.cwd,
+                            model: this.model,
+                            summary: summarizePrompt(prompt),
+                        }).catch(() => { });
+                    }
+                    return next.value;
+                }
+                yield next.value;
+            }
+        }
+        finally {
+            if (engine.messages.length) {
+                this.history.splice(0, this.history.length, ...engine.messages);
+            }
+        }
+    }
+    async run(prompt, overrides = {}) {
+        const iterator = this.query(prompt, overrides);
+        while (true) {
+            const next = await iterator.next();
+            if (next.done)
+                return next.value;
+        }
+    }
+    async runBackgroundPrompt(prompt, options) {
+        await this.setupPromise;
+        this.ensureOpen();
+        if (!this.taskRuntime.startAgentTask) {
+            throw new Error('Task runtime does not support background agent tasks.');
+        }
+        return this.taskRuntime.startAgentTask({
+            subject: options.subject,
+            description: options.description,
+            metadata: options.metadata,
+            runner: async () => {
+                const result = await this.run(prompt, {
+                    includePartialMessages: false,
+                });
+                return result.text || JSON.stringify(result, null, 2);
+            },
+        });
+    }
+    async listTasks() {
+        await this.setupPromise;
+        return this.taskRuntime.listTasks();
+    }
+    async getTask(id) {
+        await this.setupPromise;
+        return this.taskRuntime.getTask(id);
+    }
+    async getTaskOutput(id, maxChars) {
+        await this.setupPromise;
+        return this.taskRuntime.getOutput(id, maxChars);
+    }
+    async stopTask(id, reason) {
+        await this.setupPromise;
+        return this.taskRuntime.cancelTask(id, reason);
+    }
+    async listSchedules() {
+        await this.setupPromise;
+        return this.scheduler.listTasks();
+    }
+    async createSchedule(input) {
+        await this.setupPromise;
+        return this.scheduler.createTask({ ...input, enabled: true });
+    }
+    async runScheduleNow(id) {
+        await this.setupPromise;
+        return this.scheduler.runNow(id);
+    }
+    async deleteSchedule(id) {
+        await this.setupPromise;
+        return this.scheduler.deleteTask(id);
+    }
+    listPendingApprovals() {
+        return this.approvalManager?.listPending() || [];
+    }
+    async resolveApproval(requestId, result) {
+        if (!this.approvalManager)
+            return false;
+        return this.approvalManager.resolve(requestId, result);
+    }
+    listSkills() {
+        return [...this.loadedSkills];
+    }
+    async close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        const errors = [];
+        try {
+            await this.scheduler.stop();
+        }
+        catch (error) {
+            errors.push(`scheduler.stop: ${error?.message || String(error)}`);
+        }
+        try {
+            await this.approvalManager?.shutdown?.();
+        }
+        catch (error) {
+            errors.push(`approval.shutdown: ${error?.message || String(error)}`);
+        }
+        try {
+            await this.taskRuntime.shutdown?.('Agent shutting down');
+        }
+        catch (error) {
+            errors.push(`taskRuntime.shutdown: ${error?.message || String(error)}`);
+        }
+        try {
+            await closeAllConnections(this.mcpConnections);
+        }
+        catch (error) {
+            errors.push(`mcp.closeAllConnections: ${error?.message || String(error)}`);
+        }
+        if (errors.length) {
+            console.warn(`[nanobot-agent-sdk] close() completed with errors:\n${errors.join('\n')}`);
+        }
+    }
+    async setup() {
+        this.policy = await resolvePolicy(this.baseOptions.policy, this.cwd);
+        this.assistantOptions = this.policy.allowAssistantRuntime
+            ? resolveAssistantOptions(this.baseOptions.assistant, this.sessionId)
+            : undefined;
+        const paths = await ensureRuntimePaths({
+            assistantId: this.assistantOptions?.id || this.sessionId,
+            memoryDir: this.assistantOptions?.memoryDir,
+        });
+        this.assistant = createAssistantContext(this.assistantOptions, paths, this.sessionId);
+        this.memoryRuntime = this.assistant ? new DailyMemoryRuntime(this.assistant) : undefined;
+        this.taskRuntime = new FileTaskRuntime(paths, (event) => void this.emitEvent(event), this.memoryRuntime, this.assistant);
+        await this.taskRuntime.initialize();
+        this.approvalManager = this.policy.allowRemoteApproval
+            ? new EventedApprovalManager(this.baseOptions.remoteApproval, (event) => void this.emitEvent(event), this.memoryRuntime, this.assistant)
+            : undefined;
+        this.scheduler = new FileSchedulerRuntime(paths, (task) => this.handleScheduledTask(task), (event) => void this.emitEvent(event), this.memoryRuntime, this.assistant);
+        await this.scheduler.initialize();
+        if (this.baseOptions.resume) {
+            const loaded = await loadSession(this.baseOptions.resume);
+            if (loaded?.messages?.length) {
+                this.history.splice(0, this.history.length, ...loaded.messages);
+            }
+        }
+        this.loadedSkills = this.policy.allowSkills
+            ? this.skillRegistry.load(this.cwd, this.baseOptions.skillDirs || [])
+            : [];
+        this.skillTool = this.loadedSkills.length ? createSkillTool(this.skillRegistry) : undefined;
+        this.baseTools = this.buildBaseTools();
+        await this.connectMcpServers(this.baseOptions.mcpServers);
+        if (this.assistantOptions?.scheduledPrompts?.length && this.policy.allowScheduledTasks && this.scheduler.seedTasks) {
+            await this.scheduler.seedTasks(this.assistantOptions.scheduledPrompts);
+        }
+        if (this.assistantOptions?.enabled && this.assistantOptions.autoStartScheduler !== false && this.policy.allowScheduledTasks) {
+            await this.scheduler.start();
+        }
+    }
+    buildBaseTools() {
+        const raw = this.baseOptions.tools;
+        let pool;
+        if (!raw) {
+            pool = getToolPreset(this.assistant ? 'operations' : 'default');
+        }
+        else if (!Array.isArray(raw) && typeof raw === 'object' && 'type' in raw) {
+            pool = getToolPreset(raw.preset);
+        }
+        else if (Array.isArray(raw) && raw.length > 0 && typeof raw[0] === 'string') {
+            pool = filterTools(getAllBaseTools(), raw);
+        }
+        else {
+            pool = raw;
+        }
+        if (this.policy.allowSkills && this.skillTool) {
+            pool = [...pool, this.skillTool];
+        }
+        return applyPolicyToTools(filterTools(pool, this.baseOptions.allowedTools, this.baseOptions.disallowedTools), this.policy);
+    }
+    async connectMcpServers(mcpServers) {
+        if (!mcpServers)
+            return;
+        for (const [name, config] of Object.entries(mcpServers)) {
+            const connection = await connectMCPServer(name, config);
+            this.mcpConnections.push(connection);
+        }
+    }
+    mergeOptions(overrides) {
+        return {
+            ...this.baseOptions,
+            ...overrides,
+            env: { ...(this.baseOptions.env || {}), ...(overrides.env || {}) },
+            remoteApproval: overrides.remoteApproval || this.baseOptions.remoteApproval,
+        };
+    }
+    resolveTools(options) {
+        let pool = [...this.baseTools];
+        if (options.tools && options.tools !== this.baseOptions.tools) {
+            const raw = options.tools;
+            if (!Array.isArray(raw) && typeof raw === 'object' && 'type' in raw) {
+                pool = getToolPreset(raw.preset);
+            }
+            else if (Array.isArray(raw) && raw.length > 0 && typeof raw[0] === 'string') {
+                pool = filterTools(getAllBaseTools(), raw);
+            }
+            else if (Array.isArray(raw)) {
+                pool = raw;
+            }
+            if (this.policy.allowSkills && this.skillTool && !pool.find((tool) => tool.name === this.skillTool?.name)) {
+                pool.push(this.skillTool);
+            }
+        }
+        const merged = dedupeTools(filterTools(pool, options.allowedTools, options.disallowedTools).concat(this.mcpConnections.flatMap((connection) => connection.status === 'connected' ? connection.tools : [])));
+        return applyPolicyToTools(merged, this.policy);
+    }
+    async resolveSystemPrompt(options, tools) {
+        const systemInput = resolveSystemPromptInput(options.systemPrompt);
+        const skillAppend = this.policy.allowSkills && this.loadedSkills.length
+            ? [
+                '# Available Skills',
+                ...this.loadedSkills
+                    .filter((skill) => skill.modelInvocable)
+                    .map((skill) => `- ${skill.name}: ${skill.description}`),
+            ].join('\n')
+            : '';
+        const schemaAppend = options.jsonSchema
+            ? `Return JSON matching this schema when no tool call is required:\n${JSON.stringify(options.jsonSchema, null, 2)}`
+            : '';
+        return buildSystemPrompt({
+            cwd: this.cwd,
+            tools,
+            assistant: this.assistant,
+            memoryRuntime: this.memoryRuntime,
+            policy: this.policy,
+            promptPreset: systemInput.preset,
+            systemPrompt: systemInput.text,
+            appendSystemPrompt: [systemInput.append, options.appendSystemPrompt, skillAppend, schemaAppend]
+                .filter(Boolean)
+                .join('\n\n'),
+        });
+    }
+    buildCanUseTool(options) {
+        const permissionMode = options.permissionMode || 'default';
+        return async (tool, input) => {
+            if (this.policy.disabledTools.includes(tool.name)) {
+                return { behavior: 'deny', message: `Tool disabled by policy: ${tool.name}` };
+            }
+            const custom = await options.canUseTool?.(tool, input);
+            if (custom?.behavior === 'deny' || custom?.updatedInput !== undefined) {
+                return custom;
+            }
+            if (tool.isReadOnly?.())
+                return { behavior: 'allow' };
+            if (!this.policy.allowBackgroundTasks && isBackgroundTaskRequest(tool.name, input)) {
+                return { behavior: 'deny', message: 'Background tasks are disabled by policy.' };
+            }
+            if (this.approvalManager &&
+                this.policy.allowRemoteApproval &&
+                options.remoteApproval?.enabled &&
+                ['default', 'plan', 'acceptEdits'].includes(permissionMode)) {
+                return this.approvalManager.request({
+                    toolName: tool.name,
+                    toolInput: input,
+                    message: `Approval required for ${tool.name}`,
+                });
+            }
+            return { behavior: 'allow' };
+        };
+    }
+    async handleScheduledTask(task) {
+        await this.runBackgroundPrompt(task.prompt, {
+            subject: `schedule:${task.name}`,
+            description: `Scheduled task ${task.name}`,
+            metadata: { scheduleId: task.id, kind: 'scheduled' },
+        });
+    }
+    async emitEvent(event, options) {
+        try {
+            await (options?.onEvent || this.baseOptions.onEvent)?.(event);
+        }
+        catch {
+            // ignore host callback failures
+        }
+    }
+    ensureOpen() {
+        if (this.closed)
+            throw new Error('Agent has been closed.');
+    }
+}
+function resolveSystemPromptInput(input) {
+    if (!input)
+        return { preset: 'default' };
+    if (typeof input === 'string')
+        return { preset: 'default', text: input };
+    return {
+        preset: input.preset,
+        append: input.append,
+    };
+}
+function shouldPersistSession(options) {
+    return options.persistSession !== false;
+}
+function summarizePrompt(prompt, maxChars = 240) {
+    const compact = prompt.replace(/\s+/g, ' ').trim();
+    return compact.length > maxChars ? `${compact.slice(0, maxChars - 3)}...` : compact;
+}
+function isBackgroundTaskRequest(toolName, input) {
+    if (toolName === 'AgentTask')
+        return true;
+    if (toolName === 'Bash')
+        return Boolean(input?.run_in_background);
+    return false;
+}
+const MODEL_PRICING = [
+    { match: /haiku/i, inputPerMillion: 0.8, outputPerMillion: 4 },
+    { match: /sonnet/i, inputPerMillion: 3, outputPerMillion: 15 },
+    { match: /opus/i, inputPerMillion: 15, outputPerMillion: 75 },
+];
+const defaultEstimateCostUsd = ({ model, usage }) => {
+    const pricing = MODEL_PRICING.find((entry) => entry.match.test(model));
+    if (!pricing)
+        return 0;
+    const inputCost = (usage.input_tokens / 1_000_000) * pricing.inputPerMillion;
+    const outputCost = (usage.output_tokens / 1_000_000) * pricing.outputPerMillion;
+    return inputCost + outputCost;
+};
+export async function createAgent(options = {}) {
+    const agent = new Agent(options);
+    return agent.ready();
+}
+//# sourceMappingURL=agent.js.map