autosnippet 3.2.21 → 3.3.2

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

@@ -0,0 +1,154 @@
+/**
+ * TemporaryToolRegistry — TTL 临时工具注册
+ *
+ * 在 ToolRegistry 之上增加 TTL 自动回收机制。
+ * 锻造的工具默认 30 分钟有效，到期自动从 ToolRegistry 中移除。
+ *
+ * 设计：
+ *   - 装饰器模式，不修改 ToolRegistry 核心逻辑
+ *   - 定期检查（60s 间隔）清理过期工具
+ *   - 支持手动续期和提前回收
+ */
+import Logger from '#infra/logging/Logger.js';
+/* ────────────────────── Constants ────────────────────── */
+const DEFAULT_TTL_MS = 30 * 60 * 1000; // 30 minutes
+const CLEANUP_INTERVAL_MS = 60 * 1000; // 60 seconds
+/* ────────────────────── Class ────────────────────── */
+export class TemporaryToolRegistry {
+    #registry;
+    #tempTools = new Map();
+    #cleanupTimer = null;
+    #signalBus;
+    #logger = Logger.getInstance();
+    constructor(registry, options = {}) {
+        this.#registry = registry;
+        this.#signalBus = options.signalBus ?? null;
+        this.#startCleanup();
+    }
+    /**
+     * 注册一个临时工具
+     */
+    registerTemporary(tool, ttlMs = DEFAULT_TTL_MS) {
+        const now = Date.now();
+        const entry = {
+            ...tool,
+            registeredAt: now,
+            expiresAt: ttlMs > 0 ? now + ttlMs : 0,
+        };
+        // 如果已存在同名临时工具，先移除
+        if (this.#tempTools.has(tool.name)) {
+            this.revoke(tool.name);
+        }
+        // 注册到主 ToolRegistry
+        this.#registry.register({
+            name: tool.name,
+            description: `[Forged:${tool.forgeMode}] ${tool.description}`,
+            parameters: tool.parameters,
+            handler: tool.handler,
+        });
+        this.#tempTools.set(tool.name, entry);
+        if (this.#signalBus) {
+            this.#signalBus.send('forge', 'TemporaryToolRegistry', 1, {
+                target: tool.name,
+                metadata: { action: 'registered', forgeMode: tool.forgeMode, ttlMs },
+            });
+        }
+        this.#logger.debug(`TemporaryToolRegistry: registered "${tool.name}" (mode=${tool.forgeMode}, ttl=${ttlMs}ms)`);
+    }
+    /**
+     * 手动回收临时工具
+     */
+    revoke(name) {
+        const tool = this.#tempTools.get(name);
+        if (!tool) {
+            return false;
+        }
+        this.#registry.unregister(name);
+        this.#tempTools.delete(name);
+        if (this.#signalBus) {
+            this.#signalBus.send('forge', 'TemporaryToolRegistry', 0, {
+                target: name,
+                metadata: { action: 'revoked' },
+            });
+        }
+        this.#logger.debug(`TemporaryToolRegistry: revoked "${name}"`);
+        return true;
+    }
+    /**
+     * 续期临时工具
+     */
+    renew(name, additionalMs = DEFAULT_TTL_MS) {
+        const tool = this.#tempTools.get(name);
+        if (!tool) {
+            return false;
+        }
+        tool.expiresAt = Date.now() + additionalMs;
+        return true;
+    }
+    /**
+     * 清理过期工具
+     */
+    cleanup() {
+        const now = Date.now();
+        let cleaned = 0;
+        for (const [name, tool] of this.#tempTools) {
+            if (tool.expiresAt > 0 && tool.expiresAt <= now) {
+                this.#registry.unregister(name);
+                this.#tempTools.delete(name);
+                cleaned++;
+                this.#logger.debug(`TemporaryToolRegistry: expired "${name}"`);
+            }
+        }
+        return cleaned;
+    }
+    /**
+     * 获取所有临时工具信息
+     */
+    list() {
+        const now = Date.now();
+        const result = [];
+        for (const [name, tool] of this.#tempTools) {
+            result.push({
+                name,
+                forgeMode: tool.forgeMode,
+                registeredAt: tool.registeredAt,
+                expiresAt: tool.expiresAt,
+                remainingMs: tool.expiresAt > 0 ? Math.max(0, tool.expiresAt - now) : -1,
+            });
+        }
+        return result;
+    }
+    /**
+     * 检查是否是临时工具
+     */
+    isTemporary(name) {
+        return this.#tempTools.has(name);
+    }
+    /** 临时工具数量 */
+    get size() {
+        return this.#tempTools.size;
+    }
+    /** 停止定期清理（用于 shutdown） */
+    dispose() {
+        if (this.#cleanupTimer) {
+            clearInterval(this.#cleanupTimer);
+            this.#cleanupTimer = null;
+        }
+        // 回收所有临时工具
+        for (const name of [...this.#tempTools.keys()]) {
+            this.revoke(name);
+        }
+    }
+    /* ── Internal ── */
+    #startCleanup() {
+        this.#cleanupTimer = setInterval(() => {
+            this.cleanup();
+        }, CLEANUP_INTERVAL_MS);
+        // 允许 Node.js 进程在只剩此 timer 时退出
+        if (this.#cleanupTimer &&
+            typeof this.#cleanupTimer === 'object' &&
+            'unref' in this.#cleanupTimer) {
+            this.#cleanupTimer.unref();
+        }
+    }
+}

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

@@ -0,0 +1,92 @@
+/**
+ * ToolForge — 工具锻造主编排器
+ *
+ * 三级锻造策略：
+ *   Reuse (0ms)   → 直接重用注册表中已有工具
+ *   Compose (10ms) → 通过 DynamicComposer 组合已有原子工具
+ *   Generate (5s)  → LLM 生成工具代码 → SandboxRunner 验证 → 注册
+ *
+ * 瀑布逻辑：reuse → compose → generate，首个成功即返回。
+ */
+import type { SignalBus } from '#infra/signal/SignalBus.js';
+import type { CompositionSpec } from './DynamicComposer.js';
+import type { SandboxTestCase } from './SandboxRunner.js';
+import { TemporaryToolRegistry } from './TemporaryToolRegistry.js';
+import type { AnalysisResult, ToolRequirement } from './ToolRequirementAnalyzer.js';
+import { ToolRequirementAnalyzer } from './ToolRequirementAnalyzer.js';
+interface ToolRegistryLike {
+    has(name: string): boolean;
+    getToolNames(): string[];
+    execute(name: string, params: Record<string, unknown>, context?: Record<string, unknown>): Promise<unknown>;
+    register(toolDef: {
+        name: string;
+        description: string;
+        parameters?: Record<string, unknown>;
+        handler: Function;
+    }): void;
+    unregister(name: string): boolean;
+}
+export interface ForgeRequest {
+    /** 用户意图 */
+    intent: string;
+    /** 关键动作 */
+    action: string;
+    /** 目标对象 */
+    target: string;
+    /** 约束条件 */
+    constraints?: string[];
+    /** LLM 代码生成回调 — 仅 generate 模式时调用 */
+    codeGenerator?: (requirement: ToolRequirement) => Promise<GeneratedTool | null>;
+}
+export interface GeneratedTool {
+    /** 工具名 */
+    name: string;
+    /** 描述 */
+    description: string;
+    /** JSON Schema 参数 */
+    parameters: Record<string, unknown>;
+    /** 工具代码（需包含 toolHandler 函数） */
+    code: string;
+    /** 测试用例 */
+    testCases: SandboxTestCase[];
+}
+export interface ForgeResult {
+    /** 是否成功 */
+    success: boolean;
+    /** 使用的模式 */
+    mode: 'reuse' | 'compose' | 'generate';
+    /** 工具名称 */
+    toolName?: string;
+    /** 需求分析结果 */
+    analysis: AnalysisResult;
+    /** 失败原因 */
+    error?: string;
+}
+export interface ToolForgeOptions {
+    signalBus?: SignalBus;
+    /** 生成工具的默认 TTL（ms），默认 30 分钟 */
+    defaultTtlMs?: number;
+    /** compose 模式下的组合 spec 生成器 */
+    compositionSpecBuilder?: (analysis: AnalysisResult, requirement: ToolRequirement) => CompositionSpec | null;
+}
+export declare class ToolForge {
+    #private;
+    constructor(registry: ToolRegistryLike, options?: ToolForgeOptions);
+    /**
+     * 锻造工具 — 瀑布流：reuse → compose → generate
+     */
+    forge(request: ForgeRequest): Promise<ForgeResult>;
+    /**
+     * 获取临时工具注册表（暴露给 Pipeline 集成用）
+     */
+    get temporaryRegistry(): TemporaryToolRegistry;
+    /**
+     * 获取分析器
+     */
+    get analyzer(): ToolRequirementAnalyzer;
+    /**
+     * 销毁 Forge（清理临时工具和定时器）
+     */
+    dispose(): void;
+}
+export {};

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

@@ -0,0 +1,239 @@
+/**
+ * ToolForge — 工具锻造主编排器
+ *
+ * 三级锻造策略：
+ *   Reuse (0ms)   → 直接重用注册表中已有工具
+ *   Compose (10ms) → 通过 DynamicComposer 组合已有原子工具
+ *   Generate (5s)  → LLM 生成工具代码 → SandboxRunner 验证 → 注册
+ *
+ * 瀑布逻辑：reuse → compose → generate，首个成功即返回。
+ */
+import Logger from '#infra/logging/Logger.js';
+import { DynamicComposer } from './DynamicComposer.js';
+import { SandboxRunner } from './SandboxRunner.js';
+import { TemporaryToolRegistry } from './TemporaryToolRegistry.js';
+import { ToolRequirementAnalyzer } from './ToolRequirementAnalyzer.js';
+/* ────────────────────── Class ────────────────────── */
+export class ToolForge {
+    #registry;
+    #analyzer;
+    #composer;
+    #sandbox;
+    #tempRegistry;
+    #signalBus;
+    #logger = Logger.getInstance();
+    #defaultTtlMs;
+    #compositionSpecBuilder;
+    constructor(registry, options = {}) {
+        this.#registry = registry;
+        this.#signalBus = options.signalBus ?? null;
+        this.#defaultTtlMs = options.defaultTtlMs ?? 30 * 60 * 1000;
+        this.#compositionSpecBuilder = options.compositionSpecBuilder;
+        this.#analyzer = new ToolRequirementAnalyzer(registry);
+        this.#composer = new DynamicComposer(registry);
+        this.#sandbox = new SandboxRunner();
+        this.#tempRegistry = new TemporaryToolRegistry(registry, {
+            signalBus: this.#signalBus ?? undefined,
+        });
+    }
+    /* ────────── Public API ────────── */
+    /**
+     * 锻造工具 — 瀑布流：reuse → compose → generate
+     */
+    async forge(request) {
+        const requirement = {
+            intent: request.intent,
+            action: request.action,
+            target: request.target,
+            constraints: request.constraints,
+        };
+        // Step 1: 需求分析
+        const analysis = this.#analyzer.analyze(requirement);
+        this.#logger.info(`ToolForge: analysis for "${request.intent}" → mode=${analysis.mode}, confidence=${analysis.confidence}`);
+        // Step 2: 按推荐模式尝试，失败则降级
+        const result = (await this.#tryReuse(analysis, requirement)) ??
+            (await this.#tryCompose(analysis, requirement)) ??
+            (await this.#tryGenerate(analysis, requirement, request.codeGenerator));
+        if (result) {
+            this.#emitSignal('forge_complete', {
+                mode: result.mode,
+                tool: result.toolName,
+                analysis,
+            });
+            return result;
+        }
+        // 全部失败
+        return {
+            success: false,
+            mode: 'generate',
+            analysis,
+            error: 'All forge modes exhausted. Cannot satisfy tool requirement.',
+        };
+    }
+    /**
+     * 获取临时工具注册表（暴露给 Pipeline 集成用）
+     */
+    get temporaryRegistry() {
+        return this.#tempRegistry;
+    }
+    /**
+     * 获取分析器
+     */
+    get analyzer() {
+        return this.#analyzer;
+    }
+    /**
+     * 销毁 Forge（清理临时工具和定时器）
+     */
+    dispose() {
+        this.#tempRegistry.dispose();
+    }
+    /* ────────── Forge Modes ────────── */
+    async #tryReuse(analysis, _requirement) {
+        if (analysis.mode !== 'reuse' || !analysis.matchedTool) {
+            // 即便分析推荐 compose/generate，也尝试检查直接匹配
+            if (analysis.matchedTool && this.#registry.has(analysis.matchedTool)) {
+                return {
+                    success: true,
+                    mode: 'reuse',
+                    toolName: analysis.matchedTool,
+                    analysis,
+                };
+            }
+            return null;
+        }
+        if (!this.#registry.has(analysis.matchedTool)) {
+            return null;
+        }
+        this.#logger.debug(`ToolForge: reuse existing tool "${analysis.matchedTool}"`);
+        return {
+            success: true,
+            mode: 'reuse',
+            toolName: analysis.matchedTool,
+            analysis,
+        };
+    }
+    async #tryCompose(analysis, requirement) {
+        if (!analysis.composableTools || analysis.composableTools.length < 2) {
+            return null;
+        }
+        // 如果有外部 spec builder，使用它
+        const spec = this.#compositionSpecBuilder?.(analysis, requirement);
+        if (!spec) {
+            // 默认构建 sequential 组合
+            const defaultSpec = this.#buildDefaultCompositionSpec(analysis, requirement);
+            if (!defaultSpec) {
+                return null;
+            }
+            return this.#executeComposition(defaultSpec, analysis);
+        }
+        return this.#executeComposition(spec, analysis);
+    }
+    #buildDefaultCompositionSpec(analysis, requirement) {
+        const tools = analysis.composableTools;
+        if (!tools || tools.length < 2) {
+            return null;
+        }
+        const composedName = `composed_${requirement.action}_${requirement.target}`;
+        return {
+            name: composedName,
+            description: `Auto-composed tool for: ${requirement.intent}`,
+            steps: tools.map((tool) => ({
+                tool,
+                args: (prevResult) => {
+                    if (typeof prevResult === 'object' && prevResult !== null) {
+                        return prevResult;
+                    }
+                    return {};
+                },
+            })),
+            mergeStrategy: 'sequential',
+        };
+    }
+    async #executeComposition(spec, analysis) {
+        const result = this.#composer.compose(spec);
+        if (!result.success || !result.handler) {
+            this.#logger.debug(`ToolForge: composition failed — ${result.error}`);
+            return null;
+        }
+        // 注册为临时工具
+        this.#tempRegistry.registerTemporary({
+            name: spec.name,
+            description: spec.description,
+            parameters: spec.parameters ?? {},
+            handler: result.handler,
+            forgeMode: 'compose',
+        }, this.#defaultTtlMs);
+        this.#logger.info(`ToolForge: composed tool "${spec.name}" from ${spec.steps.length} steps`);
+        return {
+            success: true,
+            mode: 'compose',
+            toolName: spec.name,
+            analysis,
+        };
+    }
+    async #tryGenerate(analysis, requirement, codeGenerator) {
+        if (!codeGenerator) {
+            this.#logger.debug('ToolForge: generate mode skipped (no codeGenerator provided)');
+            return null;
+        }
+        // 调用 LLM 生成工具
+        const generated = await codeGenerator(requirement);
+        if (!generated) {
+            return null;
+        }
+        // 安全检查
+        const safety = this.#sandbox.checkSafety(generated.code);
+        if (!safety.passed) {
+            this.#logger.warn(`ToolForge: generated code failed safety check — ${safety.violations.join(', ')}`);
+            return {
+                success: false,
+                mode: 'generate',
+                analysis,
+                error: `Safety violations: ${safety.violations.join(', ')}`,
+            };
+        }
+        // 沙箱测试
+        if (generated.testCases.length > 0) {
+            const testResult = await this.#sandbox.run(generated.code, generated.testCases);
+            if (!testResult.success) {
+                const failures = testResult.testResults
+                    .filter((t) => !t.passed)
+                    .map((t) => t.description)
+                    .join(', ');
+                this.#logger.warn(`ToolForge: generated code failed tests — ${failures}`);
+                return {
+                    success: false,
+                    mode: 'generate',
+                    analysis,
+                    error: `Test failures: ${failures}`,
+                };
+            }
+        }
+        // 构建 handler 包装
+        const handler = this.#sandbox.createHandler(generated.code);
+        // 注册为临时工具
+        this.#tempRegistry.registerTemporary({
+            name: generated.name,
+            description: generated.description,
+            parameters: generated.parameters,
+            handler,
+            forgeMode: 'generate',
+        }, this.#defaultTtlMs);
+        this.#logger.info(`ToolForge: generated and registered tool "${generated.name}"`);
+        return {
+            success: true,
+            mode: 'generate',
+            toolName: generated.name,
+            analysis,
+        };
+    }
+    /* ────────── Signal ────────── */
+    #emitSignal(action, data) {
+        if (this.#signalBus) {
+            this.#signalBus.send('forge', 'ToolForge', 1, {
+                metadata: { action, ...data },
+            });
+        }
+    }
+}

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

@@ -0,0 +1,44 @@
+/**
+ * ToolRequirementAnalyzer — 工具需求分析器
+ *
+ * 分析结构化意图，确定满足需求的最佳路径：
+ *   1. Reuse  — 注册表中已有完全匹配的工具
+ *   2. Compose — 可通过组合已有工具满足
+ *   3. Generate — 必须由 LLM 生成新工具代码
+ */
+interface ToolRegistryLike {
+    has(name: string): boolean;
+    getToolNames(): string[];
+}
+export interface ToolRequirement {
+    /** 用户意图描述 */
+    intent: string;
+    /** 关键动作词（如 read / search / transform / validate） */
+    action: string;
+    /** 目标对象（如 file / database / API） */
+    target: string;
+    /** 附加约束 */
+    constraints?: string[];
+}
+export type ForgeMode = 'reuse' | 'compose' | 'generate';
+export interface AnalysisResult {
+    /** 推荐的 Forge 模式 */
+    mode: ForgeMode;
+    /** 置信度 0-1 */
+    confidence: number;
+    /** 推理理由 */
+    reasoning: string;
+    /** mode=reuse 时：匹配的工具名 */
+    matchedTool?: string;
+    /** mode=compose 时：建议参与组合的工具列表 */
+    composableTools?: string[];
+}
+export declare class ToolRequirementAnalyzer {
+    #private;
+    constructor(registry: ToolRegistryLike);
+    /**
+     * 分析需求并推荐 Forge 模式
+     */
+    analyze(requirement: ToolRequirement): AnalysisResult;
+}
+export {};

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

@@ -0,0 +1,119 @@
+/**
+ * ToolRequirementAnalyzer — 工具需求分析器
+ *
+ * 分析结构化意图，确定满足需求的最佳路径：
+ *   1. Reuse  — 注册表中已有完全匹配的工具
+ *   2. Compose — 可通过组合已有工具满足
+ *   3. Generate — 必须由 LLM 生成新工具代码
+ */
+import Logger from '#infra/logging/Logger.js';
+/* ────────────── Action → Tool Keyword mapping ────────────── */
+const ACTION_TOOL_HINTS = {
+    read: ['read', 'get', 'fetch', 'load', 'file'],
+    search: ['search', 'find', 'query', 'lookup'],
+    write: ['write', 'save', 'create', 'update', 'set'],
+    delete: ['delete', 'remove', 'clear'],
+    transform: ['transform', 'convert', 'parse', 'format'],
+    validate: ['validate', 'check', 'guard', 'lint'],
+    analyse: ['analyze', 'analyse', 'inspect', 'stats'],
+    list: ['list', 'browse', 'enumerate'],
+    execute: ['execute', 'run', 'invoke', 'call'],
+};
+/* ────────────────────── Class ────────────────────── */
+export class ToolRequirementAnalyzer {
+    #registry;
+    #logger = Logger.getInstance();
+    constructor(registry) {
+        this.#registry = registry;
+    }
+    /**
+     * 分析需求并推荐 Forge 模式
+     */
+    analyze(requirement) {
+        // 1. 尝试精确匹配
+        const exactMatch = this.#tryExactMatch(requirement);
+        if (exactMatch) {
+            return exactMatch;
+        }
+        // 2. 尝试组合匹配
+        const composeMatch = this.#tryComposeMatch(requirement);
+        if (composeMatch) {
+            return composeMatch;
+        }
+        // 3. Fallback: 需要生成
+        return {
+            mode: 'generate',
+            confidence: 0.5,
+            reasoning: `No existing tool matches "${requirement.action} ${requirement.target}". Code generation required.`,
+        };
+    }
+    /* ── Internal ── */
+    #tryExactMatch(req) {
+        // 直接检查 action_target 形式的工具名
+        const directName = `${req.action}_${req.target}`.toLowerCase();
+        if (this.#registry.has(directName)) {
+            return {
+                mode: 'reuse',
+                confidence: 1.0,
+                reasoning: `Exact tool match: "${directName}"`,
+                matchedTool: directName,
+            };
+        }
+        // 模糊匹配：遍历已注册工具，看名称是否同时包含 action 和 target 关键词
+        const allTools = this.#registry.getToolNames();
+        const actionLower = req.action.toLowerCase();
+        const targetLower = req.target.toLowerCase();
+        for (const tool of allTools) {
+            const toolLower = tool.toLowerCase();
+            if (toolLower.includes(actionLower) && toolLower.includes(targetLower)) {
+                return {
+                    mode: 'reuse',
+                    confidence: 0.85,
+                    reasoning: `Fuzzy match: tool "${tool}" contains both "${req.action}" and "${req.target}"`,
+                    matchedTool: tool,
+                };
+            }
+        }
+        // 通过 action hint 词尝试
+        const hints = ACTION_TOOL_HINTS[actionLower] ?? [actionLower];
+        for (const tool of allTools) {
+            const toolLower = tool.toLowerCase();
+            const matchesHint = hints.some((h) => toolLower.includes(h));
+            const matchesTarget = toolLower.includes(targetLower);
+            if (matchesHint && matchesTarget) {
+                return {
+                    mode: 'reuse',
+                    confidence: 0.7,
+                    reasoning: `Hint match: tool "${tool}" matches action hint and target "${req.target}"`,
+                    matchedTool: tool,
+                };
+            }
+        }
+        return null;
+    }
+    #tryComposeMatch(req) {
+        const allTools = this.#registry.getToolNames();
+        const actionLower = req.action.toLowerCase();
+        const targetLower = req.target.toLowerCase();
+        const hints = ACTION_TOOL_HINTS[actionLower] ?? [actionLower];
+        // 寻找和 action 相关的工具
+        const actionRelated = allTools.filter((t) => {
+            const tl = t.toLowerCase();
+            return hints.some((h) => tl.includes(h));
+        });
+        // 寻找和 target 相关的工具
+        const targetRelated = allTools.filter((t) => t.toLowerCase().includes(targetLower));
+        // 取并集
+        const candidates = [...new Set([...actionRelated, ...targetRelated])];
+        if (candidates.length >= 2) {
+            this.#logger.debug(`ToolRequirementAnalyzer: compose candidates for "${req.intent}": ${candidates.join(', ')}`);
+            return {
+                mode: 'compose',
+                confidence: 0.65,
+                reasoning: `Found ${candidates.length} composable tools for "${req.action} ${req.target}"`,
+                composableTools: candidates.slice(0, 5),
+            };
+        }
+        return null;
+    }
+}

package/dist/lib/agent/tools/ToolRegistry.d.ts

@@ -46,6 +46,8 @@ export declare class ToolRegistry {
     execute(name: string, params: Record<string, unknown>, context?: Record<string, unknown>): Promise<unknown>;
     /** 检查工具是否存在 */
     has(name: string): boolean;
+    /** 移除一个已注册的工具（Forge TTL 回收用） */
+    unregister(name: string): boolean;
     /** 获取所有工具名 */
     getToolNames(): string[];
     /** 工具数量 */

package/dist/lib/agent/tools/ToolRegistry.js

@@ -174,6 +174,10 @@ export class ToolRegistry {
     has(name) {
         return this.#tools.has(name);
     }
+    /** 移除一个已注册的工具（Forge TTL 回收用） */
+    unregister(name) {
+        return this.#tools.delete(name);
+    }
     /** 获取所有工具名 */
     getToolNames() {
         return [...this.#tools.keys()];

package/dist/lib/agent/tools/composite.js

@@ -214,7 +214,6 @@ export const submitWithCheck = {
                     existingFingerprints: ctx._submittedPatterns || new Set(),
                 });
             const validResult = validator.validate(params, {
-                mode: 'strict',
                 systemInjectedFields: getSystemInjectedFields(),
             });
             if (!validResult.pass) {