@jackhua/mini-langchain/dist/chains/base.d.ts

A lightweight TypeScript implementation of LangChain with cost optimization features

import { ChainValues, BaseCallbackHandler } from '../core/types';
import { BaseMemory } from '../memory/memory';
/**
 * Base class for all chains
 */
export declare abstract class BaseChain {
    protected memory?: BaseMemory;
    protected callbacks: BaseCallbackHandler[];
    protected verbose: boolean;
    constructor(config?: {
        memory?: BaseMemory;
        callbacks?: BaseCallbackHandler[];
        verbose?: boolean;
    });
    /**
     * Run the chain
     */
    abstract call(inputs: ChainValues, callbacks?: BaseCallbackHandler[]): Promise<ChainValues>;
    /**
     * Input keys this chain expects
     */
    abstract get inputKeys(): string[];
    /**
     * Output keys this chain returns
     */
    abstract get outputKeys(): string[];
    /**
     * Invoke the chain with automatic memory handling
     */
    invoke(inputs: ChainValues): Promise<ChainValues>;
    /**
     * Run the chain with a single string input/output
     */
    run(text: string): Promise<string>;
    /**
     * Batch run the chain
     */
    batch(inputs: ChainValues[]): Promise<ChainValues[]>;
    /**
     * Stream the chain output
     */
    stream(inputs: ChainValues): AsyncGenerator<ChainValues>;
    /**
     * Add a callback handler
     */
    addCallback(callback: BaseCallbackHandler): void;
    /**
     * Handle chain start callbacks
     */
    protected handleChainStart(inputs: ChainValues, callbacks: BaseCallbackHandler[]): Promise<void>;
    /**
     * Handle chain end callbacks
     */
    protected handleChainEnd(outputs: ChainValues, callbacks: BaseCallbackHandler[]): Promise<void>;
    /**
     * Handle chain error callbacks
     */
    protected handleChainError(error: Error, callbacks: BaseCallbackHandler[]): Promise<void>;
    /**
     * Serialize the chain
     */
    serialize(): Record<string, any>;
}
/**
 * Simple sequential chain that runs multiple chains in sequence
 */
export declare class SimpleSequentialChain extends BaseChain {
    private chains;
    private inputKey;
    private outputKey;
    constructor(config: {
        chains: BaseChain[];
        inputKey?: string;
        outputKey?: string;
        memory?: BaseMemory;
        callbacks?: BaseCallbackHandler[];
        verbose?: boolean;
    });
    private validateChains;
    get inputKeys(): string[];
    get outputKeys(): string[];
    call(inputs: ChainValues, callbacks?: BaseCallbackHandler[]): Promise<ChainValues>;
}
/**
 * Sequential chain that can handle multiple inputs/outputs
 */
export declare class SequentialChain extends BaseChain {
    private chains;
    private _inputKeys;
    private _outputKeys;
    private returnAll;
    constructor(config: {
        chains: BaseChain[];
        inputVariables: string[];
        outputVariables: string[];
        returnAll?: boolean;
        memory?: BaseMemory;
        callbacks?: BaseCallbackHandler[];
        verbose?: boolean;
    });
    private validateChains;
    get inputKeys(): string[];
    get outputKeys(): string[];
    call(inputs: ChainValues, callbacks?: BaseCallbackHandler[]): Promise<ChainValues>;
}
//# sourceMappingURL=base.d.ts.map