@aigne/core 0.4.200 → 0.4.201-0

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

@@ -30,3 +30,10 @@ export interface DataTypeArray extends DataTypeBase {
     defaultValue?: object[];
     items?: OmitPropsFromUnion<DataType, 'id'>;
 }
+type SchemaTypeInner<T extends Record<string, OmitPropsFromUnion<DataType, 'id' | 'name'>>> = {
+    [K in keyof T]: T[K]['type'] extends 'string' ? string : T[K]['type'] extends 'number' ? number : T[K]['type'] extends 'boolean' ? boolean : T[K]['type'] extends 'object' ? object : T[K]['type'] extends 'array' ? object[] : never;
+};
+export type SchemaType<T extends Record<string, OmitPropsFromUnion<DataType, 'id' | 'name'>>> = {
+    [K in keyof T]: T[K]['required'] extends true ? SchemaTypeInner<T>[K] : SchemaTypeInner<T>[K] | undefined;
+};
+export {};

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

@@ -1,10 +1,15 @@
-import { DataType } from './data-type';
+import { DataType, SchemaType } from './data-type';
 import { FunctionRunner } from './function-runner';
 import { RunOptions, Runnable, RunnableDefinition, RunnableResponseStream } from './runnable';
+import { OmitPropsFromUnion } from './utils/omit';
 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]: OmitPropsFromUnion<DataType, 'id' | 'name'>;
+    }, O extends {
+        [name: string]: OmitPropsFromUnion<DataType, 'id' | 'name'>;
+    }>(options: Parameters<typeof createFunctionAgentDefinition<I, O>>[0]): FunctionAgent<SchemaType<I>, SchemaType<O>>;
     constructor(definition: FunctionAgentDefinition, runner?: FunctionRunner | undefined);
     run(input: I, options: RunOptions & {
         stream: true;
@@ -13,19 +18,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]: OmitPropsFromUnion<DataType, 'id' | 'name'>;
+}, O extends {
+    [name: string]: OmitPropsFromUnion<DataType, 'id' | 'name'>;
+}>(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/llm-agent.d.ts

@@ -1,4 +1,4 @@
-import { DataType } from './data-type';
+import { DataType, SchemaType } from './data-type';
 import { LLMModel, LLMModelInputs, Role } from './llm-model';
 import { RunOptions, Runnable, RunnableDefinition, RunnableResponseStream } from './runnable';
 import { OmitPropsFromUnion } from './utils/omit';
@@ -6,7 +6,11 @@ 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]: OmitPropsFromUnion<DataType, 'id' | 'name'>;
+    }, O extends {
+        [name: string]: OmitPropsFromUnion<DataType, 'id' | 'name'>;
+    }>(options: Parameters<typeof createLLMAgentDefinition<I, O>>[0]): LLMAgent<SchemaType<I>, SchemaType<O>>;
     constructor(definition: LLMAgentDefinition, model?: LLMModel | undefined);
     run(input: I, options: RunOptions & {
         stream: true;
@@ -15,16 +19,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]: OmitPropsFromUnion<DataType, 'id' | 'name'>;
+}, O extends {
+    [name: string]: OmitPropsFromUnion<DataType, 'id' | 'name'>;
+}>(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,20 @@
 import type { Context } from './context';
-import { DataType } from './data-type';
+import { DataType, SchemaType } from './data-type';
 import { LLMModel, LLMModelInputMessage, LLMModelInputs, LLMModelOptions } from './llm-model';
 import { RunOptions, Runnable, RunnableDefinition, RunnableResponseStream } from './runnable';
 import { OrderedRecord } from './utils';
+import { OmitPropsFromUnion } from './utils/omit';
 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<I extends {
+        [name: string]: OmitPropsFromUnion<DataType, 'id' | 'name'>;
+    }, O extends {
+        [name: string]: OmitPropsFromUnion<DataType, 'id' | 'name'>;
+    }>(options: Parameters<typeof createLLMDecisionAgentDefinition<I>>[0]): LLMDecisionAgent<SchemaType<I>, SchemaType<O>>;
     constructor(definition: LLMDecisionAgentDefinition, model?: LLMModel | undefined, context?: Context | undefined);
     run(input: I, options: RunOptions & {
         stream: true;
@@ -29,14 +34,12 @@ export interface DecisionAgentCaseParameter<I extends {} = {}, O extends {} = {}
         } | undefined;
     };
 }
-export declare function createLLMDecisionAgentDefinition(options: {
+export declare function createLLMDecisionAgentDefinition<I extends {
+    [name: string]: OmitPropsFromUnion<DataType, 'id' | 'name'>;
+}>(options: {
     id?: string;
     name?: string;
-    inputs?: {
-        name: string;
-        type: DataType['type'];
-        required?: boolean;
-    }[];
+    inputs: I;
     messages: string;
     modelOptions?: LLMModelOptions;
     cases: DecisionAgentCaseParameter[];

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

@@ -1,10 +1,15 @@
 import type { Context } from './context';
-import { DataType } from './data-type';
+import { DataType, SchemaType } from './data-type';
 import { RunOptions, Runnable, RunnableDefinition, RunnableResponse, RunnableResponseStream } from './runnable';
+import { OmitPropsFromUnion } from './utils/omit';
 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]: OmitPropsFromUnion<DataType, 'id' | 'name'>;
+    }, O extends {
+        [name: string]: OmitPropsFromUnion<DataType, 'id' | 'name'>;
+    }, State = {}>(options: Parameters<typeof createLocalFunctionAgentDefinition<I, O, State>>[0]): LocalFunctionAgent<SchemaType<I>, SchemaType<O>, State>;
     constructor(definition: LocalFunctionAgentDefinition<I, O, State>, context?: Context<State> | undefined);
     run(input: I, options: RunOptions & {
         stream: true;
@@ -13,23 +18,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]: OmitPropsFromUnion<DataType, 'id' | 'name'>;
+}, O extends {
+    [name: string]: OmitPropsFromUnion<DataType, 'id' | 'name'>;
+}, 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: SchemaType<I>, options: {
         context: Context<State>;
-    }) => Promise<RunnableResponse<O>>;
-}): LocalFunctionAgentDefinition<I, O, State>;
+    }) => Promise<RunnableResponse<SchemaType<O>>>;
+}): LocalFunctionAgentDefinition<SchemaType<I>, SchemaType<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,13 +1,21 @@
 import type { Context } from './context';
-import { DataType } from './data-type';
+import { DataType, SchemaType } from './data-type';
 import { RunOptions, Runnable, RunnableDefinition, RunnableOutput, RunnableResponseStream } from './runnable';
+import { OmitPropsFromUnion } from './utils/omit';
 import { OrderedRecord } from './utils/ordered-map';
 export declare class PipelineAgent<I extends {
     [key: string]: any;
 } = {}, 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]: OmitPropsFromUnion<DataType, 'id' | 'name'>;
+    }, O extends {
+        [name: string]: OmitPropsFromUnion<DataType, 'id' | 'name'> & {
+            fromVariable: string;
+            fromVariablePropPath?: string[];
+        };
+    }>(options: Parameters<typeof createPipelineAgentDefinition<I, O>>[0]): PipelineAgent<SchemaType<I>, SchemaType<O>>;
     constructor(definition: PipelineAgentDefinition, context?: Context | undefined);
     run(input: I, options: RunOptions & {
         stream: true;
@@ -26,21 +34,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]: OmitPropsFromUnion<DataType, 'id' | 'name'>;
+}, O extends {
+    [name: string]: OmitPropsFromUnion<DataType, 'id' | 'name'> & {
         fromVariable: string;
         fromVariablePropPath?: string[];
-    }[];
+    };
+}>(options: {
+    id?: string;
+    name?: string;
+    inputs: I;
+    outputs: O;
     processes?: PipelineAgentProcessParameter[];
 }): PipelineAgentDefinition;
 export interface PipelineAgentDefinition extends RunnableDefinition {