@aigne/core 0.4.211-beta.2 → 1.0.0

package/lib/esm/utils/fetch-api.js

@@ -1,31 +0,0 @@
-import { withQuery } from 'ufo';
-import { TIMEOUT } from './constants';
-export const fetchApi = async (request) => {
-    let cookieString = '';
-    if (request.cookies) {
-        cookieString = Object.entries(request.cookies)
-            .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`)
-            .join('; ');
-    }
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), Number(TIMEOUT));
-    const response = await fetch(withQuery(request.url, request.query || {}), {
-        method: request.method,
-        headers: {
-            'Content-Type': 'application/json',
-            ...(cookieString && { Cookie: cookieString.trim() }),
-            ...request.headers,
-        },
-        body: request.method !== 'GET' ? JSON.stringify(request.body) : undefined,
-        credentials: request.cookies ? 'include' : 'same-origin',
-        signal: controller.signal,
-    }).finally(() => clearTimeout(timeoutId));
-    if (!response.ok) {
-        const errorBody = await response.text();
-        throw new Error(`API request failed for ${request.url}\n` +
-            `Status: ${response.status} ${response.statusText}\n` +
-            `Response: ${errorBody.slice(0, 200)}`);
-    }
-    return response.json();
-};
-export default fetchApi;

package/lib/esm/utils/flatten-openapi.js

@@ -1,11 +0,0 @@
-export function flattenApiStructure(apiStructure) {
-    const paths = apiStructure?.paths || {};
-    return Object.entries(paths).flatMap(([, methods]) => Object.entries(methods).map(([, endpoint]) => ({
-        id: endpoint['x-id'],
-        name: endpoint['x-did'],
-        path: endpoint['x-path'],
-        method: endpoint['x-method'],
-        did: endpoint['x-did'],
-        ...endpoint,
-    })));
-}

package/lib/esm/utils/format-parameter.js

@@ -1,116 +0,0 @@
-import logger from '../logger';
-export function getAuthParams(auth) {
-    if (!auth)
-        return {};
-    if (auth.type === 'custom') {
-        return { headers: auth.getValue() };
-    }
-    const paramKey = auth.key || 'Authorization';
-    const paramValue = (() => {
-        let paramValue = auth.token;
-        switch (auth.type) {
-            case 'basic':
-                paramValue = `Basic ${auth.token}`;
-                break;
-            case 'bearer':
-                paramValue = `Bearer ${auth.token}`;
-                break;
-            default:
-                break;
-        }
-        return paramValue;
-    })();
-    switch (auth.in) {
-        case 'header':
-            return { headers: { [paramKey]: paramValue } };
-        case 'query':
-            return { query: { [paramKey]: paramValue } };
-        case 'cookie':
-            return { cookies: { [paramKey]: paramValue } };
-        default:
-            // 默认放在 header 中
-            return { headers: { [paramKey]: paramValue } };
-    }
-}
-export function processParameters(api, inputs, input) {
-    const method = (api.method || 'GET').toUpperCase();
-    const result = {
-        url: api.url,
-        method,
-        headers: {},
-        query: {},
-        cookies: {},
-        body: {},
-    };
-    const filterInputs = Object.values(inputs).filter((i) => !Array.isArray(i));
-    // 处理路径参数
-    let processedUrl = api.url;
-    const pathParams = filterInputs.filter((x) => x.in === 'path');
-    pathParams.forEach(({ name }) => {
-        if (name && input[name] !== undefined) {
-            const placeholder = `{${name}}`;
-            processedUrl = processedUrl.replace(placeholder, String(input[name]));
-        }
-    });
-    result.url = processedUrl;
-    // 处理其他参数
-    Object.entries(input).forEach(([key, value]) => {
-        const schema = filterInputs.find((i) => i.name === key);
-        const paramIn = schema?.in;
-        switch (paramIn) {
-            case 'query':
-                result.query[key] = value;
-                break;
-            case 'header':
-                result.headers[key] = value;
-                break;
-            case 'cookie':
-                result.cookies[key] = value;
-                break;
-            case 'body':
-                result.body[key] = value;
-                break;
-            case 'path':
-                break;
-            default:
-                // 没有指定 in 的情况
-                if (method === 'GET') {
-                    result.query[key] = value;
-                }
-                else {
-                    result.body[key] = value;
-                }
-        }
-    });
-    return result;
-}
-export function mergeParameters(parameters, authParams) {
-    const result = {};
-    if (parameters.query || authParams.query) {
-        result.query = { ...(parameters.query || {}), ...(authParams.query || {}) };
-    }
-    if (parameters.cookies || authParams.cookies) {
-        result.cookies = { ...(parameters.cookies || {}), ...(authParams.cookies || {}) };
-    }
-    if (parameters.headers || authParams.headers) {
-        result.headers = { ...(parameters.headers || {}), ...(authParams.headers || {}) };
-    }
-    return result;
-}
-export const formatRequest = (api, inputs, input) => {
-    const inputParams = processParameters(api, inputs, input);
-    logger.debug('inputParams', inputParams);
-    const authParams = getAuthParams(api.auth);
-    logger.debug('authParams', authParams);
-    const mergedParams = mergeParameters(inputParams, authParams);
-    logger.debug('mergedParams', mergedParams);
-    const params = { ...inputParams, ...mergedParams };
-    return {
-        url: params.url,
-        method: params.method,
-        ...(params.headers && Object.keys(params.headers).length > 0 && { headers: params.headers }),
-        ...(params.query && Object.keys(params.query).length > 0 && { query: params.query }),
-        ...(params.cookies && Object.keys(params.cookies).length > 0 && { cookies: params.cookies }),
-        ...(params.body && Object.keys(params.body).length > 0 && { body: params.body }),
-    };
-};

package/lib/types/api-agent.d.ts

@@ -1,53 +0,0 @@
-import { Agent } from './agent';
-import type { Context, ContextState } from './context';
-import { AuthConfig, FetchRequest, FormatMethod } from './definitions/api-parameter';
-import { DataTypeSchema, InputDataTypeSchema, SchemaMapType } from './definitions/data-type-schema';
-import { CreateRunnableMemory } from './definitions/memory';
-import { MemorableSearchOutput, MemoryItemWithScore } from './memorable';
-import { RunnableDefinition } from './runnable';
-export declare class OpenAPIAgent<I extends {
-    [name: string]: any;
-} = {}, O extends {
-    [name: string]: any;
-} = {}, Memories extends {
-    [name: string]: MemoryItemWithScore[];
-} = {}, State extends ContextState = ContextState> extends Agent<I, O, Memories, State> {
-    definition: OpenAPIAgentDefinition;
-    static create: typeof create;
-    constructor(definition: OpenAPIAgentDefinition, context?: Context<State>);
-    process(input: I): Promise<any>;
-    fetch(request: FetchRequest): Promise<any>;
-}
-export interface OpenAPIAgentDefinition extends RunnableDefinition {
-    type: 'api_agent';
-    url: string;
-    method?: FormatMethod;
-    auth?: AuthConfig;
-}
-export interface CreateOpenAPIAgentOptions<I extends {
-    [name: string]: DataTypeSchema;
-}, O extends {
-    [name: string]: DataTypeSchema;
-}, Memories extends {
-    [name: string]: CreateRunnableMemory<I>;
-}, State extends ContextState> {
-    context?: Context<State>;
-    id?: string;
-    name?: string;
-    inputs: I;
-    outputs: O;
-    memories?: Memories;
-    url: string;
-    method?: FormatMethod;
-    auth?: AuthConfig;
-}
-declare function create<I extends {
-    [name: string]: InputDataTypeSchema;
-}, O extends {
-    [name: string]: DataTypeSchema;
-}, Memories extends {
-    [name: string]: CreateRunnableMemory<I>;
-}, State extends ContextState>({ context, ...options }: CreateOpenAPIAgentOptions<I, O, Memories, State>): OpenAPIAgent<SchemaMapType<I>, SchemaMapType<O>, {
-    [name in keyof Memories]: MemorableSearchOutput<Memories[name]['memory']>;
-}, State>;
-export {};

package/lib/types/data-type-schema.d.ts

@@ -1,46 +0,0 @@
-import { DataType } from './data-type';
-import { OrderedRecord } from './utils';
-export declare function schemaToDataType(dataType: {
-    [name: string]: DataTypeSchema;
-}): OrderedRecord<DataType>;
-export type DataTypeSchema = DataTypeSchemaString | DataTypeSchemaNumber | DataTypeSchemaBoolean | DataTypeSchemaObject | DataTypeSchemaArray;
-export interface DataTypeSchemaBase {
-    description?: string;
-    required?: boolean;
-}
-export interface DataTypeSchemaString extends DataTypeSchemaBase {
-    type: 'string';
-}
-export interface DataTypeSchemaNumber extends DataTypeSchemaBase {
-    type: 'number';
-}
-export interface DataTypeSchemaBoolean extends DataTypeSchemaBase {
-    type: 'boolean';
-}
-export interface DataTypeSchemaObject extends DataTypeSchemaBase {
-    type: 'object';
-    properties: {
-        [key: string]: DataTypeSchema;
-    };
-}
-export interface DataTypeSchemaArray extends DataTypeSchemaBase {
-    type: 'array';
-    items: DataTypeSchema;
-}
-type SchemaTypeInner<T extends DataTypeSchema> = T extends DataTypeSchemaString ? string : T extends DataTypeSchemaNumber ? number : T extends DataTypeSchemaBoolean ? boolean : T extends DataTypeSchemaObject ? MakeNullablePropertyOptional<{
-    [K in keyof T['properties']]: SchemaType<T['properties'][K]>;
-}> : T extends DataTypeSchemaArray ? SchemaType<T['items']>[] : never;
-export type SchemaType<T extends DataTypeSchema> = T['required'] extends true ? SchemaTypeInner<T> : SchemaTypeInner<T> | undefined | null;
-export type SchemaMapType<T extends Record<string, DataTypeSchema>> = SchemaType<{
-    type: 'object';
-    required: true;
-    properties: T;
-}>;
-type MakeNullablePropertyOptional<T extends {
-    [key: string]: any;
-}> = {
-    [K in keyof T as Extract<T[K], null | undefined> extends never ? K : never]: T[K];
-} & {
-    [K in keyof T as Extract<T[K], null | undefined> extends never ? never : K]?: T[K];
-};
-export {};

package/lib/types/data-type.d.ts

@@ -1,32 +0,0 @@
-import { OmitPropsFromUnion } from './utils/omit';
-import { OrderedRecord } from './utils/ordered-map';
-export type DataType = DataTypeString | DataTypeNumber | DataTypeBoolean | DataTypeObject | DataTypeArray;
-export interface DataTypeBase {
-    id: string;
-    name?: string;
-    description?: string;
-    required?: boolean;
-}
-export interface DataTypeString extends DataTypeBase {
-    type: 'string';
-    defaultValue?: string;
-    multiline?: boolean;
-}
-export interface DataTypeNumber extends DataTypeBase {
-    type: 'number';
-    defaultValue?: number;
-}
-export interface DataTypeBoolean extends DataTypeBase {
-    type: 'boolean';
-    defaultValue?: boolean;
-}
-export interface DataTypeObject extends DataTypeBase {
-    type: 'object';
-    defaultValue?: object;
-    properties?: OrderedRecord<DataType>;
-}
-export interface DataTypeArray extends DataTypeBase {
-    type: 'array';
-    defaultValue?: object[];
-    items?: OmitPropsFromUnion<DataType, 'id'>;
-}

package/lib/types/definitions/api-parameter.d.ts

@@ -1,55 +0,0 @@
-export type AuthType = 'apiKey' | 'basic' | 'bearer' | 'custom';
-export interface BaseAuthConfig {
-    type: AuthType;
-    token: string;
-    in?: 'header' | 'query' | 'cookie';
-    key?: string;
-}
-export interface ApiKeyAuthConfig extends BaseAuthConfig {
-    type: 'apiKey';
-}
-export interface BasicAuthConfig extends BaseAuthConfig {
-    type: 'basic';
-}
-export interface BearerAuthConfig extends BaseAuthConfig {
-    type: 'bearer';
-}
-export interface CustomAuthConfig extends Omit<BaseAuthConfig, 'in' | 'key' | 'token'> {
-    type: 'custom';
-    getValue: () => Record<string, string>;
-}
-export type AuthConfig = ApiKeyAuthConfig | BasicAuthConfig | BearerAuthConfig | CustomAuthConfig;
-export interface AuthResult {
-    headers?: Record<string, string>;
-    query?: Record<string, string>;
-    cookies?: Record<string, string>;
-}
-export declare const enum HTTPMethod {
-    GET = "GET",
-    POST = "POST",
-    PUT = "PUT",
-    DELETE = "DELETE"
-}
-export type FormatMethod = Uppercase<HTTPMethod> | Lowercase<HTTPMethod>;
-export type API = {
-    url: string;
-    method?: FormatMethod;
-    auth?: AuthConfig;
-};
-export type ParameterLocation = 'path' | 'query' | 'body' | 'header' | 'cookie';
-export type OpenAPIParameter = {
-    in?: ParameterLocation;
-};
-export type FetchRequest = {
-    url: string;
-    method: string;
-    headers?: Record<string, string>;
-    query?: Record<string, string>;
-    cookies?: Record<string, string>;
-    body?: Record<string, any>;
-};
-export interface ParametersResult extends AuthResult {
-    url: string;
-    method: string;
-    body?: Record<string, any>;
-}

package/lib/types/memory.d.ts

@@ -1,184 +0,0 @@
-import { Runnable } from './runnable';
-export interface MemoryMetadata {
-    [key: string]: any;
-}
-export type MemoryActionItem<T> = {
-    event: 'add';
-    id: string;
-    memory: T;
-    metadata?: MemoryMetadata;
-} | {
-    event: 'update';
-    id: string;
-    memory: T;
-    oldMemory: T;
-    metadata?: MemoryMetadata;
-} | {
-    event: 'delete';
-    id: string;
-    memory: T;
-} | {
-    event: 'none';
-    memory: T;
-};
-export interface MemoryItem<T> {
-    id: string;
-    userId?: string;
-    sessionId?: string;
-    createdAt: string;
-    updatedAt: string;
-    memory: T;
-    metadata: MemoryMetadata;
-}
-export interface MemoryItemWithScore<T> extends MemoryItem<T> {
-    score: number;
-}
-export interface MemoryMessage {
-    role: string;
-    content: string;
-}
-export type MemoryActions<T> = {
-    action: 'add';
-    inputs: {
-        messages: MemoryMessage[];
-        options?: {
-            userId?: string;
-            sessionId?: string;
-            metadata?: MemoryMetadata;
-        };
-    };
-    outputs: {
-        results: MemoryActionItem<T>[];
-    };
-} | {
-    action: 'search';
-    inputs: {
-        query: string;
-        options?: {
-            k?: number;
-            userId?: string;
-            sessionId?: string;
-            filter?: MemoryMetadata;
-            sort?: MemorySortOptions;
-        };
-    };
-    outputs: {
-        results: MemoryItemWithScore<T>[];
-    };
-} | {
-    action: 'filter';
-    inputs: {
-        options?: {
-            k?: number;
-            userId?: string;
-            sessionId?: string;
-            filter?: MemoryMetadata;
-            sort?: MemorySortOptions;
-        };
-    };
-    outputs: {
-        results: MemoryItem<T>[];
-    };
-} | {
-    action: 'get';
-    inputs: {
-        memoryId: string;
-    };
-    outputs: {
-        result: MemoryItem<T> | null;
-    };
-} | {
-    action: 'create';
-    inputs: {
-        memory: T;
-        options?: {
-            userId?: string;
-            sessionId?: string;
-            metadata?: MemoryMetadata;
-        };
-    };
-    outputs: {
-        result: MemoryItem<T>;
-    };
-} | {
-    action: 'update';
-    inputs: {
-        memoryId: string;
-        memory: T;
-    };
-    outputs: {
-        result: MemoryItem<T> | null;
-    };
-} | {
-    action: 'delete';
-    inputs: {
-        filter: string | string[] | Record<string, any>;
-    };
-    outputs: {};
-} | {
-    action: 'reset';
-    inputs: {};
-    outputs: {};
-};
-export interface SortItem {
-    field: string;
-    direction: 'asc' | 'desc';
-}
-export type MemorySortOptions = SortItem | SortItem[];
-export declare abstract class Memory<T, C = undefined> extends Runnable<MemoryActions<T>, MemoryActions<T>['outputs']> {
-    constructor();
-    abstract runner?: MemoryRunner<T, C>;
-    abstract add(messages: Extract<MemoryActions<T>, {
-        action: 'add';
-    }>['inputs']['messages'], options?: Extract<MemoryActions<T>, {
-        action: 'add';
-    }>['inputs']['options']): Promise<Extract<MemoryActions<T>, {
-        action: 'add';
-    }>['outputs']>;
-    abstract search(query: Extract<MemoryActions<T>, {
-        action: 'search';
-    }>['inputs']['query'], options?: Extract<MemoryActions<T>, {
-        action: 'search';
-    }>['inputs']['options']): Promise<Extract<MemoryActions<T>, {
-        action: 'search';
-    }>['outputs']>;
-    abstract filter(options: Extract<MemoryActions<T>, {
-        action: 'filter';
-    }>['inputs']['options']): Promise<Extract<MemoryActions<T>, {
-        action: 'filter';
-    }>['outputs']>;
-    abstract get(memoryId: Extract<MemoryActions<T>, {
-        action: 'get';
-    }>['inputs']['memoryId']): Promise<Extract<MemoryActions<T>, {
-        action: 'get';
-    }>['outputs']>;
-    abstract create(memory: Extract<MemoryActions<T>, {
-        action: 'create';
-    }>['inputs']['memory'], options?: Extract<MemoryActions<T>, {
-        action: 'create';
-    }>['inputs']['options']): Promise<Extract<MemoryActions<T>, {
-        action: 'create';
-    }>['outputs']>;
-    abstract update(memoryId: Extract<MemoryActions<T>, {
-        action: 'update';
-    }>['inputs']['memoryId'], memory: T): Promise<Extract<MemoryActions<T>, {
-        action: 'update';
-    }>['outputs']>;
-    abstract delete(memoryId: Extract<MemoryActions<T>, {
-        action: 'delete';
-    }>['inputs']['filter']): Promise<Extract<MemoryActions<T>, {
-        action: 'delete';
-    }>['outputs']>;
-    abstract reset(): Promise<void>;
-}
-export interface MemoryRunnerInput<C = undefined> {
-    messages: MemoryMessage[];
-    userId?: string;
-    sessionId?: string;
-    metadata?: MemoryMetadata;
-    filter?: MemoryMetadata;
-    customData: C;
-}
-export declare abstract class MemoryRunner<T, C = undefined> extends Runnable<MemoryRunnerInput<C>, MemoryActionItem<T>[]> {
-    constructor(name: string);
-}