autosnippet 3.2.21 → 3.3.2

package/dist/lib/agent/core/ToolExecutionPipeline.js

@@ -106,7 +106,9 @@ export class ToolExecutionPipeline {
  * 从 LoopContext.toolSchemas 中提取允许的工具名列表，
  * 拒绝不在列表中的调用（返回 error 提示）。
  *
- * before: 如果工具不在白名单中则短路返回 error
+ * Forge 集成：不在白名单的工具如果已由 ToolForge 锻造（存在于 ToolRegistry），则放行。
+ *
+ * before: 如果工具不在白名单中且非锻造工具则短路返回 error
  */
 export const allowlistGate = {
     name: 'allowlistGate',
@@ -118,6 +120,11 @@ export const allowlistGate = {
         }
         const allowedNames = new Set(schemas.map((s) => s.name || s.function?.name));
         if (!allowedNames.has(call.name)) {
+            // Forge fallback: 不在白名单但已注册到 ToolRegistry（如锻造的临时工具）则放行
+            if (ctx.runtime.toolRegistry?.has(call.name)) {
+                ctx.runtime.logger.info(`[ToolPipeline] Tool "${call.name}" not in allowlist but exists in registry (forged?) — allowed`);
+                return undefined;
+            }
             ctx.runtime.logger.warn(`[ToolPipeline] ⛔ Tool "${call.name}" not in allowlist — blocked (hallucinated call)`);
             return {
                 blocked: true,

package/dist/lib/agent/forge/DynamicComposer.d.ts

@@ -0,0 +1,58 @@
+/**
+ * DynamicComposer — 运行时动态工具组合
+ *
+ * 将已有的原子工具按 sequential / parallel / conditional 策略组合成复合工具。
+ * 组合结果注册为临时工具（通过 TemporaryToolRegistry）。
+ *
+ * 与 PipelineStrategy 的区别：
+ *   - PipelineStrategy 是 Agent 执行策略（Agent 层）
+ *   - DynamicComposer 是工具组合（Tool 层），产出物是单个工具
+ */
+interface ToolRegistryLike {
+    has(name: string): boolean;
+    execute(name: string, params: Record<string, unknown>, context?: Record<string, unknown>): Promise<unknown>;
+}
+export interface CompositionStep {
+    /** 要调用的工具名 */
+    tool: string;
+    /** 静态参数或从前一步结果构造参数的函数 */
+    args: Record<string, unknown> | ((prevResult: unknown) => Record<string, unknown>);
+    /** 可选：提取该步结果中的特定字段传给下一步 */
+    extractKey?: string;
+}
+export interface CompositionSpec {
+    /** 组合工具的名称 */
+    name: string;
+    /** 描述 */
+    description: string;
+    /** 执行步骤 */
+    steps: CompositionStep[];
+    /** 合并策略 */
+    mergeStrategy: 'sequential' | 'parallel';
+    /** JSON Schema 参数定义 */
+    parameters?: Record<string, unknown>;
+}
+export interface CompositionResult {
+    /** 是否成功 */
+    success: boolean;
+    /** 组合工具 handler */
+    handler?: (params: Record<string, unknown>, context: Record<string, unknown>) => Promise<unknown>;
+    /** 失败原因 */
+    error?: string;
+}
+export declare class DynamicComposer {
+    #private;
+    constructor(registry: ToolRegistryLike);
+    /**
+     * 验证组合 spec 的可行性（所有工具是否存在）
+     */
+    validate(spec: CompositionSpec): {
+        valid: boolean;
+        missingTools: string[];
+    };
+    /**
+     * 构建组合工具
+     */
+    compose(spec: CompositionSpec): CompositionResult;
+}
+export {};

package/dist/lib/agent/forge/DynamicComposer.js

@@ -0,0 +1,99 @@
+/**
+ * DynamicComposer — 运行时动态工具组合
+ *
+ * 将已有的原子工具按 sequential / parallel / conditional 策略组合成复合工具。
+ * 组合结果注册为临时工具（通过 TemporaryToolRegistry）。
+ *
+ * 与 PipelineStrategy 的区别：
+ *   - PipelineStrategy 是 Agent 执行策略（Agent 层）
+ *   - DynamicComposer 是工具组合（Tool 层），产出物是单个工具
+ */
+import Logger from '#infra/logging/Logger.js';
+/* ────────────────────── Class ────────────────────── */
+export class DynamicComposer {
+    #registry;
+    #logger = Logger.getInstance();
+    constructor(registry) {
+        this.#registry = registry;
+    }
+    /**
+     * 验证组合 spec 的可行性（所有工具是否存在）
+     */
+    validate(spec) {
+        const missing = [];
+        for (const step of spec.steps) {
+            if (!this.#registry.has(step.tool)) {
+                missing.push(step.tool);
+            }
+        }
+        return { valid: missing.length === 0, missingTools: missing };
+    }
+    /**
+     * 构建组合工具
+     */
+    compose(spec) {
+        // 验证
+        const { valid, missingTools } = this.validate(spec);
+        if (!valid) {
+            return {
+                success: false,
+                error: `Missing tools: ${missingTools.join(', ')}`,
+            };
+        }
+        if (spec.steps.length === 0) {
+            return {
+                success: false,
+                error: 'Composition must have at least one step',
+            };
+        }
+        const registry = this.#registry;
+        const logger = this.#logger;
+        // 根据策略构建 handler
+        const handler = spec.mergeStrategy === 'parallel'
+            ? this.#buildParallelHandler(spec, registry, logger)
+            : this.#buildSequentialHandler(spec, registry, logger);
+        return { success: true, handler };
+    }
+    /* ── Internal ── */
+    #buildSequentialHandler(spec, registry, logger) {
+        return async (params, context) => {
+            let prevResult = params;
+            for (const step of spec.steps) {
+                const args = typeof step.args === 'function' ? step.args(prevResult) : { ...step.args, ...params };
+                logger.debug(`DynamicComposer [${spec.name}]: executing step "${step.tool}"`);
+                const result = await registry.execute(step.tool, args, context);
+                if (step.extractKey && typeof result === 'object' && result !== null) {
+                    prevResult = result[step.extractKey];
+                }
+                else {
+                    prevResult = result;
+                }
+            }
+            return prevResult;
+        };
+    }
+    #buildParallelHandler(spec, registry, logger) {
+        return async (params, context) => {
+            logger.debug(`DynamicComposer [${spec.name}]: executing ${spec.steps.length} steps in parallel`);
+            const promises = spec.steps.map(async (step) => {
+                const args = typeof step.args === 'function' ? step.args(params) : { ...step.args, ...params };
+                const result = await registry.execute(step.tool, args, context);
+                if (step.extractKey && typeof result === 'object' && result !== null) {
+                    return { tool: step.tool, result: result[step.extractKey] };
+                }
+                return { tool: step.tool, result };
+            });
+            const results = await Promise.allSettled(promises);
+            const merged = {};
+            for (const r of results) {
+                if (r.status === 'fulfilled') {
+                    merged[r.value.tool] = r.value.result;
+                }
+                else {
+                    merged[`error_${Object.keys(merged).length}`] = r.reason?.message ?? 'Unknown error';
+                }
+            }
+            return merged;
+        };
+    }
+}

package/dist/lib/agent/forge/SandboxRunner.d.ts

@@ -0,0 +1,60 @@
+/**
+ * SandboxRunner — 工具锻造沙箱验证
+ *
+ * 在受限环境中执行锻造的工具代码 + 测试用例，验证安全性和正确性。
+ * 使用 Node.js vm 模块提供隔离执行环境。
+ *
+ * 安全约束：
+ *   - 5s 执行超时
+ *   - 禁止 require/import (无文件系统 / 网络 / 子进程)
+ *   - 内存限制 via vm 上下文隔离
+ *   - 只暴露 console.log, JSON, Math, Date, Array, Object, String 等纯函数
+ */
+export interface SandboxTestCase {
+    /** 测试描述 */
+    description: string;
+    /** 调用参数 */
+    input: Record<string, unknown>;
+    /** 预期输出（用 deepEqual 比较） */
+    expectedOutput: unknown;
+}
+export interface SandboxResult {
+    /** 是否全部通过 */
+    success: boolean;
+    /** 各测试用例结果 */
+    testResults: Array<{
+        description: string;
+        passed: boolean;
+        actualOutput?: unknown;
+        error?: string;
+    }>;
+    /** 总执行时间 (ms) */
+    executionTime: number;
+    /** 安全检查结果 */
+    safetyCheck: {
+        passed: boolean;
+        violations: string[];
+    };
+}
+export declare class SandboxRunner {
+    #private;
+    /**
+     * 对工具代码进行安全检查
+     */
+    checkSafety(code: string): {
+        passed: boolean;
+        violations: string[];
+    };
+    /**
+     * 在沙箱中执行工具代码 + 测试用例
+     *
+     * @param code 工具函数代码（应 export default 或赋给 __toolHandler__）
+     * @param testCases 测试用例
+     */
+    run(code: string, testCases: SandboxTestCase[]): SandboxResult;
+    /**
+     * 从验证通过的代码创建可调用 handler
+     * 返回的 handler 每次调用都在新沙箱中执行（隔离）
+     */
+    createHandler(code: string): (params: Record<string, unknown>, context: Record<string, unknown>) => Promise<unknown>;
+}

package/dist/lib/agent/forge/SandboxRunner.js

@@ -0,0 +1,251 @@
+/**
+ * SandboxRunner — 工具锻造沙箱验证
+ *
+ * 在受限环境中执行锻造的工具代码 + 测试用例，验证安全性和正确性。
+ * 使用 Node.js vm 模块提供隔离执行环境。
+ *
+ * 安全约束：
+ *   - 5s 执行超时
+ *   - 禁止 require/import (无文件系统 / 网络 / 子进程)
+ *   - 内存限制 via vm 上下文隔离
+ *   - 只暴露 console.log, JSON, Math, Date, Array, Object, String 等纯函数
+ */
+import { createContext, runInContext } from 'node:vm';
+import Logger from '#infra/logging/Logger.js';
+/* ────────────────────── Constants ────────────────────── */
+const EXECUTION_TIMEOUT_MS = 5000;
+/** 禁止使用的模式 */
+const FORBIDDEN_PATTERNS = [
+    /\brequire\s*\(/,
+    /\bimport\s*\(/,
+    /\bprocess\b/,
+    /\b__dirname\b/,
+    /\b__filename\b/,
+    /\bglobal\b/,
+    /\bglobalThis\b/,
+    /\beval\s*\(/,
+    /\bFunction\s*\(/,
+    /\bfetch\s*\(/,
+    /\bXMLHttpRequest\b/,
+    /\bWebSocket\b/,
+    /\bchild_process\b/,
+    /\bfs\b\./,
+    /\bnet\b\./,
+    /\bhttp\b\./,
+    /\bhttps\b\./,
+];
+/* ────────────────────── Class ────────────────────── */
+export class SandboxRunner {
+    #logger = Logger.getInstance();
+    /**
+     * 对工具代码进行安全检查
+     */
+    checkSafety(code) {
+        const violations = [];
+        for (const pattern of FORBIDDEN_PATTERNS) {
+            if (pattern.test(code)) {
+                violations.push(`Forbidden pattern detected: ${pattern.source}`);
+            }
+        }
+        return { passed: violations.length === 0, violations };
+    }
+    /**
+     * 在沙箱中执行工具代码 + 测试用例
+     *
+     * @param code 工具函数代码（应 export default 或赋给 __toolHandler__）
+     * @param testCases 测试用例
+     */
+    run(code, testCases) {
+        const start = Date.now();
+        // 1. 安全检查
+        const safetyCheck = this.checkSafety(code);
+        if (!safetyCheck.passed) {
+            return {
+                success: false,
+                testResults: [],
+                executionTime: Date.now() - start,
+                safetyCheck,
+            };
+        }
+        // 2. 构建沙箱上下文 — 只暴露安全的全局对象
+        const logs = [];
+        const sandbox = createContext({
+            console: {
+                log: (...args) => logs.push(args.map(String).join(' ')),
+                warn: (...args) => logs.push(`[warn] ${args.map(String).join(' ')}`),
+                error: (...args) => logs.push(`[error] ${args.map(String).join(' ')}`),
+            },
+            JSON,
+            Math,
+            Date,
+            Array,
+            Object,
+            String,
+            Number,
+            Boolean,
+            RegExp,
+            Map,
+            Set,
+            Error,
+            TypeError,
+            RangeError,
+            parseInt,
+            parseFloat,
+            isNaN,
+            isFinite,
+            encodeURIComponent,
+            decodeURIComponent,
+            // 工具函数占位，由代码赋值
+            __toolHandler__: null,
+        });
+        // 3. 加载工具代码
+        try {
+            const wrappedCode = `${code}\n;(typeof toolHandler !== 'undefined') && (__toolHandler__ = toolHandler);`;
+            runInContext(wrappedCode, sandbox, {
+                timeout: EXECUTION_TIMEOUT_MS,
+                filename: 'forged-tool.js',
+            });
+        }
+        catch (err) {
+            return {
+                success: false,
+                testResults: [
+                    {
+                        description: 'Code loading',
+                        passed: false,
+                        error: `Failed to load tool code: ${err.message}`,
+                    },
+                ],
+                executionTime: Date.now() - start,
+                safetyCheck,
+            };
+        }
+        const handler = sandbox.__toolHandler__;
+        if (typeof handler !== 'function') {
+            return {
+                success: false,
+                testResults: [
+                    {
+                        description: 'Handler check',
+                        passed: false,
+                        error: 'Tool code must define a `toolHandler` function',
+                    },
+                ],
+                executionTime: Date.now() - start,
+                safetyCheck,
+            };
+        }
+        // 4. 执行测试用例
+        const testResults = [];
+        let allPassed = true;
+        for (const tc of testCases) {
+            try {
+                const testCode = `__toolHandler__(${JSON.stringify(tc.input)})`;
+                const actual = runInContext(testCode, sandbox, {
+                    timeout: EXECUTION_TIMEOUT_MS,
+                    filename: 'forged-tool-test.js',
+                });
+                const passed = SandboxRunner.#deepEqual(actual, tc.expectedOutput);
+                if (!passed) {
+                    allPassed = false;
+                }
+                testResults.push({
+                    description: tc.description,
+                    passed,
+                    actualOutput: actual,
+                    error: passed
+                        ? undefined
+                        : `Expected ${JSON.stringify(tc.expectedOutput)}, got ${JSON.stringify(actual)}`,
+                });
+            }
+            catch (err) {
+                allPassed = false;
+                testResults.push({
+                    description: tc.description,
+                    passed: false,
+                    error: err.message,
+                });
+            }
+        }
+        this.#logger.debug(`SandboxRunner: ${testResults.filter((t) => t.passed).length}/${testResults.length} tests passed`);
+        return {
+            success: allPassed,
+            testResults,
+            executionTime: Date.now() - start,
+            safetyCheck,
+        };
+    }
+    /**
+     * 从验证通过的代码创建可调用 handler
+     * 返回的 handler 每次调用都在新沙箱中执行（隔离）
+     */
+    createHandler(code) {
+        return async (params) => {
+            const sandbox = createContext({
+                console: { log: () => { }, warn: () => { }, error: () => { } },
+                JSON,
+                Math,
+                Date,
+                Array,
+                Object,
+                String,
+                Number,
+                Boolean,
+                RegExp,
+                Map,
+                Set,
+                Error,
+                TypeError,
+                RangeError,
+                parseInt,
+                parseFloat,
+                isNaN,
+                isFinite,
+                encodeURIComponent,
+                decodeURIComponent,
+                __toolHandler__: null,
+            });
+            const wrappedCode = `${code}\n;(typeof toolHandler !== 'undefined') && (__toolHandler__ = toolHandler);`;
+            runInContext(wrappedCode, sandbox, {
+                timeout: EXECUTION_TIMEOUT_MS,
+                filename: 'forged-tool.js',
+            });
+            const handler = sandbox.__toolHandler__;
+            if (typeof handler !== 'function') {
+                throw new Error('Forged tool code does not define a toolHandler function');
+            }
+            const execCode = `__toolHandler__(${JSON.stringify(params)})`;
+            const result = runInContext(execCode, sandbox, {
+                timeout: EXECUTION_TIMEOUT_MS,
+                filename: 'forged-tool-exec.js',
+            });
+            // 如果返回 Promise-like，需特殊处理（vm 里一般不会有真正的 Promise）
+            return result;
+        };
+    }
+    /** 简单深度比较 */
+    static #deepEqual(a, b) {
+        if (a === b) {
+            return true;
+        }
+        if (a === null || b === null || typeof a !== typeof b) {
+            return false;
+        }
+        if (typeof a !== 'object') {
+            return false;
+        }
+        const aObj = a;
+        const bObj = b;
+        const keysA = Object.keys(aObj);
+        const keysB = Object.keys(bObj);
+        if (keysA.length !== keysB.length) {
+            return false;
+        }
+        for (const key of keysA) {
+            if (!SandboxRunner.#deepEqual(aObj[key], bObj[key])) {
+                return false;
+            }
+        }
+        return true;
+    }
+}

package/dist/lib/agent/forge/TemporaryToolRegistry.d.ts

@@ -0,0 +1,76 @@
+/**
+ * TemporaryToolRegistry — TTL 临时工具注册
+ *
+ * 在 ToolRegistry 之上增加 TTL 自动回收机制。
+ * 锻造的工具默认 30 分钟有效，到期自动从 ToolRegistry 中移除。
+ *
+ * 设计：
+ *   - 装饰器模式，不修改 ToolRegistry 核心逻辑
+ *   - 定期检查（60s 间隔）清理过期工具
+ *   - 支持手动续期和提前回收
+ */
+import type { SignalBus } from '#infra/signal/SignalBus.js';
+interface ToolRegistryLike {
+    register(toolDef: {
+        name: string;
+        description: string;
+        parameters?: Record<string, unknown>;
+        handler: Function;
+    }): void;
+    unregister(name: string): boolean;
+    has(name: string): boolean;
+}
+export interface TemporaryTool {
+    name: string;
+    description: string;
+    parameters: Record<string, unknown>;
+    handler: (params: Record<string, unknown>, context: Record<string, unknown>) => Promise<unknown>;
+    /** 锻造模式 */
+    forgeMode: 'reuse' | 'compose' | 'generate';
+    /** 注册时间 (ms) */
+    registeredAt: number;
+    /** 过期时间 (ms)，0 = never */
+    expiresAt: number;
+}
+export interface TemporaryToolInfo {
+    name: string;
+    forgeMode: string;
+    registeredAt: number;
+    expiresAt: number;
+    remainingMs: number;
+}
+export declare class TemporaryToolRegistry {
+    #private;
+    constructor(registry: ToolRegistryLike, options?: {
+        signalBus?: SignalBus;
+    });
+    /**
+     * 注册一个临时工具
+     */
+    registerTemporary(tool: Omit<TemporaryTool, 'registeredAt' | 'expiresAt'>, ttlMs?: number): void;
+    /**
+     * 手动回收临时工具
+     */
+    revoke(name: string): boolean;
+    /**
+     * 续期临时工具
+     */
+    renew(name: string, additionalMs?: number): boolean;
+    /**
+     * 清理过期工具
+     */
+    cleanup(): number;
+    /**
+     * 获取所有临时工具信息
+     */
+    list(): TemporaryToolInfo[];
+    /**
+     * 检查是否是临时工具
+     */
+    isTemporary(name: string): boolean;
+    /** 临时工具数量 */
+    get size(): number;
+    /** 停止定期清理（用于 shutdown） */
+    dispose(): void;
+}
+export {};