@gt-fe/eap-runtime 0.0.10 → 0.0.11

package/dist/common/concurrency.js

@@ -1,121 +0,0 @@
-/**
- * 并发控制模块
- *
- * 提供两种并发限制机制：
- * 1. ConcurrencyLimiter — 基于 amqplib channel.prefetch 的 Agent 级并发控制
- *    通过 RabbitMQ consumer prefetch 限制单 Agent 实例同时处理的任务数
- * 2. Semaphore — 纯内存信号量，用于本地并发控制（不依赖 RabbitMQ）
- *
- * @see Requirement 14 AC2: 系统通过消息消费者 prefetch 参数控制单 Agent 实例的并发上限（默认 prefetch=5）
- */
-// ─────────────────────────────────────────────
-// ConcurrencyLimiter — RabbitMQ prefetch 并发控制
-// ─────────────────────────────────────────────
-/** ConcurrencyLimiter 默认 prefetch 值 */
-export const DEFAULT_PREFETCH = 5;
-/**
- * 基于 amqplib consumer prefetch 的 Agent 级并发限制器
- *
- * RabbitMQ 的 channel.prefetch(n) 表示该 Channel 上的消费者最多同时
- * 持有 n 条未确认消息。超出限制的消息留在 Queue 中排队等待。
- *
- * 整体 QPS = Pod 数 × prefetch。
- */
-export class ConcurrencyLimiter {
-    prefetchCount;
-    /**
-     * @param prefetchCount 单 Agent 实例最大并发任务数，默认 5
-     */
-    constructor(prefetchCount = DEFAULT_PREFETCH) {
-        if (prefetchCount < 1) {
-            throw new Error(`prefetchCount must be >= 1, got ${prefetchCount}`);
-        }
-        this.prefetchCount = prefetchCount;
-    }
-    /**
-     * 配置 amqplib Channel 的 prefetch
-     *
-     * 调用后该 Channel 上的消费者最多同时处理 prefetchCount 条消息。
-     * 超出限制的消息在 RabbitMQ Queue 中排队等待。
-     *
-     * @param channel amqplib Channel 实例
-     */
-    async configure(channel) {
-        await channel.prefetch(this.prefetchCount);
-    }
-    /**
-     * 获取配置的最大并发数
-     */
-    getMaxConcurrency() {
-        return this.prefetchCount;
-    }
-}
-// ─────────────────────────────────────────────
-// Semaphore — 内存级信号量
-// ─────────────────────────────────────────────
-/**
- * 内存信号量 — 用于本地并发控制
- *
- * 当无需依赖 RabbitMQ 时（如单进程内限流、测试场景），
- * 使用 Semaphore 控制并发执行数。
- *
- * 用法:
- * ```ts
- * const sem = new Semaphore(3);
- * await sem.acquire(); // 等待可用槽位
- * try {
- *   // 执行并发受限的操作
- * } finally {
- *   sem.release(); // 释放槽位
- * }
- * ```
- */
-export class Semaphore {
-    maxSlots;
-    currentSlots;
-    waitQueue = [];
-    /**
-     * @param maxConcurrency 最大并发数
-     */
-    constructor(maxConcurrency) {
-        if (maxConcurrency < 1) {
-            throw new Error(`maxConcurrency must be >= 1, got ${maxConcurrency}`);
-        }
-        this.maxSlots = maxConcurrency;
-        this.currentSlots = maxConcurrency;
-    }
-    /**
-     * 获取一个可用槽位。如果当前无可用槽位，则等待直到有释放。
-     */
-    acquire() {
-        if (this.currentSlots > 0) {
-            this.currentSlots--;
-            return Promise.resolve();
-        }
-        return new Promise((resolve) => {
-            this.waitQueue.push(resolve);
-        });
-    }
-    /**
-     * 释放一个槽位。如果有等待者，唤醒队列中最先等待的。
-     */
-    release() {
-        if (this.waitQueue.length > 0) {
-            const next = this.waitQueue.shift();
-            // 使用 microtask 调度，确保调用者的 finally 块先完成
-            Promise.resolve().then(next);
-        }
-        else {
-            this.currentSlots++;
-            if (this.currentSlots > this.maxSlots) {
-                this.currentSlots = this.maxSlots;
-            }
-        }
-    }
-    /**
-     * 当前可用槽位数
-     */
-    get availableSlots() {
-        return this.currentSlots;
-    }
-}

package/dist/common/queue-consumer.d.ts

@@ -1,125 +0,0 @@
-/**
- * RabbitMQ 队列消费者
- *
- * 从 RabbitMQ 队列中消费任务消息，分发给 Graph 引擎处理。
- * 通过 channel.prefetch(n) 控制并发：
- * - 最多同时处理 n 条未 ack 的消息
- * - 超出 prefetch 限制的消息留在 RabbitMQ Queue 中排队等待
- * - 不丢弃任何请求
- *
- * 整体 QPS = Pod 数 × prefetch
- *
- * @see Requirement 14 AC2: 系统通过消息消费者 prefetch 参数控制单 Agent 实例的并发上限
- * @see Requirement 14 AC3: 并发请求数超过 prefetch 限制时，系统将超出请求放入 Queue 排队等待，不丢弃请求
- */
-import type { Connection } from 'amqplib';
-/**
- * 任务消息体 — 从 RabbitMQ 队列中消费到的任务负载
- */
-export interface TaskMessage {
-    /** 任务唯一标识 */
-    taskId: string;
-    /** 目标 Agent（值为 agentCode；字段名保留 agentId 兼容存量消息） */
-    agentId: string;
-    /** 会话 ID */
-    sessionId: string;
-    /** 发起请求的用户 ID */
-    userId: string;
-    /** 用户输入内容 */
-    input: string;
-    /** 可选的执行配置 */
-    config?: Record<string, unknown>;
-}
-/**
- * 任务处理器 — 接收解析后的 TaskMessage，分发给 Graph 引擎执行
- *
- * 处理成功则 resolve，失败则 reject（消费者据此决定 ack/nack）。
- */
-export type TaskHandler = (message: TaskMessage) => Promise<void>;
-/**
- * QueueConsumer 配置选项
- */
-export interface QueueConsumerOptions {
-    /** 队列名称 */
-    queueName: string;
-    /** prefetch 数量 — 单实例最大并发消息处理数，默认 5 */
-    prefetch?: number;
-    /** 队列是否持久化，默认 true */
-    durable?: boolean;
-    /** 是否自动确认（不推荐生产使用），默认 false */
-    noAck?: boolean;
-}
-/**
- * RabbitMQ 队列消费者
- *
- * 核心设计：利用 RabbitMQ channel.prefetch 机制实现队列式溢出控制。
- * - consumer.prefetch(5) → 该 Channel 上最多持有 5 条未 ack 消息
- * - 第 6 条及后续消息自动留在 RabbitMQ Queue 中排队
- * - 只有当某条消息被 ack/nack 后，RabbitMQ 才推送下一条
- * - 保证不丢弃任何请求（queue-based overflow）
- *
- * 使用方式：
- * ```ts
- * const consumer = new QueueConsumer(connection, {
- *   queueName: 'agent.tasks.ai-bi',
- *   prefetch: 5,
- * }, async (msg) => {
- *   await graphEngine.execute(msg);
- * });
- *
- * await consumer.start();
- * // ... 优雅关闭
- * await consumer.stop();
- * ```
- */
-export declare class QueueConsumer {
-    private readonly connection;
-    private readonly options;
-    private readonly taskHandler;
-    private channel;
-    private consumerTag;
-    private started;
-    /**
-     * @param connection amqplib Connection 实例
-     * @param options 消费者配置
-     * @param taskHandler 任务处理函数 — 接收解析后的消息，分发给 Graph 引擎
-     */
-    constructor(connection: Connection, options: QueueConsumerOptions, taskHandler: TaskHandler);
-    /**
-     * 启动消费者
-     *
-     * 1. 创建 Channel
-     * 2. 设置 prefetch（限制并发）
-     * 3. 声明队列（确保队列存在）
-     * 4. 开始消费消息
-     *
-     * prefetch 机制保证：超出限制的消息留在 RabbitMQ Queue 排队，不丢弃。
-     */
-    start(): Promise<void>;
-    /**
-     * 停止消费者并优雅关闭 Channel
-     *
-     * 1. 取消消费（不再接收新消息）
-     * 2. 关闭 Channel
-     *
-     * 已在处理中的消息不受影响，会正常完成后 ack/nack。
-     */
-    stop(): Promise<void>;
-    /**
-     * 是否正在运行
-     */
-    get isRunning(): boolean;
-    /**
-     * 获取配置的 prefetch 值
-     */
-    get prefetch(): number;
-    /**
-     * 处理单条消息
-     *
-     * - 解析消息体为 TaskMessage
-     * - 调用 taskHandler 执行任务
-     * - 成功 → ack（释放 prefetch 槽位，RabbitMQ 推送下一条）
-     * - 失败 → nack + requeue（消息重新入队，稍后重试）
-     */
-    private handleMessage;
-}

package/dist/common/queue-consumer.js

@@ -1,159 +0,0 @@
-/**
- * RabbitMQ 队列消费者
- *
- * 从 RabbitMQ 队列中消费任务消息，分发给 Graph 引擎处理。
- * 通过 channel.prefetch(n) 控制并发：
- * - 最多同时处理 n 条未 ack 的消息
- * - 超出 prefetch 限制的消息留在 RabbitMQ Queue 中排队等待
- * - 不丢弃任何请求
- *
- * 整体 QPS = Pod 数 × prefetch
- *
- * @see Requirement 14 AC2: 系统通过消息消费者 prefetch 参数控制单 Agent 实例的并发上限
- * @see Requirement 14 AC3: 并发请求数超过 prefetch 限制时，系统将超出请求放入 Queue 排队等待，不丢弃请求
- */
-// ─────────────────────────────────────────────
-// QueueConsumer
-// ─────────────────────────────────────────────
-/** 默认 prefetch 值 */
-const DEFAULT_PREFETCH = 5;
-/**
- * RabbitMQ 队列消费者
- *
- * 核心设计：利用 RabbitMQ channel.prefetch 机制实现队列式溢出控制。
- * - consumer.prefetch(5) → 该 Channel 上最多持有 5 条未 ack 消息
- * - 第 6 条及后续消息自动留在 RabbitMQ Queue 中排队
- * - 只有当某条消息被 ack/nack 后，RabbitMQ 才推送下一条
- * - 保证不丢弃任何请求（queue-based overflow）
- *
- * 使用方式：
- * ```ts
- * const consumer = new QueueConsumer(connection, {
- *   queueName: 'agent.tasks.ai-bi',
- *   prefetch: 5,
- * }, async (msg) => {
- *   await graphEngine.execute(msg);
- * });
- *
- * await consumer.start();
- * // ... 优雅关闭
- * await consumer.stop();
- * ```
- */
-export class QueueConsumer {
-    connection;
-    options;
-    taskHandler;
-    channel = null;
-    consumerTag = null;
-    started = false;
-    /**
-     * @param connection amqplib Connection 实例
-     * @param options 消费者配置
-     * @param taskHandler 任务处理函数 — 接收解析后的消息，分发给 Graph 引擎
-     */
-    constructor(connection, options, taskHandler) {
-        this.connection = connection;
-        this.options = {
-            queueName: options.queueName,
-            prefetch: options.prefetch ?? DEFAULT_PREFETCH,
-            durable: options.durable ?? true,
-            noAck: options.noAck ?? false,
-        };
-        this.taskHandler = taskHandler;
-    }
-    /**
-     * 启动消费者
-     *
-     * 1. 创建 Channel
-     * 2. 设置 prefetch（限制并发）
-     * 3. 声明队列（确保队列存在）
-     * 4. 开始消费消息
-     *
-     * prefetch 机制保证：超出限制的消息留在 RabbitMQ Queue 排队，不丢弃。
-     */
-    async start() {
-        if (this.started) {
-            return;
-        }
-        // 1. 创建 Channel
-        this.channel = await this.connection.createChannel();
-        // 2. 设置 prefetch — 核心并发控制
-        // 超出 prefetch 的消息留在 Queue 中排队等待（queue-based overflow）
-        await this.channel.prefetch(this.options.prefetch);
-        // 3. 声明队列（幂等操作，队列已存在则不做修改）
-        await this.channel.assertQueue(this.options.queueName, {
-            durable: this.options.durable,
-        });
-        // 4. 开始消费
-        const { consumerTag } = await this.channel.consume(this.options.queueName, (msg) => this.handleMessage(msg), { noAck: this.options.noAck });
-        this.consumerTag = consumerTag;
-        this.started = true;
-    }
-    /**
-     * 停止消费者并优雅关闭 Channel
-     *
-     * 1. 取消消费（不再接收新消息）
-     * 2. 关闭 Channel
-     *
-     * 已在处理中的消息不受影响，会正常完成后 ack/nack。
-     */
-    async stop() {
-        if (!this.started || !this.channel) {
-            return;
-        }
-        // 取消消费者
-        if (this.consumerTag) {
-            await this.channel.cancel(this.consumerTag);
-            this.consumerTag = null;
-        }
-        // 关闭 Channel
-        await this.channel.close();
-        this.channel = null;
-        this.started = false;
-    }
-    /**
-     * 是否正在运行
-     */
-    get isRunning() {
-        return this.started;
-    }
-    /**
-     * 获取配置的 prefetch 值
-     */
-    get prefetch() {
-        return this.options.prefetch;
-    }
-    // ─── 内部方法 ───────────────────────────────
-    /**
-     * 处理单条消息
-     *
-     * - 解析消息体为 TaskMessage
-     * - 调用 taskHandler 执行任务
-     * - 成功 → ack（释放 prefetch 槽位，RabbitMQ 推送下一条）
-     * - 失败 → nack + requeue（消息重新入队，稍后重试）
-     */
-    async handleMessage(msg) {
-        // RabbitMQ 在 Channel 关闭时会发送 null
-        if (!msg || !this.channel) {
-            return;
-        }
-        try {
-            // 解析消息体
-            const body = msg.content.toString('utf-8');
-            const taskMessage = JSON.parse(body);
-            // 分发给 Graph 引擎处理
-            await this.taskHandler(taskMessage);
-            // 处理成功 → ack，释放 prefetch 槽位
-            if (!this.options.noAck) {
-                this.channel.ack(msg);
-            }
-        }
-        catch {
-            // 处理失败 → nack，requeue=true 让消息重新排队
-            if (!this.options.noAck && this.channel) {
-                this.channel.nack(msg, false, true);
-            }
-        }
-    }
-}

package/dist/tool/mock-tool-executor.d.ts

@@ -1,28 +0,0 @@
-/**
- * MockToolExecutor — 本地开发模式的模拟 Tool 执行器
- *
- * 定位：`eap dev --tool-mode mock` 场景下替代真实 Gateway/Local 执行器，
- * 让 Agent 开发者在无 foundation-service、无真实 Tool 依赖的前提下跑通 Graph。
- *
- * 响应查找顺序：
- * 1. `${toolsDir}/<toolName>/mock.json`（用户自定义 Mock 响应）
- * 2. `${toolsDir}/<toolName>/tool.manifest.json` 内嵌 `mockResponse` 字段
- * 3. 兜底 echo：`{ toolName, arguments, note: "mock" }`
- *
- * 使用示例：
- *   const executor = new MockToolExecutor({ toolsDir: './tools' });
- */
-import type { IToolExecutor, ToolCallRequest, ToolCallResult } from './tool-executor.interface.js';
-export interface MockToolExecutorOptions {
-    /** 本地 tools 根目录，默认 `./tools` 或读 `EAP_LOCAL_TOOLS_DIR` */
-    toolsDir?: string;
-    /** Mock 响应可自定义 delay，用于验证 SSE/流式表现 */
-    delayMs?: number;
-}
-export declare class MockToolExecutor implements IToolExecutor {
-    private readonly toolsDir;
-    private readonly delayMs;
-    constructor(options?: MockToolExecutorOptions);
-    execute(request: ToolCallRequest): Promise<ToolCallResult>;
-    private resolveMockResponse;
-}

package/dist/tool/mock-tool-executor.js

@@ -1,65 +0,0 @@
-/**
- * MockToolExecutor — 本地开发模式的模拟 Tool 执行器
- *
- * 定位：`eap dev --tool-mode mock` 场景下替代真实 Gateway/Local 执行器，
- * 让 Agent 开发者在无 foundation-service、无真实 Tool 依赖的前提下跑通 Graph。
- *
- * 响应查找顺序：
- * 1. `${toolsDir}/<toolName>/mock.json`（用户自定义 Mock 响应）
- * 2. `${toolsDir}/<toolName>/tool.manifest.json` 内嵌 `mockResponse` 字段
- * 3. 兜底 echo：`{ toolName, arguments, note: "mock" }`
- *
- * 使用示例：
- *   const executor = new MockToolExecutor({ toolsDir: './tools' });
- */
-import { readFile } from 'node:fs/promises';
-import path from 'node:path';
-async function readJsonFile(filePath) {
-    try {
-        const raw = await readFile(filePath, 'utf-8');
-        return JSON.parse(raw);
-    }
-    catch {
-        return undefined;
-    }
-}
-export class MockToolExecutor {
-    toolsDir;
-    delayMs;
-    constructor(options = {}) {
-        this.toolsDir =
-            options.toolsDir ?? process.env.EAP_LOCAL_TOOLS_DIR ?? './tools';
-        this.delayMs = options.delayMs ?? 0;
-    }
-    async execute(request) {
-        if (this.delayMs > 0) {
-            await new Promise((r) => setTimeout(r, this.delayMs));
-        }
-        const mockResponse = await this.resolveMockResponse(request.toolName);
-        const payload = mockResponse ?? {
-            toolName: request.toolName,
-            arguments: request.arguments,
-            note: 'mock: no explicit mockResponse found, echoing arguments',
-        };
-        return {
-            toolCallId: request.toolCallId,
-            toolName: request.toolName,
-            content: typeof payload === 'string' ? payload : JSON.stringify(payload),
-            success: true,
-            runtime: 'mock',
-        };
-    }
-    async resolveMockResponse(toolName) {
-        const toolDir = path.join(this.toolsDir, toolName);
-        // 优先级 1：独立 mock.json
-        const explicit = await readJsonFile(path.join(toolDir, 'mock.json'));
-        if (explicit !== undefined)
-            return explicit;
-        // 优先级 2：manifest 内嵌 mockResponse
-        const manifest = (await readJsonFile(path.join(toolDir, 'tool.manifest.json')));
-        if (manifest && manifest.mockResponse !== undefined) {
-            return manifest.mockResponse;
-        }
-        return undefined;
-    }
-}