@aigne/core 0.0.1

package/lib/esm/utils/get-blocklet-agent.js

@@ -0,0 +1,344 @@
+import config from '@blocklet/sdk/lib/config';
+import axios from 'axios';
+import { Base64 } from 'js-base64';
+import { joinURL } from 'ufo';
+import { AIGNE_RUNTIME_COMPONENT_DID } from '../constants';
+import { getAllParameters } from '../libs/openapi/request/util';
+import flattenApiStructure from '../libs/openapi/util/flatten-open-api';
+import { nextId } from './task-id';
+export const HISTORY_API_ID = Base64.encodeURI(['/api/messages', 'get'].join('/'));
+export const KNOWLEDGE_API_ID = Base64.encodeURI(['/api/datasets/{datasetId}/search', 'get'].join('/'));
+export const MEMORY_API_ID = Base64.encodeURI(['/api/memories/variable-by-query', 'get'].join('/'));
+// 内置的 OpenAPI 接口
+export const buildInOpenAPI = {
+    '/api/messages': {
+        get: {
+            summary: 'Get history messages',
+            'x-summary-zh': '获取历史信息',
+            description: 'Retrieve messages based on sessionId, last N messages, or keyword',
+            'x-description-zh': '根据 sessionId、最后N条消息或关键字检索历史消息',
+            tags: ['AIGNE Studio'],
+            parameters: [
+                {
+                    in: 'query',
+                    name: 'sessionId',
+                    schema: {
+                        type: 'string',
+                    },
+                    description: 'Session Id',
+                },
+                {
+                    in: 'query',
+                    name: 'limit',
+                    schema: {
+                        type: 'number',
+                    },
+                    description: 'Number of last messages to retrieve',
+                    'x-description-zh': '检索的消息的数目',
+                },
+                {
+                    in: 'query',
+                    name: 'keyword',
+                    schema: {
+                        type: 'string',
+                    },
+                    description: 'Keyword to search in messages',
+                    'x-description-zh': '在消息中搜索的关键字',
+                },
+            ],
+            responses: {
+                '200': {
+                    description: 'A list of history messages',
+                    'x-description-zh': '检索历史消息列表',
+                    content: {
+                        'application/json': {
+                            schema: {
+                                type: 'object',
+                                properties: {
+                                    messages: {
+                                        type: 'array',
+                                        items: {
+                                            type: 'object',
+                                            properties: {
+                                                role: {
+                                                    type: 'string',
+                                                },
+                                                content: {
+                                                    type: 'string',
+                                                },
+                                                agentId: {
+                                                    type: 'string',
+                                                },
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+            'x-id': HISTORY_API_ID,
+            'x-did': AIGNE_RUNTIME_COMPONENT_DID,
+            'x-path': '/api/messages',
+            'x-method': 'get',
+        },
+    },
+    '/api/datasets/{datasetId}/search': {
+        get: {
+            summary: 'Search the knowledge',
+            'x-summary-zh': '搜索知识库信息',
+            parameters: [
+                {
+                    name: 'datasetId',
+                    in: 'path',
+                    required: true,
+                    schema: {
+                        type: 'string',
+                    },
+                    description: 'The ID of the dataset to search',
+                },
+                {
+                    name: 'blockletDid',
+                    in: 'query',
+                    required: false,
+                    schema: {
+                        type: 'string',
+                    },
+                    description: 'The Blocklet DID to search for',
+                },
+                {
+                    name: 'searchAll',
+                    in: 'query',
+                    required: false,
+                    schema: {
+                        type: 'boolean',
+                    },
+                    description: 'Whether to search all contents',
+                },
+                {
+                    name: 'message',
+                    in: 'query',
+                    required: false,
+                    schema: {
+                        type: 'string',
+                    },
+                    description: 'The search message',
+                },
+                {
+                    name: 'n',
+                    in: 'query',
+                    required: false,
+                    schema: {
+                        type: 'number',
+                        default: 10,
+                    },
+                    description: 'The number of results to return',
+                },
+            ],
+            responses: {
+                '200': {
+                    description: 'A list of search results',
+                    content: {
+                        'application/json': {
+                            schema: {
+                                type: 'object',
+                                properties: {
+                                    docs: {
+                                        type: 'array',
+                                        items: {
+                                            type: 'object',
+                                            properties: {
+                                                title: {
+                                                    type: 'string',
+                                                    description: 'The title of the document',
+                                                },
+                                                content: {
+                                                    type: 'string',
+                                                    description: 'The content of the document',
+                                                },
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+            'x-id': KNOWLEDGE_API_ID,
+            'x-did': AIGNE_RUNTIME_COMPONENT_DID,
+            'x-path': '/api/datasets/{datasetId}/search',
+            'x-method': 'get',
+        },
+    },
+    '/api/memories/variable-by-query': {
+        get: {
+            summary: 'Get memory variables by query',
+            'x-summary-zh': '知识库信息',
+            parameters: [
+                {
+                    name: 'key',
+                    in: 'query',
+                    required: false,
+                    schema: {
+                        type: 'string',
+                    },
+                    description: 'The key of the variable',
+                },
+                {
+                    name: 'projectId',
+                    in: 'query',
+                    required: false,
+                    schema: {
+                        type: 'string',
+                    },
+                    description: 'The ID of the project',
+                },
+                {
+                    name: 'scope',
+                    in: 'query',
+                    required: false,
+                    schema: {
+                        type: 'string',
+                        enum: ['session', 'user', 'global'],
+                    },
+                    description: 'The scope of the variable',
+                },
+                {
+                    name: 'sessionId',
+                    in: 'query',
+                    required: false,
+                    schema: {
+                        type: 'string',
+                    },
+                    description: 'The ID of the session',
+                },
+            ],
+            responses: {
+                '200': {
+                    description: 'A list of memory variables',
+                    content: {
+                        'application/json': {
+                            schema: {
+                                type: 'object',
+                                properties: {
+                                    datastores: {
+                                        type: 'array',
+                                        items: {
+                                            type: 'object',
+                                            properties: {
+                                                id: {
+                                                    type: 'string',
+                                                    description: 'The ID of the memory entry',
+                                                },
+                                                key: {
+                                                    type: 'string',
+                                                    description: 'The key of the memory entry',
+                                                },
+                                                data: {
+                                                    type: 'object',
+                                                    description: 'The value of the memory entry',
+                                                },
+                                                userId: {
+                                                    type: 'string',
+                                                    description: 'The ID of the user',
+                                                },
+                                                projectId: {
+                                                    type: 'string',
+                                                    description: 'The ID of the project',
+                                                },
+                                                sessionId: {
+                                                    type: 'string',
+                                                    description: 'The ID of the session',
+                                                },
+                                                scope: {
+                                                    type: 'string',
+                                                    description: 'The scope of the memory entry',
+                                                    enum: ['session', 'user', 'global'],
+                                                },
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+            'x-id': MEMORY_API_ID,
+            'x-did': AIGNE_RUNTIME_COMPONENT_DID,
+            'x-path': '/api/memories/variable-by-query',
+            'x-method': 'get',
+        },
+    },
+};
+function convertSchemaToVariableType(schema) {
+    switch (schema.type) {
+        case 'string':
+            return { type: 'string', defaultValue: '' };
+        case 'integer':
+        case 'number':
+            return { type: 'number', defaultValue: undefined };
+        case 'boolean':
+            return { type: 'boolean', defaultValue: undefined };
+        case 'object':
+            return {
+                type: 'object',
+                properties: schema.properties
+                    ? Object.entries(schema.properties).map(([key, value]) => ({
+                        id: key,
+                        name: key,
+                        ...convertSchemaToVariableType(value),
+                    }))
+                    : [],
+            };
+        case 'array':
+            return {
+                type: 'array',
+                element: schema.items ? convertSchemaToVariableType(schema.items) : undefined,
+            };
+        default:
+            throw new Error(`Unsupported schema type: ${schema.type}`);
+    }
+}
+export const getBlockletAgent = async () => {
+    let list = {};
+    try {
+        const result = await axios.get(joinURL(config.env.appUrl, '/.well-known/service/openapi.json'));
+        list = result.data;
+    }
+    catch (error) {
+        list = {};
+    }
+    const openApis = [...flattenApiStructure(list), ...flattenApiStructure({ paths: buildInOpenAPI })];
+    const agents = openApis.map((i) => {
+        const properties = i?.responses?.['200']?.content?.['application/json']?.schema?.properties || {};
+        return {
+            type: 'blocklet',
+            id: i.id,
+            name: i?.summary,
+            description: i?.description,
+            parameters: getAllParameters(i)
+                .map((i) => {
+                return {
+                    id: nextId(),
+                    type: 'string',
+                    key: i.name,
+                };
+            })
+                .filter((i) => i.key),
+            outputVariables: Object.entries(properties).map(([key, value]) => ({
+                id: key,
+                name: key,
+                ...convertSchemaToVariableType(value),
+            })),
+            openApi: i,
+        };
+    });
+    const agentsMap = agents.reduce((acc, cur) => {
+        acc[cur.id] = cur;
+        return acc;
+    }, {});
+    return { agents, agentsMap, openApis };
+};

package/lib/esm/utils/geti.js

@@ -0,0 +1,30 @@
+// @ts-ignore
+import castPath from 'lodash/_castPath';
+// @ts-ignore
+import toKey from 'lodash/_toKey';
+import toLower from 'lodash/toLower';
+export const geti = (object, path, defaultValue) => {
+    if (!object)
+        return defaultValue === undefined ? null : defaultValue;
+    const paths = castPath(path, object);
+    const { length } = paths;
+    let index = 0;
+    let iterator = object;
+    while (iterator !== undefined && index < length) {
+        const key = toKey(paths[index]).toLowerCase();
+        iterator = findLowercaseKey(iterator, key);
+        index += 1;
+    }
+    return index && index === length && iterator !== undefined ? iterator : defaultValue;
+};
+const findLowercaseKey = (value, key) => {
+    return Object.keys(value).reduce((a, k) => {
+        if (a !== undefined) {
+            return a;
+        }
+        if (toLower(k) === key) {
+            return value[k];
+        }
+        return undefined;
+    }, undefined);
+};

package/lib/esm/utils/is-non-nullable.js

@@ -0,0 +1,13 @@
+import isNil from 'lodash/isNil';
+export function isNonNullable(value) {
+    return !isNil(value);
+}
+export function isPropsNonNullable(...props) {
+    return (value) => {
+        for (const prop of props.flat()) {
+            if (isNil(value?.[prop]))
+                return false;
+        }
+        return true;
+    };
+}

package/lib/esm/utils/render-message.js

@@ -0,0 +1,20 @@
+import { get } from 'lodash';
+import { Mustache } from '../types/assistant';
+export async function renderMessage(message, parameters, { stringify = true, escapeJsonSymbols } = {}) {
+    const spans = Mustache.parse(message.trim());
+    if (!stringify && spans.length === 1) {
+        const span = spans[0];
+        if (span[0] === 'name') {
+            return get(parameters, span[1]);
+        }
+    }
+    return Mustache.render(message, parameters, undefined, {
+        escape: (v) => {
+            const r = typeof v === 'object' ? JSON.stringify(v) : v;
+            if (typeof r === 'string' && escapeJsonSymbols) {
+                return JSON.stringify(r).slice(1, -1);
+            }
+            return r;
+        },
+    });
+}

package/lib/esm/utils/resolve-secret-inputs.js

@@ -0,0 +1,46 @@
+import { uniqBy } from 'lodash';
+import { parseIdentity, stringifyIdentity } from '../common/aid';
+import { RuntimeOutputVariable } from '../types';
+import { isNonNullable } from './is-non-nullable';
+export async function resolveSecretInputs(agent, { getAgent }) {
+    if (!agent.project)
+        return [];
+    const secretInputs = (agent.parameters ?? [])
+        .filter((i) => !!i.key && i.type === 'source' && i.source?.variableFrom === 'secret' && !i.hidden)
+        .map((input) => ({ agent, input }));
+    const outputVariables = (agent.outputVariables ?? []).filter((i) => !i.hidden);
+    const children = outputVariables.find((i) => i.name === RuntimeOutputVariable.children)
+        ?.initialValue;
+    const referencedAgents = [
+        ...(children?.agents ?? []).map((i) => ({ id: i.id, projectId: agent.project.id, blockletDid: undefined })),
+        ...(agent.parameters ?? []).map((i) => {
+            if (i.hidden)
+                return null;
+            if (i.type === 'source' && i.source?.variableFrom === 'tool' && i.source.agent?.id) {
+                return {
+                    id: i.source.agent.id,
+                    blockletDid: i.source.agent.blockletDid,
+                    projectId: i.source.agent.projectId,
+                };
+            }
+            return null;
+        }),
+        ...(agent.executor?.agent?.id ? [agent.executor.agent] : []),
+    ].filter(isNonNullable);
+    const identity = parseIdentity(agent.identity.aid, { rejectWhenError: true });
+    const nestedSecretInputs = (await Promise.all(referencedAgents.map(async (i) => {
+        const res = await getAgent({
+            aid: stringifyIdentity({
+                blockletDid: i.blockletDid || identity.blockletDid,
+                projectId: i.projectId || identity.projectId,
+                projectRef: identity.projectRef || identity.projectRef,
+                agentId: i.id,
+            }),
+            working: agent.identity.working,
+        });
+        return res && resolveSecretInputs(res, { getAgent });
+    })))
+        .flat()
+        .filter(isNonNullable);
+    return uniqBy([...secretInputs, ...nestedSecretInputs], (i) => `${i.input.id}-${i.agent.id}-${i.agent.project?.id}`);
+}

package/lib/esm/utils/retry.js

@@ -0,0 +1,16 @@
+export default async function retry(fn, retries) {
+    let i = 0;
+    for (;;) {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            if (i < retries) {
+                i++;
+            }
+            else {
+                throw error;
+            }
+        }
+    }
+}

package/lib/esm/utils/task-id.js

@@ -0,0 +1,3 @@
+import { Worker } from 'snowflake-uuid';
+const idGenerator = new Worker();
+export const nextId = () => idGenerator.nextId().toString();

package/lib/esm/utils/tool-calls-transform.js

@@ -0,0 +1,15 @@
+export function toolCallsTransform(calls, chunk) {
+    const { toolCalls } = chunk.delta;
+    toolCalls?.forEach((item) => {
+        const targetCall = item?.id ? calls.find((call) => call.id === item?.id) : calls.at(-1);
+        // 如果 item 有 id, 且 calls 中没有这个 id, 则直接 push
+        // chatgpt adapter 和 claude adapter 经过改造一定有 id
+        if (item?.id && !targetCall) {
+            calls.push(item);
+        }
+        else if (targetCall?.function) {
+            targetCall.function.name += item.function?.name || '';
+            targetCall.function.arguments = (targetCall.function.arguments || '') + (item.function?.arguments || '');
+        }
+    });
+}

package/lib/types/assistant/generate-output.d.ts

@@ -0,0 +1,29 @@
+import { ReadableStream } from 'stream/web';
+import { ChatCompletionResponse } from '@blocklet/ai-kit/api/types/chat';
+import { Assistant, Role, Variable } from '../types';
+import { CallAI } from './type';
+export declare const metadataPrefix = "```metadata";
+export declare const metadataSuffix = "```";
+export declare const metadataOutputFormatPrompt: (schema: string) => string;
+export declare const metadataStreamOutputFormatPrompt: (schema: string) => string;
+export declare function generateOutput({ assistant, messages, callAI, maxRetries, datastoreVariables, }: {
+    assistant: Assistant & {
+        project: {
+            id: string;
+        };
+    };
+    messages: {
+        role: Role;
+        content: string;
+    }[];
+    callAI: CallAI;
+    maxRetries?: number;
+    datastoreVariables: Variable[];
+}): Promise<any>;
+export declare function extractMetadataFromStream(input: ReadableStream<ChatCompletionResponse>, extract?: boolean): ReadableStream<{
+    type: "text";
+    text: string;
+} | {
+    type: "match";
+    text: string;
+}>;

package/lib/types/assistant/select-agent.d.ts

@@ -0,0 +1,14 @@
+import { RouterAssistant } from '../types';
+import { CallAI } from './type';
+declare function generateSelectAgentName({ assistant, message, callAI, maxRetries, categories, }: {
+    assistant: RouterAssistant & {
+        project: {
+            id: string;
+        };
+    };
+    message: string;
+    callAI: CallAI;
+    maxRetries?: number;
+    categories: string;
+}): Promise<any>;
+export default generateSelectAgentName;

package/lib/types/assistant/type.d.ts

@@ -0,0 +1,61 @@
+import { ReadableStream } from 'stream/web';
+import { ChatCompletionInput, ChatCompletionResponse } from '@blocklet/ai-kit/api/types/chat';
+import { ImageGenerationInput } from '@blocklet/ai-kit/api/types/image';
+import { Assistant, BlockletAgent, OnTaskCompletion, ProjectSettings, RunAssistantResponse } from '../types';
+import { Agent } from '../types/runtime/agent';
+type OmitBetterStrict<T, K extends keyof T> = T extends any ? Pick<T, Exclude<keyof T, K>> : never;
+export type RunAssistantCallback = (e: OmitBetterStrict<RunAssistantResponse, 'messageId' | 'sessionId'>) => void;
+export declare class ToolCompletionDirective extends Error {
+    type: OnTaskCompletion;
+    constructor(message: string, type: OnTaskCompletion);
+}
+export interface GetAgentOptions {
+    aid: string;
+    working?: boolean;
+    rejectOnEmpty?: boolean | Error;
+}
+export type GetAgentResult = (Assistant & {
+    identity: Agent['identity'];
+    project: ProjectSettings;
+}) | (BlockletAgent & {
+    identity?: undefined;
+    project?: undefined;
+});
+export interface GetAgent {
+    (options: GetAgentOptions & {
+        rejectOnEmpty: true | Error;
+    }): Promise<GetAgentResult>;
+    (options: GetAgentOptions & {
+        rejectOnEmpty?: false;
+    }): Promise<GetAgentResult | null | undefined>;
+}
+export type Options = {
+    assistant: Assistant & {
+        project: {
+            id: string;
+        };
+    };
+    input: ChatCompletionInput;
+};
+export type ImageOptions = {
+    assistant: Assistant;
+    input: ImageGenerationInput;
+};
+export type ModelInfo = {
+    model: string;
+    temperature?: number;
+    topP?: number;
+    presencePenalty?: number;
+    frequencyPenalty?: number;
+};
+export interface CallAI {
+    (options: Options): Promise<ReadableStream<ChatCompletionResponse>>;
+}
+export interface CallAIImage {
+    (options: ImageOptions): Promise<{
+        data: {
+            url: string;
+        }[];
+    }>;
+}
+export {};

package/lib/types/common/aid.d.ts

@@ -0,0 +1,18 @@
+export interface Identity {
+    blockletDid?: string;
+    projectId: string;
+    projectRef?: string;
+    agentId: string;
+}
+export declare function parseIdentity(aid: string, options: {
+    rejectWhenError: true;
+}): Identity;
+export declare function parseIdentity(aid: string, options?: {
+    rejectWhenError?: false;
+}): Identity | undefined;
+export declare function stringifyIdentity({ blockletDid, projectId, projectRef, agentId, }: {
+    blockletDid?: string;
+    projectId: string;
+    projectRef?: string;
+    agentId: string;
+}): string;

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

@@ -0,0 +1,7 @@
+import { ImageModelInfo, ServiceMode, ServiceModePermissionMap, TextModelInfo } from '../types/common';
+export declare const defaultTextModel = "gpt-4o-mini";
+export declare const supportJsonSchemaModels: string[];
+export declare function getSupportedModels(): Promise<TextModelInfo[]>;
+export declare const defaultImageModel = "dall-e-2";
+export declare function getSupportedImagesModels(): Promise<ImageModelInfo[]>;
+export declare function getServiceModePermissionMap(serviceMode: ServiceMode): ServiceModePermissionMap;