@glodon-aiot/agent-cli-sdk 3.0.9 → 3.0.10-beta.1

package/cdn/src/AgentPlugin.d.ts

@@ -0,0 +1,17 @@
+import { AgentPluginRegistor } from '.';
+/**
+ * Class AgentPlugin
+ * 提供获取插件数据、检测客户端插件等功能
+ */
+interface AgentPluginDetails {
+}
+export default class AgentPlugin {
+    code: string;
+    description: string;
+    loaded: boolean;
+    functions: AgentPluginRegistor;
+    constructor(code: any, functions?: AgentPluginRegistor, initalData?: AgentPluginDetails);
+    fetchData(): void;
+    checkFunctions(): void;
+}
+export {};

package/cdn/src/AgentSession.d.ts

@@ -0,0 +1,9 @@
+import { IApplication, ISession } from '@glodon-aiot/apis';
+import Session, { QuestionBody, QuestionConfig } from './Session';
+import BotClient from './BotClient';
+export default class AgentSession extends Session {
+    constructor(token: string, _id?: string, _data?: Partial<ISession>, lazyload?: boolean, application?: IApplication, client?: BotClient);
+    prepareConnection(): Promise<boolean>;
+    sendQuestion(questionBody: QuestionBody, configs: QuestionConfig): Promise<false | undefined>;
+    stopAnswer(): void;
+}

package/cdn/src/BotClient.d.ts

@@ -0,0 +1,48 @@
+import Session from './Session';
+import { BotClientConfig } from './Config';
+import { IApplication, IPrompt, ISession, ISessionPrompt, SessionQueryParams } from '@glodon-aiot/apis';
+import EventBus from './EventBus';
+export type ClientEventName = 'ready' | 'application:loaded';
+export default class BotClient {
+    private _token;
+    private lazyload;
+    protected event: EventBus;
+    private cvforceApi;
+    private _applicationId;
+    private _application;
+    private _sessions;
+    private _activeSession?;
+    private _ready?;
+    private _questionContextMaxLength?;
+    private _promptVariables?;
+    constructor(_token: string, //AIoT resource token
+    configs: BotClientConfig, lazyload?: boolean);
+    private checkReady;
+    get ready(): boolean | undefined;
+    private set ready(value);
+    get questionContextMaxLength(): number | undefined;
+    get promptVariables(): IPrompt[] | undefined;
+    get knowledges(): any;
+    get sessions(): Session[];
+    set sessions(v: Session[]);
+    private loadApplication;
+    private getService;
+    get token(): string;
+    set token(v: string);
+    get applicationId(): string;
+    get application(): IApplication | null;
+    get activeSession(): string;
+    set activeSession(sessionId: string);
+    private createSession;
+    getSessions(queryParams?: SessionQueryParams): Promise<Session[]>;
+    loadSession(sessionId?: string, sessionParams?: Partial<ISession & {
+        promptVariables?: ISessionPrompt[];
+    }>): Promise<Session>;
+    reload(): Promise<this>;
+    reloadSession(sessionId?: string): Promise<Session | undefined>;
+    setTop(sessionId: string, top: boolean, order?: string): Promise<Session[] | undefined>;
+    addEventListener(eventName: ClientEventName, callback: any, once?: boolean): void;
+    removeEventListener(eventName: ClientEventName, callback: any): void;
+    removeSession(session: string | Session, deleteFromRemote?: boolean): Promise<void>;
+    clean(): void;
+}

package/cdn/src/Config.d.ts

@@ -0,0 +1,32 @@
+export interface BotClientConfig {
+    debug?: boolean;
+    env?: Env;
+    applicationId?: string;
+    plugins?: AgentPluginMap;
+    apiRoot?: string;
+}
+export interface AgentPluginRegistor {
+    [key: string]: Function;
+}
+export interface AgentPluginMap {
+    [pluginCode: string]: AgentPluginRegistor;
+}
+export type Env = 'dev' | 'test' | 'prod' | 'local';
+export declare enum ApiUrl {
+    dev = "https://aiot-dev.glodon.com/api/cvforcepd",
+    test = "https://aiot-dev.glodon.com/api/cvforce",
+    prod = "https://copilot.glodon.com/api/cvforce",
+    local = "http://localhost:3000/api/cvforcepd"
+}
+export declare let configuration: {
+    debug: boolean;
+    env: string;
+    apiRoot: string;
+    applicationId: string;
+    plugins: AgentPluginMap;
+};
+/**
+ * 配置SDK，可以在SDK被使用前被调用，该方法被调用后将改变是否debug模式、是否测试环境等基本配置
+ * @param param {debug?: boolean; env?: 'dev' | 'test' | 'prod';}
+ */
+export declare function configure(param?: BotClientConfig): void;

package/cdn/src/DialogSession.d.ts

@@ -0,0 +1,22 @@
+import { IApplication, ISession } from '@glodon-aiot/apis';
+import Session, { QuestionBody, QuestionConfig } from './Session';
+import BotClient from './BotClient';
+export default class DialogSession extends Session {
+    private ctrl;
+    constructor(token: string, _id?: string, _data?: Partial<ISession>, lazyload?: boolean, application?: IApplication, client?: BotClient);
+    prepareConnection(): Promise<boolean>;
+    postChatV2EventSource(applicationId: string, sessionId: string, params: any, signal: AbortSignal, options: {
+        onopen?: any;
+        onmessage?: any;
+        onerror?: any;
+        onclose?: any;
+    }, onAppStatusError?: (error: any) => void): Promise<void>;
+    postChatV3EventSource(applicationId: string, sessionId: string, params: any, signal: AbortSignal, options: {
+        onopen?: any;
+        onmessage?: any;
+        onerror?: any;
+        onclose?: any;
+    }, onAppStatusError?: (error: any) => void): Promise<void>;
+    sendQuestion(questionBody: QuestionBody, configs: QuestionConfig): Promise<void>;
+    stopAnswer(): void;
+}

package/cdn/src/EventBus.d.ts

@@ -0,0 +1,23 @@
+type Topic = string;
+export interface ViewerEvent {
+    topic: Topic;
+    payload?: any;
+}
+export type EventListener = (e: any) => void;
+interface SingleEventListener {
+    fn: EventListener;
+    once: true;
+}
+export default class EventBus {
+    private eventListenerMap;
+    constructor(disableLog?: boolean);
+    getEventListenerMap(): {
+        [x: string]: (SingleEventListener | EventListener)[];
+    };
+    on(topic: Topic, listener: EventListener, once?: boolean): void;
+    once(topic: Topic, listener: EventListener): void;
+    off(topic: Topic, listener: EventListener): void;
+    emit(topic: Topic, payload?: any): void;
+    removeAllListeners(): void;
+}
+export {};

package/cdn/src/Logger.d.ts

@@ -0,0 +1,12 @@
+export default class Logger {
+    private prefix;
+    private open;
+    static debug: boolean;
+    constructor(prefix: string, open?: boolean);
+    disable(): void;
+    enable(): void;
+    log(...rest: any[]): void;
+    info(...rest: any[]): void;
+    error(...rest: any[]): void;
+    warn(...rest: any[]): void;
+}

package/cdn/src/PayloadTypes.d.ts

@@ -0,0 +1,84 @@
+export declare enum UserMode {
+    Normal = 0,
+    Debug = 1
+}
+export interface ReadyEventPayload {
+    /**
+     * 错误码如下：
+     * 200: 成功
+     * 11903: 密钥失效
+     * 11904: 参数异常
+     * 11905: token解析异常
+     * 11907: 未知错误
+     * 11913: 获取应用编排数据失败
+     * 11914: 获取大模型服务失败, 请检查
+     * 11924: 用户无此应用权限
+     */
+    code: number;
+    message: string;
+    userMode: UserMode;
+}
+export interface PluginFunctionBasic {
+    pluginName: string;
+    pluginCode: string;
+    funcCode: string;
+    funcName: string;
+    parameters?: {
+        header: any;
+        query: any;
+    };
+    requestBody?: any;
+    runnerIsClient?: boolean;
+    result?: {
+        code: number;
+        message: string;
+        data: any;
+    };
+}
+export interface PluginFunctionBeforeCall extends PluginFunctionBasic {
+    parameters: {
+        header: any;
+        query: any;
+    };
+    requestBody: any;
+}
+export interface PluginFunctionCall extends PluginFunctionBasic {
+    parameters: {
+        header: any;
+        query: any;
+    };
+    requestBody: any;
+    runnerIsClient: boolean;
+}
+export interface PluginFunctionResult extends PluginFunctionBasic {
+    result: {
+        code: number;
+        message: string;
+        data: any;
+    };
+}
+export interface Thought {
+    step: number;
+    thought?: string;
+    observation?: string;
+}
+export interface BeforeCalldData extends Thought, PluginFunctionBeforeCall {
+    thought: string;
+    observation: undefined;
+}
+export interface FunctionCallData extends Thought, PluginFunctionCall {
+    thought: string;
+    observation: undefined;
+}
+export interface CallResultData extends Thought, PluginFunctionResult {
+    thought: undefined;
+    observation: undefined;
+}
+export interface AfterCallData extends Thought, PluginFunctionBasic {
+    thought: undefined;
+    observation: string;
+}
+export interface ActionPayload<T> {
+    type: 'BEFORE_CALL' | 'FUNCTION_CALL' | 'RESULT' | 'AFTER_CALL';
+    data: T;
+}

package/cdn/src/Session.d.ts

@@ -0,0 +1,209 @@
+import { ChatMessageRole, IApplication, IChatMessage, ICommentParam, ISession, ISessionPrompt } from '@glodon-aiot/apis';
+import { Socket } from 'socket.io-client';
+import EventBus from './EventBus';
+import { ActionPayload, PluginFunctionBasic, Thought } from './PayloadTypes';
+import { CVForceApi } from '@glodon-aiot/apis';
+import { ChatHistoryParams, IKnowledge } from '@glodon-aiot/apis';
+import BotClient from './BotClient';
+export declare enum NetOpen {
+    enable = 1,
+    disable = 2
+}
+export interface QuestionBody {
+    content: string;
+    stream: boolean;
+    requestId?: string;
+    fileIds?: string[];
+    oldMessageId?: string;
+    referenceFirst?: boolean;
+}
+export interface QuestionConfig {
+    stream?: boolean;
+    referenceFirst?: boolean;
+    formatValues?: any;
+    oldMessageId?: string;
+}
+type ActionPayloadBasic = ActionPayload<PluginFunctionBasic & Thought>;
+export type SessionEventName = 'init' | 'ready' | 'activated' | 'inactivated' | 'frozen' | 'data:loading' | 'data:loaded' | 'data:updating' | 'data:updated' | 'data:updated:promptVariables' | 'data:updated:knowledges' | 'data:creating' | 'data:created' | 'data:deleting' | 'data:deleted' | 'socket:connect' | 'socket:disconnect' | 'error' | 'destroy' | 'history:loading' | 'history:loaded' | 'history:moreloading' | 'history:moreloaded' | 'history:add' | 'message:new' | 'message:updated' | 'message:action' | 'message:content' | 'message:reference' | 'message:relatedQuesion:loading' | 'message:relatedQuesion:loaded' | 'message:comment' | 'message:error' | 'answer:finish';
+export declare enum SessionErrors {
+    DataRequestFailed = "data request error",
+    SocketConnectionFailed = "socket error",
+    IdUndefined = "session id is not defined",
+    SendingEmptyContent = "failed at sending empty content",
+    Frozen = "session is frozen",
+    UserModeError = "failed at setting socket user mode",
+    Inactive = "session is inactive"
+}
+export declare const SESSION_ERROR_CAUSE: {
+    "session id is not defined": {
+        code: number;
+        message: string;
+    };
+    "failed at sending empty content": {
+        code: number;
+        message: string;
+    };
+    "session is frozen": {
+        code: number;
+        message: string;
+    };
+};
+export default abstract class Session {
+    protected token: string;
+    protected lazyload?: boolean | undefined;
+    protected _id?: string;
+    protected _frozen: boolean;
+    protected inactivating: boolean;
+    protected _ready: boolean;
+    protected event: EventBus;
+    _applicationId: string;
+    _application: IApplication | null;
+    data: ISession | null;
+    readonly client: BotClient | null;
+    messages: IChatMessage[];
+    protected _loadingMessages: boolean;
+    protected _loadingMessagesSize: number;
+    cvforceApi: CVForceApi;
+    socket: Socket | null;
+    protected _promptVariables: ISessionPrompt[];
+    protected active: boolean;
+    protected activing: boolean;
+    protected _stopAnswer: boolean;
+    private _dataLoading;
+    private _dataLoaded;
+    /**
+     * Session 类的构造函数，用于初始化会话实例。
+     * @param token - 用户的身份验证令牌，用于解析应用 ID。
+     * @param _id - 会话的 ID，可选参数，默认为空字符串。
+     * @param _data - 会话的初始数据，可选参数，包含提示变量、知识库等信息。
+     * @param lazyload - 是否懒加载数据，可选参数，默认为 undefined。
+     * @param _application - 应用信息，可选参数。
+     * @param client - Bot 客户端实例，可选参数。
+     */
+    constructor(token: string, _id?: string, _data?: Partial<ISession & {
+        promptVariables?: Partial<ISessionPrompt>[];
+    }>, lazyload?: boolean | undefined, _application?: IApplication, client?: BotClient);
+    fetchData(): Promise<ISession>;
+    get id(): string;
+    get applicationId(): string;
+    get application(): IApplication | null;
+    loadApplicationInfo(): Promise<IApplication>;
+    get ready(): boolean;
+    get frozen(): boolean;
+    protected set frozen(v: boolean);
+    get knowledges(): IKnowledge[] | undefined;
+    setKnowledges(knowledges?: IKnowledge[]): Promise<IKnowledge[] | undefined>;
+    validateConfigs(): void;
+    get promptVariables(): ISessionPrompt[];
+    setPromptVariables(v: ISessionPrompt[]): Promise<ISessionPrompt[] | undefined>;
+    get netOpen(): boolean;
+    /**
+     * 异步设置会话的网络访问开关状态
+     * @param v - 布尔值，表示是否开启网络访问，true 为开启，false 为关闭
+     * @returns 如果设置成功，返回最终的网络访问开关状态；若不满足设置条件，则提前返回 undefined
+     */
+    setNetOpen(v: boolean): Promise<boolean | undefined>;
+    private getService;
+    addEventListener(eventName: SessionEventName, callback: any, once?: boolean): void;
+    removeEventListener(eventName: SessionEventName, callback: any): void;
+    /**
+     * 获取对话记录
+     * @param params ChatHistoryParams
+     * @returns Promise<false|Message[]>
+     */
+    fetchMessages(params?: ChatHistoryParams): Promise<false | {
+        actions: ActionPayloadBasic[][];
+        relatedQuesion: string[] | undefined;
+        ts?: string | undefined;
+        messageId: string;
+        content: string;
+        role: ChatMessageRole;
+        userId?: string | undefined;
+        sessionId: string;
+        reference: import("@glodon-aiot/apis").IReference[];
+        searchReference: import("@glodon-aiot/apis").ISearchRefernce[];
+        comment?: import("@glodon-aiot/apis/dist/src/cvforce").ICommentParam | undefined;
+        knowledges?: IKnowledge[] | undefined;
+        isLoading?: boolean | undefined;
+        messageTime: string;
+        fileId?: string | undefined;
+        file?: import("@glodon-aiot/apis/dist/src/cvforce").KnowledgeFileMetadata | undefined;
+        chatMode?: import("@glodon-aiot/apis").ChatMode | undefined;
+        llmModel?: string | undefined;
+        isContext?: boolean | undefined;
+        index?: number | undefined;
+        agentHistoryList?: {
+            agentList: string;
+            createdAt: string;
+            creator: string;
+            deletedAt: string;
+            id: string;
+            updatedAt: string;
+        } | undefined;
+        finish?: boolean | undefined;
+        code?: number | undefined;
+        isSensitive?: boolean | undefined;
+        message?: string | undefined;
+        stream?: boolean | undefined;
+        fileIds?: string[] | undefined;
+        isReplying?: boolean | undefined;
+        files?: import("@glodon-aiot/apis").ChatMessageFile[] | undefined;
+        thinkingSecs?: number | undefined;
+        thinkingStatus?: "end" | "start" | undefined;
+        reasoningContent?: string | undefined;
+    }[]>;
+    rename(name: string): Promise<boolean>;
+    protected pushMessage(message: IChatMessage): Promise<void>;
+    reloadSessionInfo(): Promise<this>;
+    reload(): Promise<unknown>;
+    delete(): Promise<string | false>;
+    activate(): Promise<unknown>;
+    inactivate(immediately?: boolean): boolean;
+    abstract prepareConnection(): Promise<boolean>;
+    abstract sendQuestion(params: QuestionBody, configs: QuestionConfig): any;
+    abstract stopAnswer(): any;
+    get dataLoaded(): boolean;
+    get messagesLoading(): boolean;
+    send(params: {
+        text?: string;
+        uuid?: string;
+        fileIds?: string[];
+    }, configs?: QuestionConfig): Promise<false | {
+        sessionId: string;
+        role: number;
+        content: string;
+        messageId: string;
+        reference: never[];
+        searchReference: never[];
+        messageTime: string;
+    }>;
+    protected getRelatedQuesion(message: IChatMessage): Promise<IChatMessage>;
+    protected fillMessageReference(message: IChatMessage): Promise<IChatMessage>;
+    answerAgain(configs?: QuestionConfig): Promise<void>;
+    setTop(top: boolean): Promise<void>;
+    /**
+     * 暂停当前会话的回答过程
+     * 该方法会停止当前回答，标记回答停止状态，处理正在进行的消息和操作，
+     * 并根据情况更新消息内容或添加新的系统消息。
+     * @returns 返回当前会话实例
+     */
+    suspend(): this | undefined;
+    /**
+     * 异步提交评论信息
+     * @param params - 评论参数，包含评论相关的信息，如消息 ID 等
+     * @returns 返回调用 API 提交评论后的响应结果
+     */
+    postMessageComment(params: ICommentParam): Promise<string>;
+    /**
+     * 清除当前会话的上下文信息
+     * 该方法会调用 API 清除指定会话的上下文，并在操作成功后触发相应事件
+     * @returns 如果会话 ID 存在且清除操作成功，返回一个解析为 true 的 Promise；若会话 ID 不存在，抛出错误
+     */
+    clear(): Promise<boolean>;
+    /**
+     * 销毁当前会话实例，执行清理操作并触发销毁事件
+     * @returns 返回当前会话的 ID，如果会话 ID 不存在则返回空字符串
+     */
+    destroy(): string;
+}
+export {};

package/cdn/src/api/fetchEventSource/fetch.d.ts

@@ -0,0 +1,44 @@
+import { EventSourceMessage } from "./parse";
+export declare const EventStreamContentType = "text/event-stream";
+export interface FetchEventSourceInit extends RequestInit {
+    /**
+     * The request headers. FetchEventSource only supports the Record<string,string> format.
+     */
+    headers?: Record<string, string>;
+    /**
+     * Called when a response is received. Use this to validate that the response
+     * actually matches what you expect (and throw if it doesn't.) If not provided,
+     * will default to a basic validation to ensure the content-type is text/event-stream.
+     */
+    onopen?: (response: Response) => Promise<void>;
+    /**
+     * Called when a message is received. NOTE: Unlike the default browser
+     * EventSource.onmessage, this callback is called for _all_ events,
+     * even ones with a custom `event` field.
+     */
+    onmessage?: (ev: EventSourceMessage) => void;
+    /**
+     * Called when a response finishes. If you don't expect the server to kill
+     * the connection, you can throw an exception here and retry using onerror.
+     */
+    onclose?: () => void;
+    /**
+     * Called when there is any error making the request / processing messages /
+     * handling callbacks etc. Use this to control the retry strategy: if the
+     * error is fatal, rethrow the error inside the callback to stop the entire
+     * operation. Otherwise, you can return an interval (in milliseconds) after
+     * which the request will automatically retry (with the last-event-id).
+     * If this callback is not specified, or it returns undefined, fetchEventSource
+     * will treat every error as retriable and will try again after 1 second.
+     */
+    onerror?: (err: any) => number | null | undefined | void;
+    /**
+     * If true, will keep the request open even if the document is hidden.
+     * By default, fetchEventSource will close the request and reopen it
+     * automatically when the document becomes visible again.
+     */
+    openWhenHidden?: boolean;
+    /** The Fetch function to use. Defaults to window.fetch */
+    fetch?: typeof fetch;
+}
+export declare function fetchEventSource(input: RequestInfo, { signal: inputSignal, headers: inputHeaders, onopen: inputOnOpen, onmessage, onclose, onerror, openWhenHidden, fetch: inputFetch, ...rest }: FetchEventSourceInit): Promise<void>;

package/cdn/src/api/fetchEventSource/index.d.ts

@@ -0,0 +1 @@
+export * from "./fetch";

package/cdn/src/api/fetchEventSource/parse.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Represents a message sent in an event stream
+ * https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events#Event_stream_format
+ */
+export interface EventSourceMessage {
+    /** The event ID to set the EventSource object's last event ID value. */
+    id: string;
+    /** A string identifying the type of event described. */
+    event: string;
+    /** The event data */
+    data: string;
+    /** The reconnection interval (in milliseconds) to wait before retrying the connection */
+    retry?: number;
+}
+/**
+ * Converts a ReadableStream into a callback pattern.
+ * @param stream The input ReadableStream.
+ * @param onChunk A function that will be called on each new byte chunk in the stream.
+ * @returns {Promise<void>} A promise that will be resolved when the stream closes.
+ */
+export declare function getBytes(stream: ReadableStream<Uint8Array>, onChunk: (arr: Uint8Array) => void): Promise<void>;
+/**
+ * Parses arbitary byte chunks into EventSource line buffers.
+ * Each line should be of the format "field: value" and ends with \r, \n, or \r\n.
+ * @param onLine A function that will be called on each new EventSource line.
+ * @returns A function that should be called for each incoming byte chunk.
+ */
+export declare function getLines(onLine: (line: Uint8Array, fieldLength: number, isWrap: boolean) => void): (arr: Uint8Array) => void;
+/**
+ * Parses line buffers into EventSourceMessages.
+ * @param onId A function that will be called on each `id` field.
+ * @param onRetry A function that will be called on each `retry` field.
+ * @param onMessage A function that will be called on each message.
+ * @returns A function that should be called for each incoming line buffer.
+ */
+export declare function getMessages(onId: (id: string) => void, onRetry: (retry: number) => void, onMessage?: (msg: EventSourceMessage) => void): (line: Uint8Array, fieldLength: number, isWrap: boolean) => void;

package/cdn/src/api/index.d.ts

@@ -0,0 +1,2 @@
+import { CVForceApi } from '@glodon-aiot/apis';
+export declare function getCVForceService(apiBase: string, token: string, errorHandler: (status: number, message: string) => void): CVForceApi;

package/cdn/src/index.d.ts

@@ -0,0 +1,5 @@
+export type { AgentPluginRegistor, AgentPluginMap } from './Config';
+export { configure, configuration } from './Config';
+export { default as BotClient } from './BotClient';
+export { default as Session } from './Session';
+export { default as AgentPlugin } from './AgentPlugin';

package/cdn/src/utils.d.ts

@@ -0,0 +1,4 @@
+export declare const parseJWT: (token: string) => any;
+export declare const isExpired: (token: string) => boolean;
+export declare const removeNewlines: (str: string) => string;
+export declare const removeLeadingAndTrailingBackslashes: (str: string) => string;

package/dist/es/AgentPlugin.mjs

@@ -0,0 +1,20 @@
+var c = Object.defineProperty;
+var a = (e, t, i) => t in e ? c(e, t, { enumerable: !0, configurable: !0, writable: !0, value: i }) : e[t] = i;
+var s = (e, t, i) => (a(e, typeof t != "symbol" ? t + "" : t, i), i);
+class d {
+  constructor(t, i = {}, o) {
+    s(this, "code");
+    s(this, "description", "");
+    s(this, "loaded", !1);
+    s(this, "functions", {});
+    this.code = t, i && (this.functions = i);
+  }
+  fetchData() {
+    this.description = "描述", this.loaded = !0;
+  }
+  checkFunctions() {
+  }
+}
+export {
+  d as default
+};