@aigne/core 0.0.1

package/lib/types/common/resource-manager.d.ts

@@ -0,0 +1,88 @@
+import { Assistant, ResourceProject, ResourceType } from '../types';
+export type ResourceProjectItem = ResourceProject & {
+    blocklet: {
+        did: string;
+    };
+    dir: string;
+    agentMap: {
+        [agentId: string]: Assistant;
+    };
+};
+export type ResourceBlockletItem = {
+    did: string;
+    status?: number;
+    projectMap: {
+        [projectId: string]: ResourceProjectItem;
+    };
+};
+export interface ResourceKnowledge {
+    knowledge: any & {
+        public?: boolean;
+    };
+    blockletDid: string;
+    documents: any[];
+    contents: any[];
+    segments: any[];
+    vectorsPath: string;
+    uploadPath: string;
+    sourcesPath: string;
+    processedPath: string;
+    logoPath: string;
+    title: string;
+    did: string;
+}
+export interface Resources {
+    knowledge: {
+        knowledgeList: ResourceKnowledge[];
+        blockletMap: {
+            [blockletDid: string]: {
+                knowledgeMap: {
+                    [knowledgeId: string]: ResourceKnowledge;
+                };
+            };
+        };
+    };
+    agents: {
+        [type: string]: {
+            projects: ResourceProjectItem[];
+            blockletMap: {
+                [blockletDid: string]: ResourceBlockletItem;
+            };
+        };
+    };
+}
+export declare class ResourceManager {
+    constructor({ wait, watch }?: {
+        wait?: number;
+        watch?: boolean;
+    });
+    private promise?;
+    get resources(): Promise<Resources>;
+    reload(): Promise<Resources>;
+    getProjects({ blockletDid, type }: {
+        blockletDid?: string;
+        type: ResourceType;
+    }): Promise<ResourceProjectItem[]>;
+    getProject({ blockletDid, projectId, type, }: {
+        blockletDid: string;
+        projectId: string;
+        type?: ResourceType | ResourceType[];
+    }): Promise<ResourceProjectItem | undefined>;
+    getAgent({ blockletDid, projectId, agentId, type, }: {
+        blockletDid: string;
+        projectId: string;
+        agentId: string;
+        type?: ResourceType | ResourceType[];
+    }): Promise<{
+        agent: Assistant;
+        project: import("../types").ProjectSettings;
+        blocklet: {
+            did: string;
+        };
+    } | undefined>;
+    getKnowledgeList(): Promise<ResourceKnowledge[]>;
+    getKnowledge({ blockletDid, knowledgeId }: {
+        blockletDid: string;
+        knowledgeId: string;
+    }): Promise<ResourceKnowledge>;
+}

package/lib/types/constants.d.ts

@@ -0,0 +1,6 @@
+export declare const AIGNE_RUNTIME_COMPONENT_DID = "z2qaBP9SahqU2L2YA3ip7NecwKACMByTFuiJ2";
+export declare const AIGNE_COMPONENTS_COMPONENT_DID = "z2qa6fvjmjew4pWJyTsKaWFuNoMUMyXDh5A1D";
+export declare const AIGNE_RUNTIME_CUSTOM_COMPONENT_ID = "grc9q1cveub6pnl8";
+export declare const AIGNE_STUDIO_COMPONENT_DID = "z8iZpog7mcgcgBZzTiXJCWESvmnRrQmnd3XBB";
+export declare const NFT_BLENDER_COMPONENT_DID = "z8ia1ieY5KhEC4LMRETzS5nUwD7PvAND8qkfX";
+export declare const AIGNE_ISSUE_VC_PREFIX = "AIGNE";

package/lib/types/executor/agent.d.ts

@@ -0,0 +1,5 @@
+import { Agent } from '../types';
+import { AgentExecutorBase } from './base';
+export declare class AgentExecutor extends AgentExecutorBase<Agent> {
+    process(): Promise<void>;
+}

package/lib/types/executor/aigc.d.ts

@@ -0,0 +1,9 @@
+import { ImageAssistant } from '../types';
+import { AgentExecutorBase } from './base';
+export declare class AIGCAgentExecutor extends AgentExecutorBase<ImageAssistant> {
+    process(): Promise<{
+        $images: {
+            url: string;
+        }[];
+    }>;
+}

package/lib/types/executor/api.d.ts

@@ -0,0 +1,9 @@
+import { ApiAssistant } from '../types';
+import { AgentExecutorBase } from './base';
+export declare class APIAgentExecutor extends AgentExecutorBase<ApiAssistant> {
+    process({ inputs }: {
+        inputs: {
+            [key: string]: any;
+        };
+    }): Promise<any>;
+}

package/lib/types/executor/base.d.ts

@@ -0,0 +1,209 @@
+import { CallAI, CallAIImage, GetAgent, GetAgentResult, RunAssistantCallback } from '../assistant/type';
+import { issueVC } from '../libs/blocklet/vc';
+import type { DatasetObject } from '../libs/openapi/types';
+import { ProjectSettings, Variable, VariableScope } from '../types';
+import { renderMessage } from '../utils/render-message';
+export declare class ExecutorContext {
+    constructor(options: Pick<ExecutorContext, 'entry' | 'getAgent' | 'callAI' | 'callAIImage' | 'callback' | 'getMemoryVariables' | 'user' | 'sessionId' | 'messageId' | 'clientTime' | 'executor' | 'entryProjectId' | 'queryCache' | 'setCache'>);
+    entry: {
+        blockletDid?: string;
+        project: ProjectSettings;
+        working?: boolean;
+        appUrl?: string;
+    };
+    getAgent: GetAgent;
+    callAI: CallAI;
+    callAIImage: CallAIImage;
+    queryCache: (options: {
+        aid: string;
+        cacheKey: string;
+    }) => Promise<{
+        inputs: {
+            [key: string]: any;
+        };
+        outputs: {
+            [key: string]: any;
+        };
+    } | null>;
+    setCache: (options: {
+        aid: string;
+        cacheKey: string;
+        inputs: {
+            [key: string]: any;
+        };
+        outputs: {
+            objects: any[];
+        };
+    }) => Promise<any>;
+    callback: RunAssistantCallback;
+    sessionId: string;
+    messageId: string;
+    clientTime: string;
+    promise?: Promise<{
+        agents: (GetAgentResult & {
+            openApi: DatasetObject;
+        })[];
+        agentsMap: {
+            [key: string]: GetAgentResult & {
+                openApi: DatasetObject;
+            };
+        };
+        openApis: DatasetObject[];
+    }>;
+    entryProjectId: string;
+    user?: {
+        id: string;
+        did: string;
+        role?: string;
+        fullName?: string;
+        provider?: string;
+        walletOS?: string;
+        isAdmin?: boolean;
+    };
+    getMemoryVariables: (options: {
+        blockletDid?: string;
+        projectId: string;
+        projectRef?: string;
+        working?: boolean;
+    }) => Promise<Variable[]>;
+    maxRetries: number;
+    executor: <T extends GetAgentResult>(agent: T, options: AgentExecutorOptions) => AgentExecutorBase<T>;
+    execute<T extends GetAgentResult>(agent: T, options: AgentExecutorOptions): Promise<any>;
+    copy(options: Partial<ExecutorContext>): ExecutorContext;
+    getBlockletAgent(agentId: string): Promise<{
+        agent: GetAgentResult & {
+            openApi: DatasetObject;
+        };
+        openApis: DatasetObject[];
+    }>;
+}
+export interface AgentExecutorOptions {
+    inputs?: {
+        [key: string]: any;
+    };
+    taskId: string;
+    parentTaskId?: string;
+    variables?: {
+        [key: string]: any;
+    };
+}
+export declare abstract class AgentExecutorBase<T> {
+    readonly context: ExecutorContext;
+    readonly agent: GetAgentResult & T;
+    readonly options: AgentExecutorOptions;
+    constructor(context: ExecutorContext, agent: GetAgentResult & T, options: AgentExecutorOptions);
+    abstract process(options: {
+        inputs: {
+            [key: string]: any;
+        };
+    }): Promise<any>;
+    execute(): Promise<any>;
+    private _finalInputs;
+    private get finalInputs();
+    private set finalInputs(value);
+    private cacheKey;
+    get globalContext(): {
+        $sys: {
+            sessionId: string;
+            messageId: string;
+            clientTime: string;
+            user: {
+                id: string;
+                did: string;
+                role?: string;
+                fullName?: string;
+                provider?: string;
+                walletOS?: string;
+                isAdmin?: boolean;
+            } | undefined;
+            env: Pick<{
+                [key: string]: any;
+                appId: string;
+                appPid: string;
+                appIds: string[];
+                appName: string;
+                appNameSlug: string;
+                appDescription: string;
+                appUrl: string;
+                isComponent: boolean;
+                dataDir: string;
+                cacheDir: string;
+                mode: string;
+                tenantMode: string;
+                appStorageEndpoint: string;
+                serverVersion: string;
+                languages: {
+                    code: string;
+                    name: string;
+                }[];
+                preferences: Record<string, any>;
+                componentDid: string;
+                initialized?: boolean;
+            }, "appId" | "appName" | "appDescription" | "appUrl">;
+        };
+        $storage: {
+            getItem(key: string, { scope, onlyOne }?: {
+                scope?: VariableScope;
+                onlyOne?: boolean;
+            }): Promise<{
+                id: string;
+                key: string;
+                data: any;
+                scope: VariableScope;
+            }[] | {
+                id: string;
+                key: string;
+                data: any;
+                scope: VariableScope;
+            } | null>;
+            setItem(key: string, value: any, { scope, onlyOne }?: {
+                scope?: VariableScope;
+                onlyOne?: boolean;
+            }): Promise<{
+                id: string;
+                key: string;
+                data: any;
+                scope: VariableScope;
+            }>;
+        };
+        $cache: {
+            readonly key: string;
+            getItem(key: string, { agentId }?: {
+                agentId?: string;
+            }): Promise<{
+                inputs: {
+                    [key: string]: any;
+                };
+                outputs: {
+                    [key: string]: any;
+                };
+            } | null>;
+        };
+        $blocklet: {
+            issueVC: (args: Omit<Parameters<typeof issueVC>[0], "userDid" | "project">) => Promise<{
+                user: import("@abtnode/client").UserInfo;
+                vc: object;
+            }>;
+        };
+    };
+    private prepareInputs;
+    protected renderMessage: typeof renderMessage;
+    protected validateOutputs({ inputs, outputs, partial, processCallAgentOutputs, }: {
+        inputs?: {
+            [key: string]: any;
+        };
+        outputs?: {
+            [key: string]: any;
+        };
+        partial?: boolean;
+        processCallAgentOutputs?: boolean;
+    }): Promise<any>;
+    private postProcessOutputs;
+    private setMemory;
+    private getMemory;
+    hideSecretInputs(partial: {
+        [key: string]: any;
+    }, agent: GetAgentResult): {
+        [x: string]: any;
+    };
+}

package/lib/types/executor/blocklet.d.ts

@@ -0,0 +1,9 @@
+import { BlockletAgent } from '../types';
+import { AgentExecutorBase } from './base';
+export declare class BlockletAgentExecutor extends AgentExecutorBase<BlockletAgent> {
+    process({ inputs }: {
+        inputs: {
+            [key: string]: any;
+        };
+    }): Promise<any>;
+}

package/lib/types/executor/call-agent.d.ts

@@ -0,0 +1,12 @@
+import { CallAssistant } from '../types';
+import { AgentExecutorBase } from './base';
+export declare class CallAgentExecutor extends AgentExecutorBase<CallAssistant> {
+    private getCalledAgents;
+    private getLastTextSteamAgentId;
+    private getOutputVariables;
+    process(options: {
+        inputs: {
+            [key: string]: any;
+        };
+    }): Promise<Partial<{}>>;
+}

package/lib/types/executor/decision.d.ts

@@ -0,0 +1,20 @@
+import { RouterAssistant } from '../types';
+import { AgentExecutorBase } from './base';
+export declare class DecisionAgentExecutor extends AgentExecutorBase<RouterAssistant> {
+    process({ inputs }: {
+        inputs: {
+            [key: string]: any;
+        };
+    }): Promise<any>;
+    processWithJsonLogic({ inputs }: {
+        inputs: {
+            [key: string]: any;
+        };
+    }): Promise<any>;
+    processWithLLM({ inputs }: {
+        inputs: {
+            [key: string]: any;
+        };
+    }): Promise<any>;
+    private getEnglishFunctionName;
+}

package/lib/types/executor/image-blender.d.ts

@@ -0,0 +1,9 @@
+import { ImageBlenderAssistant } from '../types';
+import { AgentExecutorBase } from './base';
+export declare class ImageBlenderAgentExecutor extends AgentExecutorBase<ImageBlenderAssistant> {
+    process(): Promise<{
+        $images: {
+            url: string;
+        }[];
+    }>;
+}

package/lib/types/executor/index.d.ts

@@ -0,0 +1,8 @@
+import { GetAgentResult } from '../assistant/type';
+import { AgentExecutorBase, AgentExecutorOptions, ExecutorContext } from './base';
+export declare class RuntimeExecutor extends AgentExecutorBase<GetAgentResult> {
+    private parentAgent?;
+    constructor(context: Omit<ConstructorParameters<typeof ExecutorContext>[0], 'executor'>, agent: GetAgentResult, options: AgentExecutorOptions, parentAgent?: GetAgentResult | undefined);
+    process(): Promise<void>;
+    execute(): Promise<any>;
+}

package/lib/types/executor/llm.d.ts

@@ -0,0 +1,38 @@
+import { GetAgentResult } from '../assistant/type';
+import { OutputVariable, PromptAssistant } from '../types';
+import { AgentExecutorBase } from './base';
+export declare class LLMAgentExecutor extends AgentExecutorBase<PromptAssistant> {
+    private retryTimes;
+    get modelInfo(): {
+        model: string;
+        temperature: number | undefined;
+        topP: number | undefined;
+        presencePenalty: number | undefined;
+        frequencyPenalty: number | undefined;
+    };
+    private _executor;
+    get executor(): Promise<{
+        executor: GetAgentResult;
+        inputValues?: {
+            [key: string]: any;
+        };
+    } | undefined>;
+    private _outputsInfo;
+    get outputsInfo(): Promise<{
+        outputs: OutputVariable[];
+        schema: any;
+        hasStreamingTextOutput: boolean;
+        hasJsonOutputs: boolean;
+    }>;
+    private getMessages;
+    process({ inputs }: {
+        inputs: {
+            [key: string]: any;
+        };
+    }): Promise<any>;
+    private processWithOutJsonSchemaFormatSupport;
+    private processWithJsonSchemaFormat;
+    private callAIGetJsonOutput;
+    private callAIGetTextStreamOutput;
+    private callAIOrExecutor;
+}

package/lib/types/executor/logic.d.ts

@@ -0,0 +1,9 @@
+import { FunctionAssistant } from '../types';
+import { AgentExecutorBase } from './base';
+export declare class LogicAgentExecutor extends AgentExecutorBase<FunctionAssistant> {
+    process({ inputs }: {
+        inputs: {
+            [key: string]: any;
+        };
+    }): Promise<any>;
+}

package/lib/types/index.d.ts

@@ -0,0 +1 @@
+export * from './runtime/runtime';

package/lib/types/libs/blocklet/vc.d.ts

@@ -0,0 +1,17 @@
+import { UserInfo } from '@abtnode/client';
+import AuthService from '@blocklet/sdk/lib/service/auth';
+import type { ExecutorContext } from '../../executor/base';
+export declare const authService: AuthService;
+export declare function issueVC({ context: { entry }, userDid, name, title, description, reissue, displayUrl, notify, }: {
+    context: ExecutorContext;
+    userDid: string;
+    name: string;
+    title: string;
+    description: string;
+    reissue?: boolean;
+    displayUrl?: string;
+    notify?: boolean;
+}): Promise<{
+    user: UserInfo;
+    vc: object;
+}>;

package/lib/types/libs/openapi/request/index.d.ts

@@ -0,0 +1,17 @@
+import { DatasetObject } from '../types';
+export interface User {
+    did: string;
+}
+export declare const callBlockletApi: (pathItem: DatasetObject, data: {
+    [key: string]: any;
+}, options?: {
+    user?: User;
+    params?: {
+        [key: string]: any;
+    };
+    data?: {
+        [key: string]: any;
+    };
+}) => Promise<import("axios").AxiosResponse<any, {
+    [key: string]: any;
+}>>;

package/lib/types/libs/openapi/request/util.d.ts

@@ -0,0 +1,40 @@
+import { DatasetObject, RequestBodyObject } from '../types';
+export declare const getRequestConfig: (pathItem: DatasetObject, requestData: {
+    [key: string]: any;
+}, options?: {
+    params: {
+        [key: string]: any;
+    };
+    data: {
+        [key: string]: any;
+    };
+}) => {
+    url: string;
+    method: string;
+    headers: {
+        [key: string]: any;
+    };
+    params: {
+        [key: string]: any;
+    };
+    data: {
+        [key: string]: any;
+    };
+    body: {
+        [key: string]: any;
+    };
+    cookies: {
+        [key: string]: any;
+    };
+};
+export declare function extractRequestBodyParameters(requestBody?: RequestBodyObject): {
+    name: string;
+    value: any;
+    description?: string;
+}[];
+export declare function getAllParameters(dataset: DatasetObject): {
+    name: string;
+    description?: string;
+    type?: string;
+}[];
+export declare function getRequiredFields(dataset: DatasetObject): any[];

package/lib/types/libs/openapi/types/index.d.ts

@@ -0,0 +1,20 @@
+import { ParameterObject, RequestBodyObject, ResponsesObject } from 'openapi3-ts/oas31';
+export * from 'openapi3-ts/oas31';
+export interface PathItemObject {
+    path: string;
+    method: string;
+    summary?: string;
+    description?: string;
+    parameters?: ParameterObject[];
+    requestBody?: RequestBodyObject;
+    responses?: ResponsesObject;
+}
+export interface DatasetObject extends PathItemObject {
+    id: string;
+    type: string;
+    url?: string;
+    name?: string;
+    did?: string;
+    [key: `x-summary-${string}`]: string | undefined;
+    [key: `x-description-${string}`]: string | undefined;
+}

package/lib/types/libs/openapi/util/call.d.ts

@@ -0,0 +1,2 @@
+import { call as originalCall } from '@blocklet/sdk/lib/component';
+export declare const call: typeof originalCall;

package/lib/types/libs/openapi/util/check-schema.d.ts

@@ -0,0 +1,3 @@
+import Joi from 'joi';
+declare const _default: Joi.ObjectSchema<any>;
+export default _default;

package/lib/types/libs/openapi/util/convert-schema.d.ts

@@ -0,0 +1,8 @@
+declare const convertSchemaToObject: (schema: any) => any[] | {
+    [key: string]: any;
+} | {
+    type: string;
+    value: any;
+    description?: string;
+};
+export default convertSchemaToObject;

package/lib/types/libs/openapi/util/flatten-open-api.d.ts

@@ -0,0 +1,3 @@
+import { DatasetObject, OpenAPIObject } from '../types';
+declare function flattenApiStructure(apiStructure: OpenAPIObject): DatasetObject[];
+export default flattenApiStructure;

package/lib/types/libs/openapi/util/get-open-api-i18n-text.d.ts

@@ -0,0 +1,2 @@
+declare const getOpenApiTextFromI18n: (data: any, key: string, locale: string) => any;
+export default getOpenApiTextFromI18n;

package/lib/types/logger.d.ts

@@ -0,0 +1,2 @@
+declare const logger: Console;
+export default logger;

package/lib/types/runtime/resource-blocklet.d.ts

@@ -0,0 +1,2 @@
+import { ResourceManager } from '../common/resource-manager';
+export declare const resourceManager: ResourceManager;

package/lib/types/runtime/runtime.d.ts

@@ -0,0 +1,20 @@
+import { Agent, Variable } from '../types';
+export interface AIGNEProject {
+    id: string;
+    name?: string;
+    description?: string;
+    createdAt?: string;
+    updatedAt?: string;
+    createdBy?: string;
+    updatedBy?: string;
+    agents?: Agent[];
+    memories?: Variable[];
+}
+export declare class AIGNERuntime {
+    project: AIGNEProject;
+    static load(options: {
+        path: string;
+    }): Promise<AIGNERuntime>;
+    constructor(project: AIGNEProject);
+    runAgent(agentId: string, inputs: object): Promise<any>;
+}