@aigne/core 1.0.17 → 1.1.0-beta.2

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

@@ -1,78 +0,0 @@
-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.auth();
-    }
-    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: {},
-    };
-    for (const [key, value] of Object.entries(input)) {
-        const schema = OrderedRecord.find(inputs, (x) => x.name === key);
-        if (!schema)
-            continue;
-        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/esm/utils/ordered-map.d.ts

@@ -1,37 +0,0 @@
-export type OrderedRecord<T extends {
-    id: string;
-}> = Record<string, T> & {
-    $indexes: string[];
-};
-export declare namespace OrderedRecord {
-    function iterator<T extends {
-        id: string;
-    }>(record?: OrderedRecord<T>): IterableIterator<T>;
-    function map<O, T extends {
-        id: string;
-    }>(record: OrderedRecord<T> | undefined, fn: (value: T, index: number) => O): O[];
-    function toArray<T extends {
-        id: string;
-    }>(record: OrderedRecord<T> | undefined): T[];
-    function fromArray<T extends {
-        id: string;
-    }>(array?: T[]): OrderedRecord<T>;
-    function find<T extends {
-        id: string;
-    }>(record: OrderedRecord<T> | undefined, predicate: (value: T, index: number) => boolean): T | undefined;
-    function filter<T extends {
-        id: string;
-    }>(record: OrderedRecord<T> | undefined, predicate: (value: T, index: number) => boolean): T[];
-    function at<T extends {
-        id: string;
-    }>(record: OrderedRecord<T> | undefined, index: number): T | undefined;
-    function push<T extends {
-        id: string;
-    }>(record: OrderedRecord<T>, ...items: T[]): OrderedRecord<T>;
-    function merge<T extends {
-        id: string;
-    }>(...records: OrderedRecord<T>[]): OrderedRecord<T>;
-    function pushOrUpdate<T extends {
-        id: string;
-    }>(record: OrderedRecord<T>, ...items: T[]): OrderedRecord<T>;
-}

package/lib/esm/utils/ordered-map.js

@@ -1,100 +0,0 @@
-export var OrderedRecord;
-(function (OrderedRecord) {
-    function iterator(record) {
-        return (function* () {
-            if (!record)
-                return;
-            for (const id of record.$indexes) {
-                yield record[id];
-            }
-        })();
-    }
-    OrderedRecord.iterator = iterator;
-    function map(record, fn) {
-        if (!record)
-            return [];
-        const result = new Array(record.$indexes.length);
-        for (let i = 0; i < record.$indexes.length; i++) {
-            result[i] = fn(record[record.$indexes[i]], i);
-        }
-        return result;
-    }
-    OrderedRecord.map = map;
-    function toArray(record) {
-        return OrderedRecord.map(record, (value) => value);
-    }
-    OrderedRecord.toArray = toArray;
-    function fromArray(array) {
-        const record = { $indexes: [] };
-        for (const value of array ?? []) {
-            record[value.id] = value;
-            record.$indexes.push(value.id);
-        }
-        return record;
-    }
-    OrderedRecord.fromArray = fromArray;
-    function find(record, predicate) {
-        if (!record)
-            return undefined;
-        for (let i = 0; i < record.$indexes.length; i++) {
-            const id = record.$indexes[i];
-            const value = record[id];
-            if (predicate(value, i))
-                return value;
-        }
-        return undefined;
-    }
-    OrderedRecord.find = find;
-    function filter(record, predicate) {
-        if (!record)
-            return [];
-        const result = [];
-        for (let i = 0; i < record.$indexes.length; i++) {
-            const id = record.$indexes[i];
-            const value = record[id];
-            if (predicate(value, i))
-                result.push(value);
-        }
-        return result;
-    }
-    OrderedRecord.filter = filter;
-    function at(record, index) {
-        if (!record?.$indexes.length)
-            return undefined;
-        const id = record.$indexes.at(index);
-        return record[id];
-    }
-    OrderedRecord.at = at;
-    function push(record, ...items) {
-        for (const item of items) {
-            if (record[item.id])
-                throw new Error(`Item with id ${item.id} already exists`);
-            record.$indexes.push(item.id);
-            record[item.id] = item;
-        }
-        return record;
-    }
-    OrderedRecord.push = push;
-    function merge(...records) {
-        const result = { $indexes: [] };
-        for (const record of records) {
-            for (const id of record.$indexes) {
-                if (!result[id])
-                    result.$indexes.push(id);
-                result[id] = record[id];
-            }
-        }
-        return result;
-    }
-    OrderedRecord.merge = merge;
-    function pushOrUpdate(record, ...items) {
-        for (const item of items) {
-            if (!record[item.id]) {
-                record.$indexes.push(item.id);
-            }
-            record[item.id] = item;
-        }
-        return record;
-    }
-    OrderedRecord.pushOrUpdate = pushOrUpdate;
-})(OrderedRecord || (OrderedRecord = {}));

package/lib/esm/utils/partial.d.ts

@@ -1,3 +0,0 @@
-export type DeepPartial<T> = T extends object ? {
-    [P in keyof T]?: DeepPartial<T[P]>;
-} : T;

package/lib/esm/utils/partial.js

@@ -1 +0,0 @@
-export {};

package/lib/esm/utils/runnable-type.d.ts

@@ -1,5 +0,0 @@
-import type { Runnable, RunnableInput, RunnableOutput, RunnableResponseStream } from "../runnable";
-import type { UnionToIntersection } from "./union";
-export type ExtractRunnableInputType<T> = T extends Runnable<infer I, RunnableOutput> ? I : never;
-export type ExtractRunnableOutputType<T> = T extends Runnable<RunnableInput, infer O> ? Exclude<O, RunnableResponseStream<unknown>> : never;
-export type ExtractRunnableInputTypeIntersection<T> = UnionToIntersection<ExtractRunnableInputType<T>, Record<string, unknown>>;

package/lib/esm/utils/runnable-type.js

@@ -1 +0,0 @@
-export {};

package/lib/esm/utils/stream-utils.d.ts

@@ -1,20 +0,0 @@
-import { type RunnableResponse, type RunnableResponseChunk, type RunnableResponseStream } from "../runnable";
-export declare function objectToRunnableResponseStream<T extends {
-    [key: string]: any;
-}>(obj: T): RunnableResponseStream<T>;
-export declare function runnableResponseStreamToObject<T extends {
-    [key: string]: any;
-}>(stream: RunnableResponseStream<T> | AsyncGenerator<RunnableResponseChunk<T>>): Promise<T>;
-/**
- * Extracts the outputs from a runnable output stream and run the
- * resolve function on the result before the stream closes. It can be
- * used to update the memories of an agent.
- * @param output The runnable output stream or object
- * @param resolve The function to run on the result
- * @returns The runnable output stream or object
- */
-export declare function extractOutputsFromRunnableOutput<T extends {
-    [key: string]: any;
-}>(output: RunnableResponse<T> | AsyncGenerator<RunnableResponseChunk<T>>, resolve: (result: T) => Promise<void> | void): Promise<RunnableResponse<T>>;
-export declare function asyncGeneratorToReadableStream<T>(generator: AsyncGenerator<T>): ReadableStream<T>;
-export declare function isAsyncGenerator<T extends AsyncGenerator>(value: any): value is T;

package/lib/esm/utils/stream-utils.js

@@ -1,79 +0,0 @@
-import { isRunnableResponseDelta, } from "../runnable";
-export function objectToRunnableResponseStream(obj) {
-    return new ReadableStream({
-        start(controller) {
-            controller.enqueue({ $text: obj.$text || undefined, delta: obj });
-            controller.close();
-        },
-    });
-}
-export async function runnableResponseStreamToObject(stream) {
-    let $text = "";
-    const result = {};
-    for await (const value of stream) {
-        if (isRunnableResponseDelta(value)) {
-            $text += value.$text || "";
-            Object.assign(result, value.delta);
-        }
-    }
-    Object.assign(result, { $text: result.$text || $text || undefined });
-    return result;
-}
-/**
- * Extracts the outputs from a runnable output stream and run the
- * resolve function on the result before the stream closes. It can be
- * used to update the memories of an agent.
- * @param output The runnable output stream or object
- * @param resolve The function to run on the result
- * @returns The runnable output stream or object
- */
-export async function extractOutputsFromRunnableOutput(output, resolve) {
-    if (output instanceof ReadableStream ||
-        isAsyncGenerator(output)) {
-        return new ReadableStream({
-            async start(controller) {
-                try {
-                    const result = {};
-                    let $text = "";
-                    for await (const value of output) {
-                        controller.enqueue(value);
-                        if (isRunnableResponseDelta(value)) {
-                            $text += value.$text || "";
-                            Object.assign(result, value.delta);
-                        }
-                    }
-                    Object.assign(result, { $text: result.$text || $text || undefined });
-                    await resolve(result);
-                }
-                catch (error) {
-                    controller.error(error);
-                }
-                finally {
-                    controller.close();
-                }
-            },
-        });
-    }
-    await resolve(output);
-    return output;
-}
-export function asyncGeneratorToReadableStream(generator) {
-    return new ReadableStream({
-        async start(controller) {
-            try {
-                for await (const value of generator) {
-                    controller.enqueue(value);
-                }
-            }
-            catch (error) {
-                controller.error(error);
-            }
-            finally {
-                controller.close();
-            }
-        },
-    });
-}
-export function isAsyncGenerator(value) {
-    return Symbol.asyncIterator in value;
-}

package/lib/esm/utils/structured-output-schema.d.ts

@@ -1,3 +0,0 @@
-import type { RunnableOutputType } from "../runnable";
-import { OrderedRecord } from "./ordered-map";
-export declare function outputsToJsonSchema(outputs: OrderedRecord<RunnableOutputType>): object;

package/lib/esm/utils/structured-output-schema.js

@@ -1,37 +0,0 @@
-import omitBy from "lodash/omitBy";
-import { isNonNullable } from "./is-non-nullable";
-import { OrderedRecord } from "./ordered-map";
-export function outputsToJsonSchema(outputs) {
-    const outputToSchema = (output) => {
-        const properties = output.type === "object" && output.properties?.$indexes.length
-            ? OrderedRecord.map(output.properties, (property) => {
-                if (!property.name)
-                    return null;
-                const schema = outputToSchema(property);
-                if (!schema)
-                    return null;
-                return { schema, property };
-            }).filter(isNonNullable)
-            : undefined;
-        return omitBy({
-            type: output.type,
-            description: output.description,
-            properties: properties?.length
-                ? Object.fromEntries(properties.map((p) => [p.property.name, p.schema]))
-                : undefined,
-            items: output.type === "array" && output.items
-                ? outputToSchema(output.items)
-                : undefined,
-            additionalProperties: output.type === "object" ? false : undefined,
-            required: properties?.length
-                ? properties
-                    .filter((i) => i.property.required)
-                    .map((i) => i.property.name)
-                : undefined,
-        }, (v) => v === undefined);
-    };
-    return outputToSchema({
-        type: "object",
-        properties: outputs,
-    });
-}

package/lib/esm/utils/union.d.ts

@@ -1 +0,0 @@
-export type UnionToIntersection<U, O = any> = (U extends any ? (arg: U) => void : never) extends (arg: infer I) => void ? I extends O ? I : never : never;

package/lib/esm/utils/union.js

@@ -1 +0,0 @@
-export {};