@aigne/core 0.4.201-2 → 0.4.201-4

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

@@ -0,0 +1,38 @@
+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 {
+    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 ? {
+    [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;
+export type SchemaMapType<T extends Record<string, DataTypeSchema>> = SchemaType<{
+    type: 'object';
+    required: true;
+    properties: T;
+}>;
+export {};

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

@@ -30,10 +30,3 @@ 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,15 +1,14 @@
-import { DataType, SchemaType } from './data-type';
+import { DataTypeSchema, SchemaMapType } from './data-type-schema';
 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 {} = {}, Inputs extends {
-        [name: string]: OmitPropsFromUnion<DataType, 'id' | 'name'>;
-    } = {}, Outputs extends {
-        [name: string]: OmitPropsFromUnion<DataType, 'id' | 'name'>;
-    } = {}>(options: Parameters<typeof createFunctionAgentDefinition<Inputs, Outputs>>[0]): FunctionAgent<SchemaType<Inputs> & I, SchemaType<Outputs> & 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;
@@ -19,9 +18,9 @@ export declare class FunctionAgent<I extends {} = {}, O extends {} = {}> extends
     }): Promise<O>;
 }
 export declare function createFunctionAgentDefinition<I extends {
-    [name: string]: OmitPropsFromUnion<DataType, 'id' | 'name'>;
+    [name: string]: DataTypeSchema;
 }, O extends {
-    [name: string]: OmitPropsFromUnion<DataType, 'id' | 'name'>;
+    [name: string]: DataTypeSchema;
 }>(options: {
     id?: string;
     name?: string;

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,16 +1,15 @@
-import { DataType, SchemaType } 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 {} = {}, Inputs extends {
-        [name: string]: OmitPropsFromUnion<DataType, 'id' | 'name'>;
-    } = {}, Outputs extends {
-        [name: string]: OmitPropsFromUnion<DataType, 'id' | 'name'>;
-    } = {}>(options: Parameters<typeof createLLMAgentDefinition<I, O>>[0]): LLMAgent<SchemaType<Inputs> & I, SchemaType<Outputs> & 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;
@@ -20,9 +19,9 @@ export declare class LLMAgent<I extends {} = {}, O extends {} = {}> extends Runn
     }): Promise<O>;
 }
 export declare function createLLMAgentDefinition<I extends {
-    [name: string]: OmitPropsFromUnion<DataType, 'id' | 'name'>;
+    [name: string]: DataTypeSchema;
 }, O extends {
-    [name: string]: OmitPropsFromUnion<DataType, 'id' | 'name'>;
+    [name: string]: DataTypeSchema;
 }>(options: {
     id?: string;
     name?: string;

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

@@ -1,20 +1,19 @@
 import type { Context } from './context';
-import { DataType, SchemaType } from './data-type';
+import { DataTypeSchema, SchemaMapType } from './data-type-schema';
 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 {} = {}, Inputs extends {
-        [name: string]: OmitPropsFromUnion<DataType, 'id' | 'name'>;
-    } = {}, Outputs extends {
-        [name: string]: OmitPropsFromUnion<DataType, 'id' | 'name'>;
-    } = {}>(options: Parameters<typeof createLLMDecisionAgentDefinition<Inputs>>[0]): LLMDecisionAgent<SchemaType<Inputs> & I, SchemaType<Outputs> & O>;
+    static create<I extends {
+        [name: string]: DataTypeSchema;
+    }, O extends {
+        [name: string]: DataTypeSchema;
+    }>(options: Parameters<typeof createLLMDecisionAgentDefinition<I>>[0]): LLMDecisionAgent<SchemaMapType<I>, SchemaMapType<O>>;
     constructor(definition: LLMDecisionAgentDefinition, model?: LLMModel | undefined, context?: Context | undefined);
     run(input: I, options: RunOptions & {
         stream: true;
@@ -35,7 +34,7 @@ export interface DecisionAgentCaseParameter<I extends {} = {}, O extends {} = {}
     };
 }
 export declare function createLLMDecisionAgentDefinition<I extends {
-    [name: string]: OmitPropsFromUnion<DataType, 'id' | 'name'>;
+    [name: string]: DataTypeSchema;
 }>(options: {
     id?: string;
     name?: string;

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

@@ -1,15 +1,14 @@
 import type { Context } from './context';
-import { DataType, SchemaType } from './data-type';
+import { DataTypeSchema, SchemaMapType } from './data-type-schema';
 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 = {}, Inputs extends {
-        [name: string]: OmitPropsFromUnion<DataType, 'id' | 'name'>;
-    } = {}, Outputs extends {
-        [name: string]: OmitPropsFromUnion<DataType, 'id' | 'name'>;
-    } = {}>(options: Parameters<typeof createLocalFunctionAgentDefinition<Inputs, Outputs, State>>[0]): LocalFunctionAgent<SchemaType<Inputs> & I, SchemaType<Outputs> & 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;
@@ -19,18 +18,18 @@ export declare class LocalFunctionAgent<I extends {} = {}, O extends {} = {}, St
     }): Promise<O>;
 }
 export declare function createLocalFunctionAgentDefinition<I extends {
-    [name: string]: OmitPropsFromUnion<DataType, 'id' | 'name'>;
+    [name: string]: DataTypeSchema;
 }, O extends {
-    [name: string]: OmitPropsFromUnion<DataType, 'id' | 'name'>;
+    [name: string]: DataTypeSchema;
 }, State = {}>(options: {
     id?: string;
     name?: string;
     inputs: I;
     outputs: O;
-    function?: (input: SchemaType<I>, options: {
+    function?: (input: SchemaMapType<I>, options: {
         context: Context<State>;
-    }) => Promise<RunnableResponse<SchemaType<O>>>;
-}): LocalFunctionAgentDefinition<SchemaType<I>, SchemaType<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,21 +1,20 @@
 import type { Context } from './context';
-import { DataType, SchemaType } from './data-type';
+import { DataTypeSchema, SchemaMapType } from './data-type-schema';
 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 {} = {}, Inputs extends {
-        [name: string]: OmitPropsFromUnion<DataType, 'id' | 'name'>;
-    } = {}, Outputs extends {
-        [name: string]: OmitPropsFromUnion<DataType, 'id' | 'name'> & {
+    static create<I extends {
+        [name: string]: DataTypeSchema;
+    }, O extends {
+        [name: string]: DataTypeSchema & {
             fromVariable: string;
             fromVariablePropPath?: string[];
         };
-    } = {}>(options: Parameters<typeof createPipelineAgentDefinition<Inputs, Outputs>>[0]): PipelineAgent<SchemaType<Inputs> & I, SchemaType<Outputs> & O>;
+    }>(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;
@@ -35,9 +34,9 @@ export interface PipelineAgentProcessParameter<I extends {} = {}, O extends {} =
     };
 }
 export declare function createPipelineAgentDefinition<I extends {
-    [name: string]: OmitPropsFromUnion<DataType, 'id' | 'name'>;
+    [name: string]: DataTypeSchema;
 }, O extends {
-    [name: string]: OmitPropsFromUnion<DataType, 'id' | 'name'> & {
+    [name: string]: DataTypeSchema & {
         fromVariable: string;
         fromVariablePropPath?: string[];
     };