@chen0825/aiapp-ability 0.1.1 → 0.1.2

package/lib/abilities/dingtalk/index.d.ts

@@ -0,0 +1,92 @@
+/**
+ * 钉钉能力模块
+ */
+import { BatchSendRobotMsgRequest, BatchSendResponse, RobotMsgKey } from '../../types/dingtalk';
+import { AbilityProvider } from '../../types';
+/**
+ * 简化的 Markdown 通知参数
+ */
+export interface MarkdownNotificationParams {
+    /** 接收者用户 ID 列表 */
+    userIds: string[];
+    /** 消息标题 */
+    title: string;
+    /** Markdown 格式的消息内容 */
+    text: string;
+}
+/**
+ * 通用批量发送参数
+ */
+export interface BatchNotificationParams<T extends RobotMsgKey = RobotMsgKey> {
+    /** 接收者用户 ID 列表 */
+    userIds: string[];
+    /** 消息类型 */
+    msgKey: T;
+    /** 消息参数 */
+    msgParam: Record<string, unknown>;
+}
+/**
+ * 钉钉能力提供者
+ *
+ * 必须配置以下环境变量：
+ * - DINGTALK_APP_KEY: 钉钉应用 AppKey
+ * - DINGTALK_APP_SECRET: 钉钉应用 AppSecret
+ * - DINGTALK_ROBOT_CODE: 钉钉机器人编码
+ * - DINGTALK_API_URL: 钉钉 API 基础 URL
+ */
+export declare class DingTalkProvider implements AbilityProvider {
+    readonly name = "dingtalk";
+    readonly version = "1.0.0";
+    private dingtalkApiClient;
+    constructor();
+    /**
+     * 获取 appKey
+     */
+    private getAppKey;
+    /**
+     * 获取 appSecret
+     */
+    private getAppSecret;
+    /**
+     * 获取机器人编码
+     */
+    private getRobotCode;
+    /**
+     * 获取 API 基础 URL
+     */
+    private getApiUrl;
+    /**
+     * 获取企业内部应用的 accessToken（每次调用都重新获取）
+     */
+    getAccessToken(): Promise<{
+        success: boolean;
+        accessToken?: string;
+        message?: string;
+    }>;
+    /**
+     * 批量发送机器人消息
+     */
+    batchSendRobotMessage<T extends RobotMsgKey>(params: BatchSendRobotMsgRequest<T>): Promise<BatchSendResponse>;
+    /**
+     * 分批发送机器人消息（超过20人时自动分批）
+     */
+    private batchSendInChunks;
+    /**
+     * 发送 Markdown 消息
+     */
+    sendMarkdownMessage(params: MarkdownNotificationParams): Promise<BatchSendResponse>;
+    /**
+     * 通用批量发送接口
+     */
+    sendBatchNotification<T extends RobotMsgKey>(params: BatchNotificationParams<T>): Promise<BatchSendResponse>;
+    /**
+     * 初始化（重新加载环境变量配置）
+     */
+    initialize(): Promise<void>;
+    /**
+     * 将数组分割成指定大小的块
+     */
+    private chunkArray;
+}
+/** 默认钉钉提供者实例 */
+export declare const dingtalkProvider: DingTalkProvider;

package/lib/abilities/dingtalk/index.js

@@ -0,0 +1,242 @@
+"use strict";
+/**
+ * 钉钉能力模块
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dingtalkProvider = exports.DingTalkProvider = void 0;
+const http_client_1 = require("../../core/http-client");
+const environment_1 = require("../../core/environment");
+/** 钉钉API批量发送限制：每次最多20人 */
+const BATCH_SEND_LIMIT = 20;
+/**
+ * 钉钉能力提供者
+ *
+ * 必须配置以下环境变量：
+ * - DINGTALK_APP_KEY: 钉钉应用 AppKey
+ * - DINGTALK_APP_SECRET: 钉钉应用 AppSecret
+ * - DINGTALK_ROBOT_CODE: 钉钉机器人编码
+ * - DINGTALK_API_URL: 钉钉 API 基础 URL
+ */
+class DingTalkProvider {
+    constructor() {
+        this.name = 'dingtalk';
+        this.version = '1.0.0';
+        const envConfig = (0, environment_1.getDingTalkEnvConfig)();
+        this.dingtalkApiClient = new http_client_1.HttpClient(envConfig.apiUrl || 'https://api.dingtalk.com');
+    }
+    /**
+     * 获取 appKey
+     */
+    getAppKey() {
+        return (0, environment_1.getDingTalkEnvConfig)().appKey;
+    }
+    /**
+     * 获取 appSecret
+     */
+    getAppSecret() {
+        return (0, environment_1.getDingTalkEnvConfig)().appSecret;
+    }
+    /**
+     * 获取机器人编码
+     */
+    getRobotCode() {
+        return (0, environment_1.getDingTalkEnvConfig)().robotCode;
+    }
+    /**
+     * 获取 API 基础 URL
+     */
+    getApiUrl() {
+        return (0, environment_1.getDingTalkEnvConfig)().apiUrl || 'https://api.dingtalk.com';
+    }
+    /**
+     * 获取企业内部应用的 accessToken（每次调用都重新获取）
+     */
+    async getAccessToken() {
+        const appKey = this.getAppKey();
+        const appSecret = this.getAppSecret();
+        if (!appKey || !appSecret) {
+            return {
+                success: false,
+                message: '未配置环境变量 DINGTALK_APP_KEY 或 DINGTALK_APP_SECRET',
+            };
+        }
+        try {
+            const response = await fetch(`${this.getApiUrl()}/v1.0/oauth2/accessToken`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({ appKey, appSecret }),
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                console.error('获取 accessToken 失败:', errorText);
+                return {
+                    success: false,
+                    message: `获取 accessToken 失败: ${response.status}`,
+                };
+            }
+            const data = await response.json();
+            if (!data.accessToken) {
+                return {
+                    success: false,
+                    message: '获取 accessToken 失败: 响应中无 accessToken',
+                };
+            }
+            return {
+                success: true,
+                accessToken: data.accessToken,
+            };
+        }
+        catch (error) {
+            console.error('获取 accessToken 异常:', error);
+            return {
+                success: false,
+                message: error instanceof Error ? error.message : '获取 accessToken 异常',
+            };
+        }
+    }
+    /**
+     * 批量发送机器人消息
+     */
+    async batchSendRobotMessage(params) {
+        const tokenResult = await this.getAccessToken();
+        if (!tokenResult.success || !tokenResult.accessToken) {
+            return {
+                success: false,
+                message: tokenResult.message || '获取 accessToken 失败',
+            };
+        }
+        if (!params.userIds || params.userIds.length === 0) {
+            return {
+                success: false,
+                message: '接收者列表不能为空',
+            };
+        }
+        if (params.userIds.length > BATCH_SEND_LIMIT) {
+            return this.batchSendInChunks(params);
+        }
+        try {
+            const result = await this.dingtalkApiClient.post('/v1.0/robot/oToMessages/batchSend', params, {
+                headers: {
+                    'x-acs-dingtalk-access-token': tokenResult.accessToken,
+                },
+            });
+            if (!result.success) {
+                return {
+                    success: false,
+                    message: result.message || '批量发送机器人消息失败',
+                    data: result.data,
+                };
+            }
+            return {
+                success: true,
+                message: '批量发送成功',
+                data: result.data,
+                successCount: params.userIds.length,
+                failCount: 0,
+            };
+        }
+        catch (error) {
+            console.error('批量发送机器人消息异常:', error);
+            return {
+                success: false,
+                message: error instanceof Error ? error.message : '批量发送机器人消息异常',
+                failedUserIds: params.userIds,
+            };
+        }
+    }
+    /**
+     * 分批发送机器人消息（超过20人时自动分批）
+     */
+    async batchSendInChunks(params) {
+        const { userIds, ...restParams } = params;
+        const chunks = this.chunkArray(userIds, BATCH_SEND_LIMIT);
+        const failedUserIds = [];
+        let successCount = 0;
+        let failCount = 0;
+        for (const chunk of chunks) {
+            const chunkParams = {
+                ...restParams,
+                userIds: chunk,
+            };
+            const result = await this.batchSendRobotMessage(chunkParams);
+            if (result.success) {
+                successCount += chunk.length;
+            }
+            else {
+                failCount += chunk.length;
+                failedUserIds.push(...chunk);
+            }
+        }
+        const allSuccess = failCount === 0;
+        return {
+            success: allSuccess,
+            message: allSuccess
+                ? `批量发送成功，共 ${successCount} 人`
+                : `部分发送失败，成功 ${successCount} 人，失败 ${failCount} 人`,
+            successCount,
+            failCount,
+            failedUserIds: failedUserIds.length > 0 ? failedUserIds : undefined,
+        };
+    }
+    /**
+     * 发送 Markdown 消息
+     */
+    async sendMarkdownMessage(params) {
+        const robotCode = this.getRobotCode();
+        if (!robotCode) {
+            return {
+                success: false,
+                message: '未配置环境变量 DINGTALK_ROBOT_CODE',
+            };
+        }
+        return this.batchSendRobotMessage({
+            robotCode,
+            userIds: params.userIds,
+            msgKey: 'sampleMarkdown',
+            msgParam: JSON.stringify({
+                title: params.title,
+                text: params.text,
+            }),
+        });
+    }
+    /**
+     * 通用批量发送接口
+     */
+    async sendBatchNotification(params) {
+        const robotCode = this.getRobotCode();
+        if (!robotCode) {
+            return {
+                success: false,
+                message: '未配置环境变量 DINGTALK_ROBOT_CODE',
+            };
+        }
+        return this.batchSendRobotMessage({
+            robotCode,
+            userIds: params.userIds,
+            msgKey: params.msgKey,
+            msgParam: JSON.stringify(params.msgParam),
+        });
+    }
+    /**
+     * 初始化（重新加载环境变量配置）
+     */
+    async initialize() {
+        const envConfig = (0, environment_1.getDingTalkEnvConfig)();
+        this.dingtalkApiClient = new http_client_1.HttpClient(envConfig.apiUrl || 'https://api.dingtalk.com');
+    }
+    /**
+     * 将数组分割成指定大小的块
+     */
+    chunkArray(array, size) {
+        const chunks = [];
+        for (let i = 0; i < array.length; i += size) {
+            chunks.push(array.slice(i, i + size));
+        }
+        return chunks;
+    }
+}
+exports.DingTalkProvider = DingTalkProvider;
+/** 默认钉钉提供者实例 */
+exports.dingtalkProvider = new DingTalkProvider();

package/lib/abilities/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * 能力模块统一导出
+ */
+export * from './dingtalk';
+export * from './registry';

package/lib/abilities/index.js

@@ -0,0 +1,21 @@
+"use strict";
+/**
+ * 能力模块统一导出
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./dingtalk"), exports);
+__exportStar(require("./registry"), exports);

package/lib/abilities/registry.d.ts

@@ -0,0 +1,69 @@
+/**
+ * 能力注册表模块
+ */
+import { AbilityProvider } from '../types';
+/**
+ * 能力注册表配置
+ */
+export interface AbilityRegistryConfig {
+    /** 是否启用日志 */
+    enableLogging?: boolean;
+    /** 默认超时时间 */
+    defaultTimeout?: number;
+}
+/**
+ * 能力注册表
+ */
+export declare class AbilityRegistry {
+    private providers;
+    private config;
+    constructor(config?: AbilityRegistryConfig);
+    /**
+     * 注册能力提供者
+     * @param provider 能力提供者
+     */
+    register(provider: AbilityProvider): void;
+    /**
+     * 批量注册能力提供者
+     * @param providers 能力提供者数组
+     */
+    registerAll(providers: AbilityProvider[]): void;
+    /**
+     * 获取能力提供者
+     * @param name 提供者名称
+     */
+    get<T extends AbilityProvider = AbilityProvider>(name: string): T | undefined;
+    /**
+     * 检查能力提供者是否已注册
+     * @param name 提供者名称
+     */
+    has(name: string): boolean;
+    /**
+     * 获取所有已注册的提供者名称
+     */
+    getNames(): string[];
+    /**
+     * 获取所有已注册的提供者
+     */
+    getAll(): AbilityProvider[];
+    /**
+     * 注销能力提供者
+     * @param name 提供者名称
+     */
+    unregister(name: string): boolean;
+    /**
+     * 清空所有能力提供者
+     */
+    clear(): void;
+    /**
+     * 初始化所有已注册的提供者
+     */
+    initializeAll(): Promise<void>;
+    /**
+     * 销毁所有已注册的提供者
+     */
+    destroyAll(): Promise<void>;
+    private log;
+}
+/** 默认能力注册表实例 */
+export declare const defaultRegistry: AbilityRegistry;

package/lib/abilities/registry.js

@@ -0,0 +1,111 @@
+"use strict";
+/**
+ * 能力注册表模块
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultRegistry = exports.AbilityRegistry = void 0;
+/**
+ * 能力注册表
+ */
+class AbilityRegistry {
+    constructor(config = {}) {
+        this.providers = new Map();
+        this.config = {
+            enableLogging: false,
+            defaultTimeout: 30000,
+            ...config,
+        };
+    }
+    /**
+     * 注册能力提供者
+     * @param provider 能力提供者
+     */
+    register(provider) {
+        if (this.providers.has(provider.name)) {
+            throw new Error(`Provider "${provider.name}" is already registered`);
+        }
+        this.providers.set(provider.name, provider);
+        this.log(`Registered provider: ${provider.name}`);
+    }
+    /**
+     * 批量注册能力提供者
+     * @param providers 能力提供者数组
+     */
+    registerAll(providers) {
+        for (const provider of providers) {
+            this.register(provider);
+        }
+    }
+    /**
+     * 获取能力提供者
+     * @param name 提供者名称
+     */
+    get(name) {
+        return this.providers.get(name);
+    }
+    /**
+     * 检查能力提供者是否已注册
+     * @param name 提供者名称
+     */
+    has(name) {
+        return this.providers.has(name);
+    }
+    /**
+     * 获取所有已注册的提供者名称
+     */
+    getNames() {
+        return Array.from(this.providers.keys());
+    }
+    /**
+     * 获取所有已注册的提供者
+     */
+    getAll() {
+        return Array.from(this.providers.values());
+    }
+    /**
+     * 注销能力提供者
+     * @param name 提供者名称
+     */
+    unregister(name) {
+        const result = this.providers.delete(name);
+        if (result) {
+            this.log(`Unregistered provider: ${name}`);
+        }
+        return result;
+    }
+    /**
+     * 清空所有能力提供者
+     */
+    clear() {
+        this.providers.clear();
+        this.log('Cleared all providers');
+    }
+    /**
+     * 初始化所有已注册的提供者
+     */
+    async initializeAll() {
+        for (const provider of this.providers.values()) {
+            if (provider.initialize) {
+                await provider.initialize();
+            }
+        }
+    }
+    /**
+     * 销毁所有已注册的提供者
+     */
+    async destroyAll() {
+        for (const provider of this.providers.values()) {
+            if (provider.destroy) {
+                await provider.destroy();
+            }
+        }
+    }
+    log(message) {
+        if (this.config.enableLogging) {
+            console.log(`[AbilityRegistry] ${message}`);
+        }
+    }
+}
+exports.AbilityRegistry = AbilityRegistry;
+/** 默认能力注册表实例 */
+exports.defaultRegistry = new AbilityRegistry();

package/lib/core/environment.d.ts

@@ -0,0 +1,47 @@
+/**
+ * 环境配置模块
+ */
+export interface EnvironmentConfig {
+    /** API 基础 URL */
+    apiUrl: string;
+    /** 当前环境 */
+    env: 'development' | 'production';
+    /** 应用 ID */
+    appId?: string;
+    /** 用户 ID */
+    userId?: string;
+    /** 租户 ID */
+    tenantId?: string;
+}
+/**
+ * 钉钉环境配置
+ */
+export interface DingTalkEnvConfig {
+    /** 钉钉应用 AppKey */
+    appKey?: string;
+    /** 钉钉应用 AppSecret */
+    appSecret?: string;
+    /** 钉钉机器人编码 */
+    robotCode?: string;
+    /** 钉钉 API 基础 URL */
+    apiUrl?: string;
+}
+/**
+ * 获取环境配置
+ * @returns 环境配置对象
+ */
+export declare function getEnvironmentConfig(): EnvironmentConfig;
+/**
+ * 设置环境配置
+ * @param config 部分配置
+ */
+export declare function setEnvironmentConfig(config: Partial<EnvironmentConfig>): void;
+/**
+ * 重置环境配置为默认值
+ */
+export declare function resetEnvironmentConfig(): void;
+/**
+ * 获取钉钉环境配置（从环境变量）
+ * @returns 钉钉环境配置对象
+ */
+export declare function getDingTalkEnvConfig(): DingTalkEnvConfig;

package/lib/core/environment.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDingTalkEnvConfig = exports.resetEnvironmentConfig = exports.setEnvironmentConfig = exports.getEnvironmentConfig = void 0;
+/**
+ * 默认环境配置
+ */
+const defaultConfig = {
+    apiUrl: process.env.API_URL || '',
+    env: process.env.NODE_ENV || 'development',
+    appId: process.env.APP_ID,
+    userId: process.env.USER_ID,
+    tenantId: process.env.TENANT_ID,
+};
+/** 当前环境配置 */
+let currentConfig = { ...defaultConfig };
+/**
+ * 获取环境配置
+ * @returns 环境配置对象
+ */
+function getEnvironmentConfig() {
+    return { ...currentConfig };
+}
+exports.getEnvironmentConfig = getEnvironmentConfig;
+/**
+ * 设置环境配置
+ * @param config 部分配置
+ */
+function setEnvironmentConfig(config) {
+    currentConfig = { ...currentConfig, ...config };
+}
+exports.setEnvironmentConfig = setEnvironmentConfig;
+/**
+ * 重置环境配置为默认值
+ */
+function resetEnvironmentConfig() {
+    currentConfig = { ...defaultConfig };
+}
+exports.resetEnvironmentConfig = resetEnvironmentConfig;
+/**
+ * 获取钉钉环境配置（从环境变量）
+ * @returns 钉钉环境配置对象
+ */
+function getDingTalkEnvConfig() {
+    return {
+        appKey: process.env.DINGTALK_APP_KEY,
+        appSecret: process.env.DINGTALK_APP_SECRET,
+        robotCode: process.env.DINGTALK_ROBOT_CODE,
+        apiUrl: process.env.DINGTALK_API_URL,
+    };
+}
+exports.getDingTalkEnvConfig = getDingTalkEnvConfig;

package/lib/core/http-client.d.ts

@@ -0,0 +1,16 @@
+import { BaseResponse } from "../types";
+/**
+ * HTTP 请求客户端
+ */
+export declare class HttpClient {
+    private baseUrl;
+    constructor(baseUrl: string);
+    /**
+     * 发送 POST 请求
+     */
+    post<T = any>(endpoint: string, data: any, options?: RequestInit): Promise<BaseResponse<T>>;
+    /**
+     * 发送 GET 请求
+     */
+    get<T = any>(endpoint: string, options?: RequestInit): Promise<BaseResponse<T>>;
+}

package/lib/core/http-client.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpClient = void 0;
+/**
+ * HTTP 请求客户端
+ */
+class HttpClient {
+    constructor(baseUrl) {
+        this.baseUrl = baseUrl;
+    }
+    /**
+     * 发送 POST 请求
+     */
+    async post(endpoint, data, options) {
+        try {
+            const response = await fetch(`${this.baseUrl}${endpoint}`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    ...options?.headers,
+                },
+                body: JSON.stringify(data),
+                ...options,
+            });
+            if (!response.ok) {
+                return {
+                    success: false,
+                    message: "请求异常",
+                    data: undefined,
+                };
+            }
+            const result = await response.json();
+            return result;
+        }
+        catch (error) {
+            console.error("HTTP请求失败：", error);
+            return {
+                success: false,
+                message: error instanceof Error ? error.message : "请求失败",
+                data: undefined,
+            };
+        }
+    }
+    /**
+     * 发送 GET 请求
+     */
+    async get(endpoint, options) {
+        try {
+            const response = await fetch(`${this.baseUrl}${endpoint}`, {
+                method: "GET",
+                headers: {
+                    "Content-Type": "application/json",
+                    ...options?.headers,
+                },
+                ...options,
+            });
+            if (!response.ok) {
+                return {
+                    success: false,
+                    message: "请求异常",
+                    data: undefined,
+                };
+            }
+            const result = await response.json();
+            return result;
+        }
+        catch (error) {
+            console.error("HTTP请求失败：", error);
+            return {
+                success: false,
+                message: error instanceof Error ? error.message : "请求失败",
+                data: undefined,
+            };
+        }
+    }
+}
+exports.HttpClient = HttpClient;

package/lib/core/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * 核心模块统一导出
+ */
+export * from './http-client';
+export * from './environment';

package/lib/core/index.js

@@ -0,0 +1,21 @@
+"use strict";
+/**
+ * 核心模块统一导出
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./http-client"), exports);
+__exportStar(require("./environment"), exports);

package/lib/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @ali/aiapp-ability
+ * AI应用能力包
+ */
+export * from './types';
+export * from './core';
+export * from './abilities';
+export default function main(): string;

package/lib/index.js

@@ -0,0 +1,30 @@
+"use strict";
+/**
+ * @ali/aiapp-ability
+ * AI应用能力包
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// 导出类型
+__exportStar(require("./types"), exports);
+// 导出核心模块
+__exportStar(require("./core"), exports);
+// 导出能力模块
+__exportStar(require("./abilities"), exports);
+function main() {
+    return 'Write your own legend...';
+}
+exports.default = main;

package/lib/types/dingtalk.d.ts

@@ -0,0 +1,80 @@
+/**
+ * 钉钉能力相关类型定义
+*/
+/**
+ * 获取 AccessToken 请求参数
+ */
+export interface GetAccessTokenRequest {
+    /** 已创建的企业内部应用的 AppKey */
+    appKey: string;
+    /** 已创建的企业内部应用的 AppSecret */
+    appSecret: string;
+}
+/**
+ * 获取 AccessToken 响应
+ */
+export interface GetAccessTokenResponse {
+    /** 生成的 accessToken */
+    accessToken: string;
+    /** accessToken 的过期时间，单位秒 */
+    expireIn: number;
+}
+/**
+ * 批量发送机器人消息的消息类型
+  */
+export declare type RobotMsgKey = 'sampleMarkdown';
+/**
+ * 批量发送机器人消息请求参数
+ * @see POST /v1.0/robot/oToMessages/batchSend
+ */
+export interface BatchSendRobotMsgRequest<T extends RobotMsgKey = RobotMsgKey> {
+    /** 机器人的编码 */
+    robotCode: string;
+    /** 接收消息的用户 userId 列表，最多支持 20 人 */
+    userIds: string[];
+    /** 消息模板 key */
+    msgKey: T;
+    /** 消息模板动态参数（JSON 字符串） */
+    msgParam: string;
+}
+/**
+ * 批量发送机器人消息响应
+ */
+export interface BatchSendRobotMsgResponse {
+    /** 处理结果列表 */
+    sendResults?: BatchSendResult[];
+    /** 流程 ID */
+    processQueryKey?: string;
+    /** 被限流的用户列表 */
+    flowControlledStaffIdList?: string[];
+}
+/**
+ * 批量发送结果
+ */
+export interface BatchSendResult {
+    /** 用户 ID */
+    staffId: string;
+    /** 是否成功 */
+    success: boolean;
+    /** 错误码 */
+    errorCode?: string;
+    /** 错误信息 */
+    errorMsg?: string;
+}
+/**
+ * 批量发送响应
+ */
+export interface BatchSendResponse {
+    /** 是否成功 */
+    success: boolean;
+    /** 消息 */
+    message?: string;
+    /** 发送结果详情 */
+    data?: BatchSendRobotMsgResponse;
+    /** 失败的用户列表 */
+    failedUserIds?: string[];
+    /** 发送成功的数量 */
+    successCount?: number;
+    /** 发送失败的数量 */
+    failCount?: number;
+}

package/lib/types/dingtalk.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * 钉钉能力相关类型定义
+*/
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/index.d.ts

@@ -0,0 +1,21 @@
+/**
+ * 类型定义统一导出
+ */
+export * from './dingtalk';
+/**
+ * 通用响应接口
+ */
+export interface BaseResponse<T = any> {
+    success: boolean;
+    message?: string;
+    data?: T;
+}
+/**
+ * 能力提供者基础接口
+ */
+export interface AbilityProvider {
+    name: string;
+    version: string;
+    initialize?(config?: any): Promise<void> | void;
+    destroy?(): Promise<void> | void;
+}

package/lib/types/index.js

@@ -0,0 +1,21 @@
+"use strict";
+/**
+ * 类型定义统一导出
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// 导出钉钉相关类型
+__exportStar(require("./dingtalk"), exports);

package/lib/utils/index.js

@@ -0,0 +1 @@
+"use strict";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chen0825/aiapp-ability",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "aiapp能力包",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",