@aigne/core 1.0.17 → 1.1.0-beta.1

package/lib/esm/memorable.d.ts

@@ -1,198 +0,0 @@
-import { Agent } from "./agent";
-import type { Context } from "./context";
-import type { LLMModelInputMessage } from "./llm-model";
-import { Runnable } from "./runnable";
-export type MemoryMetadata = Record<string, unknown>;
-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;
-    agentId?: string;
-    createdAt: string;
-    updatedAt: string;
-    memory: T;
-    metadata: MemoryMetadata;
-}
-export interface MemoryItemWithScore<T = unknown> extends MemoryItem<T> {
-    score: number;
-}
-export type MemoryMessage = LLMModelInputMessage;
-export type MemoryActions<T> = {
-    action: "add";
-    inputs: {
-        messages: MemoryMessage[];
-        options?: {
-            userId?: string;
-            sessionId?: string;
-            agentId?: string;
-            metadata?: MemoryMetadata;
-        };
-    };
-    outputs: {
-        results: MemoryActionItem<T>[];
-    };
-} | {
-    action: "search";
-    inputs: {
-        query: string;
-        options?: {
-            k?: number;
-            userId?: string;
-            sessionId?: string;
-            agentId?: string;
-            filter?: MemoryMetadata;
-            sort?: MemorySortOptions;
-        };
-    };
-    outputs: {
-        results: MemoryItemWithScore<T>[];
-    };
-} | {
-    action: "filter";
-    inputs: {
-        options?: {
-            k?: number;
-            userId?: string;
-            sessionId?: string;
-            agentId?: 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;
-            agentId?: string;
-            metadata?: MemoryMetadata;
-        };
-    };
-    outputs: {
-        result: MemoryItem<T>;
-    };
-} | {
-    action: "update";
-    inputs: {
-        memoryId: string;
-        memory: T;
-    };
-    outputs: {
-        result: MemoryItem<T> | null;
-    };
-} | {
-    action: "delete";
-    inputs: {
-        filter: string | string[] | Record<string, unknown>;
-    };
-    outputs: {
-        [name: string]: never;
-    };
-} | {
-    action: "reset";
-    inputs: {
-        [name: string]: never;
-    };
-    outputs: {
-        [name: string]: never;
-    };
-};
-export interface SortItem {
-    field: string;
-    direction: "asc" | "desc";
-}
-export type MemorySortOptions = SortItem | SortItem[];
-export declare abstract class Memorable<T, C extends Record<string, any> = Record<string, any>> extends Runnable<MemoryActions<T>, MemoryActions<T>["outputs"]> {
-    constructor(context?: Context);
-    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"]["filter"]): Promise<Extract<MemoryActions<T>, {
-        action: "delete";
-    }>["outputs"]>;
-    abstract reset(): Promise<void>;
-}
-export type MemoryRunnerInput<C extends Record<string, any> = Record<string, any>> = {
-    messages: MemoryMessage[];
-    userId?: string;
-    sessionId?: string;
-    agentId?: string;
-    metadata?: MemoryMetadata;
-    filter?: MemoryMetadata;
-    customData: C;
-};
-export type MemoryRunnerOutput<T> = {
-    actions: MemoryActionItem<T>[];
-};
-export declare abstract class MemoryRunner<T, C extends Record<string, any> = Record<string, any>> extends Agent<MemoryRunnerInput<C>, MemoryRunnerOutput<T>> {
-    constructor(name: string);
-}
-export type MemorableSearchOutput<T extends Memorable<unknown>> = Awaited<ReturnType<T["search"]>>["results"];

package/lib/esm/memorable.js

@@ -1,28 +0,0 @@
-import { camelCase, startCase } from "lodash";
-import { Agent } from "./agent";
-import { Runnable } from "./runnable";
-import { OrderedRecord } from "./utils";
-export class Memorable extends Runnable {
-    constructor(context) {
-        super({
-            id: "memory",
-            type: "memory",
-            name: "Memory",
-            inputs: OrderedRecord.fromArray([]),
-            outputs: OrderedRecord.fromArray([]),
-        }, context);
-    }
-}
-export class MemoryRunner extends Agent {
-    constructor(name) {
-        const id = `${camelCase(name)}_runner`;
-        super({
-            id,
-            type: id,
-            name: `${startCase(name)} Runner`,
-            description: `${startCase(name)} Runner`,
-            inputs: OrderedRecord.fromArray([]),
-            outputs: OrderedRecord.fromArray([]),
-        });
-    }
-}

package/lib/esm/open-api-agent.d.ts

@@ -1,26 +0,0 @@
-import { Agent, type AgentDefinition, type AgentMemories, type AgentPreloads, type AgentProcessInput, type CreateAgentInputSchema, type CreateAgentMemoriesSchema, type CreateAgentMemoriesType, type CreateAgentOptions, type CreateAgentOutputSchema, type CreateAgentPreloadsSchema, type CreateAgentPreloadsType } from "./agent";
-import type { Context, ContextState } from "./context";
-import { type SchemaToType } from "./definitions/data-schema";
-import type { AuthConfig, FetchRequest, HTTPMethod, OpenAPIDataType } from "./definitions/open-api";
-import type { RunnableInput, RunnableOutput } from "./runnable";
-import type { OrderedRecord } from "./utils";
-export declare class OpenAPIAgent<I extends RunnableInput = RunnableInput, O extends RunnableOutput = RunnableOutput, State extends ContextState = ContextState, Preloads extends AgentPreloads = AgentPreloads, Memories extends AgentMemories = AgentMemories> extends Agent<I, O, State, Preloads, Memories> {
-    definition: OpenAPIAgentDefinition;
-    static create: typeof create;
-    constructor(definition: OpenAPIAgentDefinition, context?: Context<State>);
-    process(input: AgentProcessInput<I, Preloads, Memories>): Promise<O>;
-    fetch<T>(request: FetchRequest): Promise<T>;
-}
-export interface OpenAPIAgentDefinition extends AgentDefinition {
-    type: "open_api_agent";
-    inputs: OrderedRecord<OpenAPIDataType>;
-    url: string;
-    method?: HTTPMethod;
-    auth?: AuthConfig;
-}
-declare function create<I extends CreateAgentInputSchema, O extends CreateAgentOutputSchema, State extends ContextState, Preloads extends CreateAgentPreloadsSchema<I>, Memories extends CreateAgentMemoriesSchema<I>>(options: CreateAgentOptions<I, O, State, Preloads, Memories> & {
-    url: string;
-    method?: HTTPMethod;
-    auth?: AuthConfig;
-}): OpenAPIAgent<SchemaToType<I>, SchemaToType<O>, State, CreateAgentPreloadsType<I, Preloads>, CreateAgentMemoriesType<I, Memories>>;
-export {};

package/lib/esm/open-api-agent.js

@@ -1,65 +0,0 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-var __param = (this && this.__param) || function (paramIndex, decorator) {
-    return function (target, key) { decorator(target, key, paramIndex); }
-};
-import { nanoid } from "nanoid";
-import { inject, injectable } from "tsyringe";
-import { Agent, } from "./agent";
-import { TYPES } from "./constants";
-import { schemaToDataType } from "./definitions/data-schema";
-import { toRunnableMemories } from "./definitions/memory";
-import { preloadCreatorsToPreloads } from "./definitions/preload";
-import { fetchOpenApi } from "./utils/fetch-open-api";
-import { formatOpenAPIRequest } from "./utils/open-api-parameter";
-let OpenAPIAgent = class OpenAPIAgent extends Agent {
-    definition;
-    static create = create;
-    constructor(definition, context) {
-        super(definition, context);
-        this.definition = definition;
-    }
-    async process(input) {
-        const { url, method = "get", auth, inputs } = this.definition;
-        if (!url)
-            throw new Error("API url is required");
-        const request = await formatOpenAPIRequest({ url, method, auth }, inputs, input);
-        return this.fetch(request);
-    }
-    async fetch(request) {
-        return fetchOpenApi(request);
-    }
-};
-OpenAPIAgent = __decorate([
-    injectable(),
-    __param(0, inject(TYPES.definition)),
-    __param(1, inject(TYPES.context)),
-    __metadata("design:paramtypes", [Object, Object])
-], OpenAPIAgent);
-export { OpenAPIAgent };
-function create(options) {
-    const agentId = options.name || nanoid();
-    const inputs = schemaToDataType(options.inputs);
-    const outputs = schemaToDataType(options.outputs);
-    const preloads = preloadCreatorsToPreloads(inputs, options.preloads);
-    const memories = toRunnableMemories(agentId, inputs, options.memories || {});
-    return new OpenAPIAgent({
-        id: agentId,
-        name: options.name,
-        type: "open_api_agent",
-        inputs,
-        preloads,
-        memories,
-        outputs,
-        url: options.url,
-        method: options.method,
-        auth: options.auth,
-    }, options.context);
-}

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

@@ -1,56 +0,0 @@
-import { Agent, type AgentDefinition, type AgentMemories, type AgentPreloads, type AgentProcessInput, type AgentProcessOptions, type CreateAgentInputSchema, type CreateAgentMemoriesSchema, type CreateAgentMemoriesType, type CreateAgentOptions, type CreateAgentOutputSchema, type CreateAgentPreloadsSchema, type CreateAgentPreloadsType } from "./agent";
-import type { Context, ContextState } from "./context";
-import { type SchemaToType } from "./definitions/data-schema";
-import { type Runnable, type RunnableInput, type RunnableOutput, type RunnableOutputType, type RunnableResponseDelta } from "./runnable";
-import type { MakeNullablePropertyOptional } from "./utils/nullable";
-import { OrderedRecord } from "./utils/ordered-map";
-import type { ExtractRunnableInputType } from "./utils/runnable-type";
-export declare class PipelineAgent<I extends RunnableInput = RunnableInput, O extends RunnableOutput = RunnableOutput, State extends ContextState = ContextState, Preloads extends AgentPreloads = AgentPreloads, Memories extends AgentMemories = AgentMemories> extends Agent<I, O, State, AgentPreloads, Memories> {
-    definition: PipelineAgentDefinition;
-    static create: typeof create;
-    constructor(definition: PipelineAgentDefinition, context?: Context<State>);
-    process(input: AgentProcessInput<I, Preloads, Memories>, options: AgentProcessOptions<Preloads, Memories>): Promise<import("stream/web").ReadableStream<RunnableResponseDelta<O>>>;
-}
-type VariableWithPropPath = {
-    fromVariable: string;
-    fromVariablePropPath?: (string | number)[];
-};
-export type PipelineAgentProcessParameter<R extends Runnable = Runnable, RI extends RunnableInput = ExtractRunnableInputType<R>> = {
-    runnable: R;
-    input: MakeNullablePropertyOptional<{
-        [key in keyof RI]: VariableWithPropPath;
-    }>;
-};
-declare function create<I extends CreateAgentInputSchema, O extends CreateAgentOutputSchema<{
-    fromVariable: string;
-    fromVariablePropPath?: string[];
-}>, State extends ContextState, Preloads extends CreateAgentPreloadsSchema<I>, Memories extends CreateAgentMemoriesSchema<I>, Processes extends {
-    [name: string]: PipelineAgentProcessParameter;
-}>(options: CreateAgentOptions<I, O, State, Preloads, Memories> & {
-    processes: Processes;
-}): PipelineAgent<SchemaToType<I>, SchemaToType<O>, State, CreateAgentPreloadsType<I, Preloads>, CreateAgentMemoriesType<I, Memories>>;
-export interface PipelineAgentDefinition extends AgentDefinition {
-    type: "pipeline_agent";
-    processes?: OrderedRecord<PipelineAgentProcess>;
-    outputs: OrderedRecord<PipelineAgentOutput>;
-}
-export type PipelineAgentOutput = RunnableOutputType & {
-    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 | symbol)[];
-        };
-    };
-};
-export {};

package/lib/esm/pipeline-agent.js

@@ -1,203 +0,0 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-var __param = (this && this.__param) || function (paramIndex, decorator) {
-    return function (target, key) { decorator(target, key, paramIndex); }
-};
-import { get, isNil } from "lodash";
-import { nanoid } from "nanoid";
-import { inject, injectable } from "tsyringe";
-import { Agent, } from "./agent";
-import { StreamTextOutputName, TYPES } from "./constants";
-import { schemaToDataType } from "./definitions/data-schema";
-import { toRunnableMemories } from "./definitions/memory";
-import { preloadCreatorsToPreloads } from "./definitions/preload";
-import { isRunnableResponseDelta, } from "./runnable";
-import { isNonNullable } from "./utils/is-non-nullable";
-import { logger } from "./utils/logger";
-import { OrderedRecord } from "./utils/ordered-map";
-let PipelineAgent = class PipelineAgent extends Agent {
-    definition;
-    static create = create;
-    constructor(definition, context) {
-        super(definition, context);
-        this.definition = definition;
-    }
-    async process(input, options) {
-        const { definition, context } = this;
-        if (!context)
-            throw new Error("Context is required");
-        const { processes } = definition;
-        if (!processes?.$indexes.length) {
-            throw new Error("No processes defined");
-        }
-        return new ReadableStream({
-            async start(controller) {
-                try {
-                    // NOTE: 将 input 转换为 variables，其中 key 为 inputId，value 为 input 的值
-                    const variables = {
-                        ...options.memories,
-                        ...Object.fromEntries(OrderedRecord.map(definition.inputs, (i) => {
-                            const value = input[i.name || i.id];
-                            if (isNil(value))
-                                return null;
-                            return [i.id, value];
-                        }).filter(isNonNullable)),
-                    };
-                    const outputs = OrderedRecord.toArray(definition.outputs);
-                    const textStreamOutput = outputs.find((i) => i.name === StreamTextOutputName);
-                    let result = {};
-                    for (const process of OrderedRecord.iterator(processes)) {
-                        if (!process.runnable?.id) {
-                            logger.warn("Runnable id is required for process", process);
-                            continue;
-                        }
-                        const runnable = await context.resolve(process.runnable.id);
-                        if (!runnable)
-                            continue;
-                        const inputValues = Object.fromEntries(Object.entries(process.input ?? {})
-                            .map(([inputId, input]) => {
-                            const targetInput = runnable.definition.inputs?.[inputId];
-                            if (!targetInput?.name)
-                                return null;
-                            let value;
-                            if (input.from === "variable") {
-                                const v = variables[input.fromVariableId];
-                                value = input.fromVariablePropPath?.length
-                                    ? get(v, input.fromVariablePropPath)
-                                    : v;
-                            }
-                            else {
-                                throw new Error("Unsupported input source");
-                            }
-                            return [targetInput.name, value];
-                        })
-                            .filter(isNonNullable));
-                        const stream = await runnable.run(inputValues, { stream: true });
-                        const needRespondTextStream = textStreamOutput?.from === "variable" &&
-                            textStreamOutput.fromVariableId === process.id;
-                        // const needRespondJsonStream = outputs.some(
-                        //   (i) => i.name !== StreamTextOutputName && i.from === 'variable' && i.fromVariableId === process.id
-                        // );
-                        const processResult = {};
-                        variables[process.id] = processResult;
-                        for await (const chunk of stream) {
-                            if (isRunnableResponseDelta(chunk)) {
-                                if (chunk.$text) {
-                                    Object.assign(processResult, {
-                                        $text: (processResult.$text || "") + chunk.$text,
-                                    });
-                                    if (needRespondTextStream) {
-                                        controller.enqueue({ $text: chunk.$text });
-                                    }
-                                }
-                                if (chunk.delta) {
-                                    Object.assign(processResult, chunk.delta);
-                                    // TODO: 这里需要考虑上层 agent 直接输出了 {$text: 'xxx'} 没有用 chunk 的方式返回的情况
-                                    // if (needRespondJsonStream) {
-                                    result = Object.fromEntries(OrderedRecord.map(definition.outputs, (output) => {
-                                        if (!output.name)
-                                            return null;
-                                        if (output.name === StreamTextOutputName)
-                                            return null;
-                                        let value;
-                                        if (output.from === "variable") {
-                                            const v = variables[output.fromVariableId];
-                                            value = output.fromVariablePropPath?.length
-                                                ? get(v, output.fromVariablePropPath)
-                                                : v;
-                                        }
-                                        else {
-                                            throw new Error(`Unsupported output source ${output.from}`);
-                                        }
-                                        return [output.name, value];
-                                    }).filter(isNonNullable));
-                                    controller.enqueue({ delta: result });
-                                    // }
-                                }
-                            }
-                        }
-                    }
-                }
-                catch (error) {
-                    controller.error(error);
-                }
-                finally {
-                    controller.close();
-                }
-            },
-        });
-    }
-};
-PipelineAgent = __decorate([
-    injectable(),
-    __param(0, inject(TYPES.definition)),
-    __param(1, inject(TYPES.context)),
-    __metadata("design:paramtypes", [Object, Object])
-], PipelineAgent);
-export { PipelineAgent };
-function create(options) {
-    const agentId = options.name || nanoid();
-    const inputs = schemaToDataType(options.inputs);
-    const preloads = preloadCreatorsToPreloads(inputs, options.preloads);
-    const memories = toRunnableMemories(agentId, inputs, options.memories || {});
-    const processes = OrderedRecord.fromArray([]);
-    for (const [name, p] of Object.entries(options.processes)) {
-        OrderedRecord.push(processes, {
-            id: nanoid(),
-            name: name || p.runnable?.name,
-            runnable: { id: p.runnable.id },
-            input: Object.fromEntries(OrderedRecord.map(p.runnable.definition.inputs, (inputOfProcess) => {
-                const i = p.input[inputOfProcess.name || inputOfProcess.id];
-                if (!i) {
-                    if (inputOfProcess.required) {
-                        throw new Error(`Input ${inputOfProcess.name || inputOfProcess.id} for case ${p.runnable.name || p.runnable.id} is required`);
-                    }
-                    // ignore optional input
-                    return null;
-                }
-                const inputFromPipeline = OrderedRecord.find(inputs, (input) => input.name === i.fromVariable) ||
-                    OrderedRecord.find(processes, (p) => p.name === i.fromVariable);
-                if (!inputFromPipeline)
-                    throw new Error(`Input ${i.fromVariable.toString()} not found`);
-                return [
-                    inputOfProcess.id,
-                    {
-                        from: "variable",
-                        fromVariableId: inputFromPipeline.id,
-                        fromVariablePropPath: i.fromVariablePropPath,
-                    },
-                ];
-            }).filter(isNonNullable)),
-        });
-    }
-    const outputs = OrderedRecord.fromArray(OrderedRecord.map(schemaToDataType(options.outputs), (output) => {
-        const { fromVariable, fromVariablePropPath } = options.outputs[output.name];
-        const from = OrderedRecord.find(inputs, (i) => i.name === fromVariable) ||
-            OrderedRecord.find(processes, (p) => p.name === fromVariable);
-        if (!from)
-            throw new Error(`Output ${output.name} not found in inputs or processes`);
-        return {
-            ...output,
-            from: "variable",
-            fromVariableId: from.id,
-            fromVariablePropPath,
-        };
-    }));
-    return new PipelineAgent({
-        id: agentId,
-        name: options.name,
-        type: "pipeline_agent",
-        inputs,
-        preloads,
-        memories,
-        outputs,
-        processes,
-    }, options.context);
-}

package/lib/esm/runnable.d.ts

@@ -1,76 +0,0 @@
-import type { Context, ContextState } from "./context";
-import type { DataType } from "./definitions/data-type";
-import { OrderedRecord } from "./utils/ordered-map";
-export interface RunOptions {
-    stream?: boolean;
-}
-export type RunnableResponse<T> = T | RunnableResponseStream<T>;
-export type RunnableInput = Record<string, any>;
-export type RunnableOutput = Record<string, any>;
-export declare abstract class Runnable<I extends RunnableInput = RunnableInput, O extends RunnableOutput = RunnableOutput, State extends ContextState = ContextState> {
-    definition: RunnableDefinition;
-    context?: Context<State> | undefined;
-    constructor(definition: RunnableDefinition, context?: Context<State> | undefined);
-    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<RunnableInputType>;
-    outputs: OrderedRecord<RunnableOutputType>;
-}
-export type RunnableInputType = DataType;
-export type RunnableOutputType = DataType;
-export interface RunnableResponseDelta<T> {
-    $text?: string;
-    delta?: Partial<T>;
-}
-export interface RunnableResponseProgress {
-    progress: {
-        taskId: string;
-        time: string;
-        agent: {
-            id: string;
-            name?: string;
-            description?: string;
-        };
-        payload: {
-            type: "start";
-            input: {
-                [key: string]: any;
-            };
-        } | {
-            type: "end";
-            output: {
-                [key: string]: any;
-            };
-        };
-    };
-}
-export interface RunnableResponseError {
-    error: {
-        message: string;
-    };
-}
-export type RunnableResponseChunk<T> = RunnableResponseDelta<T> | RunnableResponseProgress;
-export type RunnableResponseChunkWithError<T> = RunnableResponseChunk<T> | RunnableResponseError;
-export declare function isRunnableResponseDelta<T>(chunk: RunnableResponseChunkWithError<T>): chunk is RunnableResponseDelta<T>;
-export declare function isRunnableResponseProgress<T>(chunk: RunnableResponseChunkWithError<T>): chunk is RunnableResponseProgress;
-export declare function isRunnableResponseError<T>(chunk: RunnableResponseChunkWithError<T>): chunk is RunnableResponseError;
-export type RunnableResponseStream<T> = ReadableStream<RunnableResponseChunk<T>>;