@aigne/core 0.4.194 → 0.4.196

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

@@ -0,0 +1,69 @@
+import type { Context } from './context';
+import { DataType } from './data-type';
+import { RunOptions, Runnable, RunnableDefinition, RunnableOutput, RunnableResponseStream } from './runnable';
+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>;
+    constructor(definition: PipelineAgentDefinition, context?: Context | undefined);
+    run(input: I, options: RunOptions & {
+        stream: true;
+    }): Promise<RunnableResponseStream<O>>;
+    run(input: I, options?: RunOptions & {
+        stream?: false;
+    }): Promise<O>;
+}
+export interface PipelineAgentProcessParameter<I extends {} = {}, O extends {} = {}, R = Runnable<I, O>> {
+    name?: string;
+    runnable: R;
+    input?: {
+        [key: string]: {
+            fromVariable: string;
+            fromVariablePropPath?: string[];
+        } | 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;
+        fromVariable: string;
+        fromVariablePropPath?: string[];
+    }[];
+    processes?: PipelineAgentProcessParameter[];
+}): PipelineAgentDefinition;
+export interface PipelineAgentDefinition extends RunnableDefinition {
+    type: 'pipeline_agent';
+    processes?: OrderedRecord<PipelineAgentProcess>;
+    outputs: OrderedRecord<PipelineAgentOutput>;
+}
+export type PipelineAgentOutput = RunnableOutput & {
+    from: 'variable';
+    fromVariableId?: string;
+    fromVariablePropPath?: (string | number)[];
+};
+export type PipelineAgentProcess = {
+    id: string;
+    name?: string;
+    runnable?: {
+        id?: string;
+    };
+    input?: {
+        [inputId: string]: {
+            from: 'variable';
+            fromVariableId?: string;
+            fromVariablePropPath?: (string | number)[];
+        };
+    };
+};

package/lib/types/runnable.d.ts

@@ -0,0 +1,49 @@
+import { DataType } from './data-type';
+import { OrderedRecord } from './utils/ordered-map';
+export interface RunOptions {
+    stream?: boolean;
+}
+export type RunnableResponse<T> = T | RunnableResponseStream<T>;
+export declare abstract class Runnable<I extends {} = {}, O extends {} = {}> {
+    definition: RunnableDefinition;
+    constructor(definition: RunnableDefinition);
+    get id(): string;
+    get name(): string | undefined;
+    inputs: {
+        [key in keyof I]: DataType;
+    };
+    outputs: {
+        [key in keyof O]: DataType;
+    };
+    abstract run(input: I, options: RunOptions & {
+        stream: true;
+    }): Promise<RunnableResponseStream<O>>;
+    abstract run(input: I, options?: RunOptions & {
+        stream?: false;
+    }): Promise<O>;
+    abstract run(input: I, options?: RunOptions): Promise<RunnableResponse<O>>;
+}
+export interface RunnableDefinition {
+    id: string;
+    type: string;
+    name?: string;
+    description?: string;
+    inputs: OrderedRecord<RunnableInput>;
+    outputs: OrderedRecord<RunnableOutput>;
+}
+export type RunnableInput = DataType;
+export type RunnableOutput = DataType;
+export interface RunnableResponseDelta<T> {
+    $text?: string;
+    delta?: Partial<T>;
+}
+export interface RunnableResponseError {
+    error: {
+        message: string;
+    };
+}
+export type RunnableResponseChunk<T> = RunnableResponseDelta<T>;
+export type RunnableResponseChunkWithError<T> = RunnableResponseChunk<T> | RunnableResponseError;
+export declare function isRunnableResponseDelta<T>(chunk: RunnableResponseChunkWithError<T>): chunk is RunnableResponseDelta<T>;
+export declare function isRunnableResponseError<T>(chunk: RunnableResponseChunkWithError<T>): chunk is RunnableResponseError;
+export type RunnableResponseStream<T> = ReadableStream<RunnableResponseChunk<T>>;