@aigne/core 0.4.201 → 0.4.203

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

@@ -45,6 +45,13 @@ export var OrderedRecord;
         return undefined;
     }
     OrderedRecord.find = find;
+    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])

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

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

package/lib/esm/utils/union.js

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

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

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

@@ -1,10 +1,14 @@
-import { DataType } from './data-type';
+import { DataTypeSchema, SchemaMapType } from './data-type-schema';
 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>;
+    static create<I extends {
+        [name: string]: DataTypeSchema;
+    }, O extends {
+        [name: string]: DataTypeSchema;
+    }>(options: Parameters<typeof createFunctionAgentDefinition<I, O>>[0]): FunctionAgent<SchemaMapType<I>, SchemaMapType<O>>;
     constructor(definition: FunctionAgentDefinition, runner?: FunctionRunner | undefined);
     run(input: I, options: RunOptions & {
         stream: true;
@@ -13,19 +17,15 @@ export declare class FunctionAgent<I extends {} = {}, O extends {} = {}> extends
         stream?: false;
     }): Promise<O>;
 }
-export declare function createFunctionAgentDefinition(options: {
+export declare function createFunctionAgentDefinition<I extends {
+    [name: string]: DataTypeSchema;
+}, O extends {
+    [name: string]: DataTypeSchema;
+}>(options: {
     id?: string;
     name?: string;
-    inputs?: {
-        name: string;
-        type: DataType['type'];
-        required?: boolean;
-    }[];
-    outputs?: {
-        name: string;
-        type: DataType['type'];
-        required?: boolean;
-    }[];
+    inputs: I;
+    outputs: O;
     language: string;
     code: string;
 }): FunctionAgentDefinition;

package/lib/types/index.d.ts

@@ -1,6 +1,7 @@
 export * from './utils';
 export * from './constants';
 export * from './data-type';
+export * from './data-type-schema';
 export * from './context';
 export * from './runnable';
 export * from './pipeline-agent';

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

@@ -1,12 +1,15 @@
-import { DataType } from './data-type';
+import { DataTypeSchema, SchemaMapType } from './data-type-schema';
 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>;
+    static create<I extends {
+        [name: string]: DataTypeSchema;
+    }, O extends {
+        [name: string]: DataTypeSchema;
+    }>(options: Parameters<typeof createLLMAgentDefinition<I, O>>[0]): LLMAgent<SchemaMapType<I>, SchemaMapType<O>>;
     constructor(definition: LLMAgentDefinition, model?: LLMModel | undefined);
     run(input: I, options: RunOptions & {
         stream: true;
@@ -15,16 +18,20 @@ export declare class LLMAgent<I extends {} = {}, O extends {} = {}> extends Runn
         stream?: false;
     }): Promise<O>;
 }
-export declare function createLLMAgentDefinition(options: {
+export declare function createLLMAgentDefinition<I extends {
+    [name: string]: DataTypeSchema;
+}, O extends {
+    [name: string]: DataTypeSchema;
+}>(options: {
     id?: string;
     name?: string;
+    inputs: I;
+    outputs: O;
+    modelOptions?: LLMModelInputs['modelOptions'];
     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';

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

@@ -1,15 +1,16 @@
 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';
+import { ExtractRunnableInputType, ExtractRunnableOutputType } from './utils/runnable-type';
+import { ObjectUnionToIntersection } from './utils/union';
 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>;
+    static create<Case extends DecisionAgentCaseParameter>(options: Parameters<typeof createLLMDecisionAgentDefinition<Case>>[0]): LLMDecisionAgent<ObjectUnionToIntersection<ExtractRunnableInputType<Case['runnable']>>, ExtractRunnableOutputType<Case['runnable']>>;
     constructor(definition: LLMDecisionAgentDefinition, model?: LLMModel | undefined, context?: Context | undefined);
     run(input: I, options: RunOptions & {
         stream: true;
@@ -18,28 +19,17 @@ export declare class LLMDecisionAgent<I extends {
         stream?: false;
     }): Promise<O>;
 }
-export interface DecisionAgentCaseParameter<I extends {} = {}, O extends {} = {}, R = Runnable<I, O>> {
+export interface DecisionAgentCaseParameter<R extends Runnable = Runnable> {
     name?: string;
     description?: string;
     runnable: R;
-    input?: {
-        [key: string]: {
-            fromVariable: string;
-            fromVariablePropPath?: string[];
-        } | undefined;
-    };
 }
-export declare function createLLMDecisionAgentDefinition(options: {
+export declare function createLLMDecisionAgentDefinition<Case extends DecisionAgentCaseParameter>(options: {
     id?: string;
     name?: string;
-    inputs?: {
-        name: string;
-        type: DataType['type'];
-        required?: boolean;
-    }[];
     messages: string;
     modelOptions?: LLMModelOptions;
-    cases: DecisionAgentCaseParameter[];
+    cases: Case[];
 }): LLMDecisionAgentDefinition;
 export interface LLMDecisionAgentDefinition extends RunnableDefinition {
     type: 'llm_decision_agent';

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

@@ -1,10 +1,14 @@
 import type { Context } from './context';
-import { DataType } from './data-type';
+import { DataTypeSchema, SchemaMapType } from './data-type-schema';
 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>;
+    static create<I extends {
+        [name: string]: DataTypeSchema;
+    }, O extends {
+        [name: string]: DataTypeSchema;
+    }, State = {}>(options: Parameters<typeof createLocalFunctionAgentDefinition<I, O, State>>[0]): LocalFunctionAgent<SchemaMapType<I>, SchemaMapType<O>, State>;
     constructor(definition: LocalFunctionAgentDefinition<I, O, State>, context?: Context<State> | undefined);
     run(input: I, options: RunOptions & {
         stream: true;
@@ -13,23 +17,19 @@ export declare class LocalFunctionAgent<I extends {} = {}, O extends {} = {}, St
         stream?: false;
     }): Promise<O>;
 }
-export declare function createLocalFunctionAgentDefinition<I extends {} = {}, O extends {} = {}, State = {}>(options: {
+export declare function createLocalFunctionAgentDefinition<I extends {
+    [name: string]: DataTypeSchema;
+}, O extends {
+    [name: string]: DataTypeSchema;
+}, 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: {
+    inputs: I;
+    outputs: O;
+    function?: (input: SchemaMapType<I>, options: {
         context: Context<State>;
-    }) => Promise<RunnableResponse<O>>;
-}): LocalFunctionAgentDefinition<I, O, State>;
+    }) => Promise<RunnableResponse<SchemaMapType<O>>>;
+}): LocalFunctionAgentDefinition<SchemaMapType<I>, SchemaMapType<O>, State>;
 export interface LocalFunctionAgentDefinition<I extends {} = {}, O extends {} = {}, State = {}> extends RunnableDefinition {
     type: 'local_function_agent';
     function?: (input: I, options: {

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

@@ -1,5 +1,5 @@
 import type { Context } from './context';
-import { DataType } from './data-type';
+import { DataTypeSchema, SchemaMapType } from './data-type-schema';
 import { RunOptions, Runnable, RunnableDefinition, RunnableOutput, RunnableResponseStream } from './runnable';
 import { OrderedRecord } from './utils/ordered-map';
 export declare class PipelineAgent<I extends {
@@ -7,7 +7,14 @@ export declare class PipelineAgent<I extends {
 } = {}, O extends {} = {}> extends Runnable<I, O> {
     definition: PipelineAgentDefinition;
     context?: Context | undefined;
-    static create<I extends {} = {}, O extends {} = {}>(options: Parameters<typeof createPipelineAgentDefinition>[0]): PipelineAgent<I, O>;
+    static create<I extends {
+        [name: string]: DataTypeSchema;
+    }, O extends {
+        [name: string]: DataTypeSchema & {
+            fromVariable: string;
+            fromVariablePropPath?: string[];
+        };
+    }>(options: Parameters<typeof createPipelineAgentDefinition<I, O>>[0]): PipelineAgent<SchemaMapType<I>, SchemaMapType<O>>;
     constructor(definition: PipelineAgentDefinition, context?: Context | undefined);
     run(input: I, options: RunOptions & {
         stream: true;
@@ -26,21 +33,18 @@ export interface PipelineAgentProcessParameter<I extends {} = {}, O extends {} =
         } | undefined;
     };
 }
-export declare function createPipelineAgentDefinition(options: {
-    id?: string;
-    name?: string;
-    inputs?: {
-        name: string;
-        type: DataType['type'];
-        required?: boolean;
-    }[];
-    outputs: {
-        name: string;
-        type: DataType['type'];
-        required?: boolean;
+export declare function createPipelineAgentDefinition<I extends {
+    [name: string]: DataTypeSchema;
+}, O extends {
+    [name: string]: DataTypeSchema & {
         fromVariable: string;
         fromVariablePropPath?: string[];
-    }[];
+    };
+}>(options: {
+    id?: string;
+    name?: string;
+    inputs: I;
+    outputs: O;
     processes?: PipelineAgentProcessParameter[];
 }): PipelineAgentDefinition;
 export interface PipelineAgentDefinition extends RunnableDefinition {