@aigne/core 0.4.209 → 0.4.210

package/lib/esm/utils/constants.js

@@ -0,0 +1 @@
+export const FETCH_TIMEOUT = Number(process.env.FETCH_TIMEOUT) || 30000;

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

@@ -0,0 +1,26 @@
+import { withQuery } from 'ufo';
+import { FETCH_TIMEOUT } from './constants';
+import { checkFetchResponse } from './fetch';
+export const fetchOpenApi = async (request) => {
+    const cookie = request.cookies
+        ? Object.entries(request.cookies)
+            .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`)
+            .join('; ')
+            .trim()
+        : undefined;
+    const controller = new AbortController();
+    const abortTimer = setTimeout(() => controller.abort(), FETCH_TIMEOUT);
+    const response = await fetch(withQuery(request.url, request.query ?? {}), {
+        method: request.method,
+        headers: {
+            'Content-Type': 'application/json',
+            ...request.headers,
+            ...(cookie && { cookie }),
+        },
+        body: request.method.toLowerCase() !== 'get' && request.body ? JSON.stringify(request.body) : undefined,
+        credentials: request.cookies ? 'include' : 'same-origin',
+        signal: controller.signal,
+    }).finally(() => clearTimeout(abortTimer));
+    await checkFetchResponse(response);
+    return response.json();
+};

package/lib/esm/utils/fetch.js

@@ -0,0 +1,17 @@
+export async function checkFetchResponse(result) {
+    if (!result.ok) {
+        let message;
+        try {
+            const json = await result.json();
+            const msg = json.error?.message || json.message;
+            if (msg && typeof msg === 'string') {
+                message = msg;
+            }
+        }
+        catch {
+            // ignore
+        }
+        throw new Error(message || `Failed to fetch url ${result.url} with status ${result.status}`);
+    }
+    return result;
+}

package/lib/esm/utils/index.js

@@ -1,7 +1,10 @@
+export * from './fetch';
+export * from './fetch-open-api';
 export * from './is-non-nullable';
 export * from './mustache-utils';
 export * from './nullable';
 export * from './omit';
+export * from './open-api-parameter';
 export * from './ordered-map';
 export * from './stream-utils';
 export * from './union';

package/lib/esm/utils/open-api-parameter.js

@@ -0,0 +1,78 @@
+import { isEmpty, omitBy } from 'lodash';
+import logger from '../logger';
+import { OrderedRecord } from './ordered-map';
+export async function formatOpenAPIRequest(api, inputs, input) {
+    const { url, method, ...inputParams } = processParameters(api, inputs, input);
+    logger.debug('inputParams', inputParams);
+    const authParams = await getAuthParams(api.auth);
+    logger.debug('authParams', authParams);
+    return {
+        url,
+        method,
+        ...omitBy({
+            ...inputParams,
+            query: { ...inputParams.query, ...authParams.query },
+            cookies: { ...inputParams.cookies, ...authParams.cookies },
+            headers: { ...inputParams.headers, ...authParams.headers },
+        }, (i) => isEmpty(i)),
+    };
+}
+async function getAuthParams(auth) {
+    if (!auth)
+        return {};
+    if (auth.type === 'custom') {
+        return await auth.getValue();
+    }
+    const { type, key, token } = auth;
+    switch (auth.in) {
+        case 'query':
+            return { query: { [key || 'token']: token } };
+        case 'cookie':
+            return { cookies: { [key || 'token']: token } };
+        default: {
+            const prefix = type === 'bearer' ? 'Bearer ' : type === 'basic' ? 'Basic ' : '';
+            return { headers: { [key || 'Authorization']: `${prefix}${token}` } };
+        }
+    }
+}
+function processParameters(api, inputs, input) {
+    const result = {
+        url: api.url,
+        method: api.method,
+        headers: {},
+        query: {},
+        cookies: {},
+        body: {},
+    };
+    Object.entries(input).forEach(([key, value]) => {
+        const schema = OrderedRecord.find(inputs, (x) => x.name === key);
+        if (!schema)
+            return;
+        switch (schema.in) {
+            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':
+                result.url = result.url.replace(`{${key}}`, String(value));
+                break;
+            default:
+                // 没有指定 in 的情况
+                if (result.method.toLowerCase() === 'get') {
+                    result.query[key] = value;
+                }
+                else {
+                    result.body[key] = value;
+                }
+        }
+    });
+    return result;
+}

package/lib/types/context.d.ts

@@ -3,6 +3,7 @@ import { Runnable, RunnableDefinition } from './runnable';
 export interface ContextState {
     userId?: string;
     sessionId?: string;
+    [key: string]: any;
 }
 export interface ContextConfig {
     llmModel?: LLMModelConfiguration;

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

@@ -1,5 +1,5 @@
-import { OrderedRecord } from '../utils';
 import { MakeNullablePropertyOptional } from '../utils/nullable';
+import { OrderedRecord } from '../utils/ordered-map';
 import { DataType } from './data-type';
 export declare function schemaToDataType(dataType: {
     [name: string]: DataTypeSchema;

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

@@ -0,0 +1,36 @@
+import type { DataType } from './data-type';
+import type { DataTypeSchema } from './data-type-schema';
+export interface BaseAuthConfig {
+    type: 'bearer' | 'basic';
+    token: string;
+    in?: 'header' | 'query' | 'cookie';
+    /**
+     * The key to use for the token. Default `Authorization` in header and `token` in query and cookie.
+     */
+    key?: string;
+}
+export interface CustomAuthConfig {
+    type: 'custom';
+    getValue: () => Promise<AuthResult> | AuthResult;
+}
+export type AuthConfig = BaseAuthConfig | CustomAuthConfig;
+export type AuthType = AuthConfig['type'];
+export type AuthResult = Pick<FetchRequest, 'headers' | 'query' | 'cookies'>;
+type HTTPMethodLowercase = 'get' | 'post' | 'put' | 'delete' | 'patch' | 'head' | 'options';
+export type HTTPMethod = Uppercase<HTTPMethodLowercase> | Lowercase<HTTPMethodLowercase>;
+export type ParameterLocation = 'path' | 'query' | 'body' | 'header' | 'cookie';
+export type OpenAPIDataType = DataType & {
+    in?: ParameterLocation;
+};
+export type OpenAPIDataTypeSchema = DataTypeSchema & {
+    in?: ParameterLocation;
+};
+export type FetchRequest = {
+    url: string;
+    method: HTTPMethod;
+    query?: Record<string, string | number | boolean>;
+    headers?: Record<string, string>;
+    cookies?: Record<string, string>;
+    body?: Record<string, any>;
+};
+export {};

package/lib/types/index.d.ts

@@ -2,6 +2,8 @@ export * from './utils';
 export * from './constants';
 export * from './definitions/data-type';
 export * from './definitions/data-type-schema';
+export * from './definitions/open-api';
+export * from './definitions/memory';
 export * from './context';
 export * from './runnable';
 export * from './agent';
@@ -12,4 +14,5 @@ export * from './function-agent';
 export * from './function-runner';
 export * from './llm-decision-agent';
 export * from './local-function-agent';
+export * from './open-api-agent';
 export * from './memorable';

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

@@ -0,0 +1,55 @@
+import { Agent } from './agent';
+import type { Context, ContextState } from './context';
+import { DataTypeSchema, SchemaMapType } from './definitions/data-type-schema';
+import { CreateRunnableMemory } from './definitions/memory';
+import { AuthConfig, FetchRequest, HTTPMethod, OpenAPIDataType, OpenAPIDataTypeSchema } from './definitions/open-api';
+import { MemorableSearchOutput, MemoryItemWithScore } from './memorable';
+import { RunnableDefinition } from './runnable';
+import { OrderedRecord } from './utils';
+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: 'open_api_agent';
+    inputs: OrderedRecord<OpenAPIDataType>;
+    url: string;
+    method?: HTTPMethod;
+    auth?: AuthConfig;
+}
+export interface CreateOpenAPIAgentOptions<I extends {
+    [name: string]: OpenAPIDataTypeSchema;
+}, 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?: HTTPMethod;
+    auth?: AuthConfig;
+}
+declare function create<I extends {
+    [name: string]: OpenAPIDataTypeSchema;
+}, 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 {};