@aigne/core 0.4.194 → 0.4.196

package/lib/esm/utils/index.js

@@ -0,0 +1,4 @@
+export * from './ordered-map';
+export * from './is-non-nullable';
+export * from './stream-utils';
+export * from './mustache-utils';

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/mustache-utils.js

@@ -0,0 +1,8 @@
+import Mustache from 'mustache';
+export function renderMessage(template, variables) {
+    return Mustache.render(template, variables, undefined, {
+        escape: (v) => {
+            return typeof v === 'object' ? JSON.stringify(v) : v;
+        },
+    });
+}

package/lib/esm/utils/omit.js

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

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

@@ -0,0 +1,68 @@
+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 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 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/stream-utils.js

@@ -0,0 +1,21 @@
+import { isRunnableResponseDelta } from '../runnable';
+export function objectToRunnableResponseStream(obj) {
+    return new ReadableStream({
+        start(controller) {
+            controller.enqueue({ delta: obj });
+            controller.close();
+        },
+    });
+}
+export async function runnableResponseStreamToObject(stream) {
+    let $text = '';
+    const lastValue = {};
+    for await (const value of stream) {
+        if (isRunnableResponseDelta(value)) {
+            $text += value.$text || '';
+            Object.assign(lastValue, value.delta);
+        }
+    }
+    Object.assign(lastValue, { $text: lastValue.$text || $text || undefined });
+    return lastValue;
+}

package/lib/types/constants.d.ts

@@ -0,0 +1,8 @@
+export declare const TYPES: {
+    context: symbol;
+    definition: symbol;
+    llmModel: symbol;
+    llmModelConfiguration: symbol;
+    functionRunner: symbol;
+};
+export declare const StreamTextOutputName = "$text";

package/lib/types/context.d.ts

@@ -0,0 +1,5 @@
+import { Runnable, RunnableDefinition } from './runnable';
+export interface Context<State = {}> {
+    state: State;
+    resolve<T extends Runnable>(id: string | RunnableDefinition): Promise<T>;
+}

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

@@ -0,0 +1,32 @@
+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/function-agent.d.ts

@@ -0,0 +1,36 @@
+import { DataType } from './data-type';
+import { FunctionRunner } from './function-runner';
+import { RunOptions, Runnable, RunnableDefinition, RunnableResponseStream } from './runnable';
+export declare class FunctionAgent<I extends {} = {}, O extends {} = {}> extends Runnable<I, O> {
+    definition: FunctionAgentDefinition;
+    runner?: FunctionRunner | undefined;
+    static create<I extends {} = {}, O extends {} = {}>(options: Parameters<typeof createFunctionAgentDefinition>[0]): FunctionAgent<I, O>;
+    constructor(definition: FunctionAgentDefinition, runner?: FunctionRunner | undefined);
+    run(input: I, options: RunOptions & {
+        stream: true;
+    }): Promise<RunnableResponseStream<O>>;
+    run(input: I, options?: RunOptions & {
+        stream?: false;
+    }): Promise<O>;
+}
+export declare function createFunctionAgentDefinition(options: {
+    id?: string;
+    name?: string;
+    inputs?: {
+        name: string;
+        type: DataType['type'];
+        required?: boolean;
+    }[];
+    outputs?: {
+        name: string;
+        type: DataType['type'];
+        required?: boolean;
+    }[];
+    language: string;
+    code: string;
+}): FunctionAgentDefinition;
+export interface FunctionAgentDefinition extends RunnableDefinition {
+    type: 'function_agent';
+    language?: string;
+    code?: string;
+}

package/lib/types/function-runner.d.ts

@@ -0,0 +1,11 @@
+import { Runnable } from './runnable';
+export interface FunctionRunnerInputs {
+    name: string;
+    language: string;
+    code: string;
+    arguments?: object;
+}
+export type FunctionRunnerOutputs = object;
+export declare abstract class FunctionRunner extends Runnable<FunctionRunnerInputs, FunctionRunnerOutputs> {
+    constructor();
+}

package/lib/types/index.d.ts

@@ -1 +1,13 @@
-export * from './types';
+export * from './utils';
+export * from './constants';
+export * from './data-type';
+export * from './context';
+export * from './runnable';
+export * from './pipeline-agent';
+export * from './llm-agent';
+export * from './llm-model';
+export * from './function-agent';
+export * from './function-runner';
+export * from './llm-decision-agent';
+export * from './local-function-agent';
+export * from './memory';

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

@@ -0,0 +1,37 @@
+import { DataType } from './data-type';
+import { LLMModel, LLMModelInputs, Role } from './llm-model';
+import { RunOptions, Runnable, RunnableDefinition, RunnableResponseStream } from './runnable';
+import { OmitPropsFromUnion } from './utils/omit';
+import { OrderedRecord } from './utils/ordered-map';
+export declare class LLMAgent<I extends {} = {}, O extends {} = {}> extends Runnable<I, O> {
+    definition: LLMAgentDefinition;
+    model?: LLMModel | undefined;
+    static create<I extends {} = {}, O extends {} = {}>(options: Parameters<typeof createLLMAgentDefinition>[0]): LLMAgent<I, O>;
+    constructor(definition: LLMAgentDefinition, model?: LLMModel | undefined);
+    run(input: I, options: RunOptions & {
+        stream: true;
+    }): Promise<RunnableResponseStream<O>>;
+    run(input: I, options?: RunOptions & {
+        stream?: false;
+    }): Promise<O>;
+}
+export declare function createLLMAgentDefinition(options: {
+    id?: string;
+    name?: string;
+    messages?: {
+        role: Role;
+        content: string;
+    }[];
+    modelOptions?: LLMModelInputs['modelOptions'];
+    inputs?: OmitPropsFromUnion<DataType, 'id'>[];
+    outputs?: OmitPropsFromUnion<DataType, 'id'>[];
+}): LLMAgentDefinition;
+export interface LLMAgentDefinition extends RunnableDefinition {
+    type: 'llm_agent';
+    messages?: OrderedRecord<{
+        id: string;
+        role: Role;
+        content: string;
+    }>;
+    modelOptions?: LLMModelInputs['modelOptions'];
+}

package/lib/types/llm-decision-agent.d.ts

@@ -0,0 +1,66 @@
+import type { Context } from './context';
+import { DataType } from './data-type';
+import { LLMModel, LLMModelInputMessage, LLMModelInputs, LLMModelOptions } from './llm-model';
+import { RunOptions, Runnable, RunnableDefinition, RunnableResponseStream } from './runnable';
+import { OrderedRecord } from './utils';
+export declare class LLMDecisionAgent<I extends {
+    [key: string]: any;
+} = {}, O extends {} = {}> extends Runnable<I, O> {
+    definition: LLMDecisionAgentDefinition;
+    model?: LLMModel | undefined;
+    context?: Context | undefined;
+    static create<I extends {} = {}, O extends {} = {}>(options: Parameters<typeof createLLMDecisionAgentDefinition>[0]): LLMDecisionAgent<I, O>;
+    constructor(definition: LLMDecisionAgentDefinition, model?: LLMModel | undefined, context?: Context | undefined);
+    run(input: I, options: RunOptions & {
+        stream: true;
+    }): Promise<RunnableResponseStream<O>>;
+    run(input: I, options?: RunOptions & {
+        stream?: false;
+    }): Promise<O>;
+}
+export interface DecisionAgentCaseParameter<I extends {} = {}, O extends {} = {}, R = Runnable<I, O>> {
+    name?: string;
+    description?: string;
+    runnable: R;
+    input?: {
+        [key: string]: {
+            fromVariable: string;
+            fromVariablePropPath?: string[];
+        } | undefined;
+    };
+}
+export declare function createLLMDecisionAgentDefinition(options: {
+    id?: string;
+    name?: string;
+    inputs?: {
+        name: string;
+        type: DataType['type'];
+        required?: boolean;
+    }[];
+    messages: string;
+    modelOptions?: LLMModelOptions;
+    cases: DecisionAgentCaseParameter[];
+}): LLMDecisionAgentDefinition;
+export interface LLMDecisionAgentDefinition extends RunnableDefinition {
+    type: 'llm_decision_agent';
+    messages?: OrderedRecord<LLMModelInputMessage & {
+        id: string;
+    }>;
+    modelOptions?: LLMModelInputs['modelOptions'];
+    cases?: OrderedRecord<LLMDecisionCase>;
+}
+export interface LLMDecisionCase {
+    id: string;
+    name?: string;
+    description?: string;
+    runnable?: {
+        id?: string;
+    };
+    input?: {
+        [inputId: string]: {
+            from: 'variable';
+            fromVariableId?: string;
+            fromVariablePropPath?: (string | number)[];
+        };
+    };
+}

package/lib/types/llm-model.d.ts

@@ -0,0 +1,79 @@
+import { Runnable } from './runnable';
+export type Role = 'system' | 'user' | 'assistant' | 'tool';
+export interface LLMModelInputs {
+    messages: LLMModelInputMessage[];
+    responseFormat?: {
+        type: 'text';
+    } | {
+        type: 'json_schema';
+        jsonSchema: {
+            name: string;
+            description?: string;
+            schema: object;
+            strict?: boolean;
+        };
+    };
+    tools?: LLMModelInputTool[];
+    toolChoice?: 'auto' | 'none' | 'required' | {
+        type: 'function';
+        function: {
+            name: string;
+            description?: string;
+        };
+    };
+    modelOptions?: LLMModelOptions;
+}
+export interface LLMModelInputMessage {
+    role: Role;
+    content: string | ({
+        type: 'text';
+        text: string;
+    } | {
+        type: 'image_url';
+        imageUrl: {
+            url: string;
+        };
+    })[];
+    toolCalls?: {
+        id: string;
+        type: 'function';
+        function: {
+            name: string;
+            arguments: string;
+        };
+    }[];
+    toolCallId?: string;
+}
+export interface LLMModelInputTool {
+    type: 'function';
+    function: {
+        name: string;
+        description?: string;
+        parameters: object;
+    };
+}
+export interface LLMModelOptions {
+    model?: string;
+    temperature?: number;
+    topP?: number;
+    frequencyPenalty?: number;
+    presencePenalty?: number;
+}
+export interface LLMModelOutputs {
+    $text?: string | null;
+    toolCalls?: {
+        id?: string;
+        type?: 'function';
+        function?: {
+            name?: string;
+            arguments?: string;
+        };
+    }[];
+}
+export declare abstract class LLMModel extends Runnable<LLMModelInputs, LLMModelOutputs> {
+    constructor();
+}
+export interface LLMModelConfiguration {
+    default?: Partial<LLMModelOptions>;
+    override?: Partial<LLMModelOptions>;
+}

package/lib/types/local-function-agent.d.ts

@@ -0,0 +1,38 @@
+import type { Context } from './context';
+import { DataType } from './data-type';
+import { RunOptions, Runnable, RunnableDefinition, RunnableResponse, RunnableResponseStream } from './runnable';
+export declare class LocalFunctionAgent<I extends {} = {}, O extends {} = {}, State = {}> extends Runnable<I, O> {
+    definition: LocalFunctionAgentDefinition<I, O, State>;
+    context?: Context<State> | undefined;
+    static create<I extends {} = {}, O extends {} = {}, State = {}>(options: Parameters<typeof createLocalFunctionAgentDefinition<I, O, State>>[0]): LocalFunctionAgent<I, O, State>;
+    constructor(definition: LocalFunctionAgentDefinition<I, O, State>, context?: Context<State> | undefined);
+    run(input: I, options: RunOptions & {
+        stream: true;
+    }): Promise<RunnableResponseStream<O>>;
+    run(input: I, options?: RunOptions & {
+        stream?: false;
+    }): Promise<O>;
+}
+export declare function createLocalFunctionAgentDefinition<I extends {} = {}, O extends {} = {}, State = {}>(options: {
+    id?: string;
+    name?: string;
+    inputs?: {
+        name: string;
+        type: DataType['type'];
+        required?: boolean;
+    }[];
+    outputs?: {
+        name: string;
+        type: DataType['type'];
+        required?: boolean;
+    }[];
+    function?: (input: I, options: {
+        context: Context<State>;
+    }) => Promise<RunnableResponse<O>>;
+}): LocalFunctionAgentDefinition<I, O, State>;
+export interface LocalFunctionAgentDefinition<I extends {} = {}, O extends {} = {}, State = {}> extends RunnableDefinition {
+    type: 'local_function_agent';
+    function?: (input: I, options: {
+        context: Context<State>;
+    }) => Promise<RunnableResponse<O>>;
+}

package/lib/types/memory.d.ts

@@ -0,0 +1,186 @@
+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: {
+        memoryId: string;
+    };
+    outputs: {
+        result: MemoryItem<T> | null;
+    };
+} | {
+    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']['memoryId']): 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);
+}