langfn 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,666 @@
+import { z } from 'zod';
+import { Adapter } from '@superfunctions/db';
+import { Route } from '@superfunctions/http';
+
+interface ToolContext {
+    metadata: Record<string, any>;
+}
+interface ToolConfig<T extends z.ZodType> {
+    name: string;
+    description: string;
+    schema: T;
+    execute: (args: z.infer<T>, context: ToolContext) => Promise<any>;
+}
+declare class Tool<T extends z.ZodType, R = any> {
+    readonly name: string;
+    readonly description: string;
+    readonly schema: T;
+    private readonly _execute;
+    constructor(config: ToolConfig<T>);
+    json_schema(): any;
+    run(args: any, context?: ToolContext): Promise<R>;
+}
+
+type Role = "system" | "user" | "assistant" | "tool";
+interface Message {
+    role: Role;
+    content: string;
+    name?: string;
+    tool_call_id?: string;
+}
+interface ToolCall {
+    id: string;
+    name: string;
+    arguments: Record<string, any>;
+}
+interface TokenUsage {
+    prompt_tokens: number;
+    completion_tokens: number;
+    total_tokens?: number;
+}
+interface Cost {
+    prompt: number;
+    completion: number;
+    total: number;
+    currency: string;
+}
+interface ChatRequest {
+    messages: Message[];
+    tools?: any[];
+    tool_choice?: string | object;
+    metadata?: Record<string, any>;
+}
+interface ChatResponse {
+    message: Message;
+    tool_calls?: ToolCall[];
+    usage?: TokenUsage;
+    cost?: Cost;
+    trace_id?: string;
+    raw?: any;
+}
+interface CompletionRequest {
+    prompt: string;
+    metadata?: Record<string, any>;
+}
+interface CompletionResponse {
+    content: string;
+    usage?: TokenUsage;
+    cost?: Cost;
+    trace_id?: string;
+    raw?: any;
+}
+type StreamEvent = ContentEvent | EndEvent | ErrorEvent;
+interface ContentEvent {
+    type: "content";
+    content: string;
+    delta: string;
+    trace_id?: string;
+}
+interface EndEvent {
+    type: "end";
+    finish_reason: string;
+    trace_id?: string;
+}
+interface ErrorEvent {
+    type: "error";
+    error: any;
+    trace_id?: string;
+}
+
+interface ToolAgentResult {
+    messages: Message[];
+    output: string;
+}
+declare class ToolAgent {
+    private options;
+    constructor(options: {
+        lang: LangFn;
+        tools: Tool<any, any>[];
+        max_iterations?: number;
+    });
+    run(prompt: string, options?: {
+        system?: string;
+    }): Promise<ToolAgentResult>;
+}
+
+interface ReActResult {
+    messages: Message[];
+    output: string;
+}
+declare class ReActAgent {
+    private options;
+    constructor(options: {
+        model: LangFn;
+        tools: Tool<any, any>[];
+        max_iterations?: number;
+        system_prompt?: string;
+    });
+    run(prompt: string): Promise<ReActResult>;
+}
+
+declare abstract class ChatModel {
+    abstract provider: string;
+    abstract model: string;
+    abstract complete(request: CompletionRequest): Promise<CompletionResponse>;
+    abstract chat(request: ChatRequest): Promise<ChatResponse>;
+    abstract stream(request: CompletionRequest): AsyncIterable<StreamEvent>;
+}
+
+declare class StructuredOutput<T extends z.ZodType> {
+    private readonly schema;
+    constructor(schema: T);
+    parse(text: string): z.infer<T>;
+    getSchema(): any;
+}
+
+interface LangFnConfig {
+    model: ChatModel;
+    observability?: {
+        enabled?: boolean;
+        watchfn?: any;
+    };
+}
+declare class LangFn {
+    private model;
+    private config;
+    constructor(config: LangFnConfig);
+    complete<T extends z.ZodType>(prompt: string, options?: {
+        metadata?: Record<string, any>;
+        structured?: StructuredOutput<T>;
+    }): Promise<CompletionResponse & {
+        parsed?: z.infer<T>;
+    }>;
+    chat<T extends z.ZodType>(messages: Message[], options?: {
+        tools?: Tool<any, any>[];
+        tool_choice?: string | object;
+        metadata?: Record<string, any>;
+        structured?: StructuredOutput<T>;
+    }): Promise<ChatResponse & {
+        parsed?: z.infer<T>;
+    }>;
+    feedback(traceId: string, options: {
+        rating: number;
+        comment?: string;
+        metadata?: Record<string, any>;
+    }): Promise<void>;
+    stream(prompt: string, options?: {
+        metadata?: Record<string, any>;
+    }): AsyncIterable<StreamEvent>;
+    streamSSE(prompt: string): AsyncIterable<string>;
+    completeBatch(prompts: string[], options?: {
+        concurrency?: number;
+        metadata?: Record<string, any>;
+    }): Promise<CompletionResponse[]>;
+    embed(texts: string | string[]): Promise<number[] | number[][]>;
+    createReactAgent(tools: Tool<any, any>[], options?: {
+        max_iterations?: number;
+        system_prompt?: string;
+    }): Promise<ReActAgent>;
+    createToolAgent(tools: Tool<any, any>[], options?: {
+        max_iterations?: number;
+    }): Promise<ToolAgent>;
+}
+declare function langfn(config: LangFnConfig): LangFn;
+
+type Step<TIn, TOut> = (input: TIn) => Promise<TOut>;
+declare class Chain<TIn, TOut> {
+    private readonly _run;
+    constructor(_run: (input: TIn) => Promise<TOut>);
+    run(input: TIn): Promise<TOut>;
+    static sequential<T = any>(steps: Step<any, any>[]): Chain<any, any>;
+    static parallel<T = any>(steps: Step<T, any>[]): Chain<T, any[]>;
+    static mapReduce<T = any, TMap = any, TReduce = any>(options: {
+        map: (input: T) => Promise<TMap>;
+        reduce: (inputs: TMap[]) => Promise<TReduce>;
+    }): Chain<T[], TReduce>;
+}
+
+type index$c_Chain<TIn, TOut> = Chain<TIn, TOut>;
+declare const index$c_Chain: typeof Chain;
+type index$c_Step<TIn, TOut> = Step<TIn, TOut>;
+declare namespace index$c {
+  export { index$c_Chain as Chain, type index$c_Step as Step };
+}
+
+declare class MockChatModel extends ChatModel {
+    private responses;
+    provider: string;
+    model: string;
+    constructor(responses?: string[]);
+    complete(request: CompletionRequest): Promise<CompletionResponse>;
+    chat(request: ChatRequest): Promise<ChatResponse>;
+    stream(request: CompletionRequest): AsyncIterable<StreamEvent>;
+}
+
+interface OpenAIConfig {
+    apiKey: string;
+    model?: string;
+    baseUrl?: string;
+    organization?: string;
+    project?: string;
+}
+declare class OpenAIChatModel extends ChatModel {
+    provider: string;
+    model: string;
+    private apiKey;
+    private baseUrl;
+    private organization?;
+    private project?;
+    constructor(config: OpenAIConfig);
+    private fetch;
+    complete(request: CompletionRequest): Promise<CompletionResponse>;
+    chat(request: ChatRequest): Promise<ChatResponse>;
+    stream(request: CompletionRequest): AsyncIterable<StreamEvent>;
+}
+
+interface AnthropicConfig {
+    apiKey: string;
+    model?: string;
+    baseUrl?: string;
+    version?: string;
+}
+declare class AnthropicChatModel extends ChatModel {
+    provider: string;
+    model: string;
+    private apiKey;
+    private baseUrl;
+    private version;
+    constructor(config: AnthropicConfig);
+    private fetch;
+    complete(request: CompletionRequest): Promise<CompletionResponse>;
+    chat(request: ChatRequest): Promise<ChatResponse>;
+    stream(request: CompletionRequest): AsyncIterable<StreamEvent>;
+}
+
+interface OllamaConfig {
+    model?: string;
+    baseUrl?: string;
+}
+declare class OllamaChatModel extends ChatModel {
+    provider: string;
+    model: string;
+    private baseUrl;
+    constructor(config?: OllamaConfig);
+    private fetch;
+    complete(request: CompletionRequest): Promise<CompletionResponse>;
+    chat(request: ChatRequest): Promise<ChatResponse>;
+    stream(request: CompletionRequest): AsyncIterable<StreamEvent>;
+}
+
+type index$b_AnthropicChatModel = AnthropicChatModel;
+declare const index$b_AnthropicChatModel: typeof AnthropicChatModel;
+type index$b_AnthropicConfig = AnthropicConfig;
+type index$b_ChatModel = ChatModel;
+declare const index$b_ChatModel: typeof ChatModel;
+type index$b_MockChatModel = MockChatModel;
+declare const index$b_MockChatModel: typeof MockChatModel;
+type index$b_OllamaChatModel = OllamaChatModel;
+declare const index$b_OllamaChatModel: typeof OllamaChatModel;
+type index$b_OllamaConfig = OllamaConfig;
+type index$b_OpenAIChatModel = OpenAIChatModel;
+declare const index$b_OpenAIChatModel: typeof OpenAIChatModel;
+type index$b_OpenAIConfig = OpenAIConfig;
+declare namespace index$b {
+  export { index$b_AnthropicChatModel as AnthropicChatModel, type index$b_AnthropicConfig as AnthropicConfig, index$b_ChatModel as ChatModel, index$b_MockChatModel as MockChatModel, index$b_OllamaChatModel as OllamaChatModel, type index$b_OllamaConfig as OllamaConfig, index$b_OpenAIChatModel as OpenAIChatModel, type index$b_OpenAIConfig as OpenAIConfig };
+}
+
+declare const CalculatorTool: Tool<z.ZodObject<{
+    expression: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    expression: string;
+}, {
+    expression: string;
+}>, any>;
+
+declare const ApiCallTool: Tool<z.ZodObject<{
+    url: z.ZodString;
+    method: z.ZodDefault<z.ZodString>;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    body: z.ZodOptional<z.ZodAny>;
+}, "strip", z.ZodTypeAny, {
+    method: string;
+    url: string;
+    headers?: Record<string, string> | undefined;
+    body?: any;
+}, {
+    url: string;
+    method?: string | undefined;
+    headers?: Record<string, string> | undefined;
+    body?: any;
+}>, any>;
+
+declare const index$a_ApiCallTool: typeof ApiCallTool;
+declare const index$a_CalculatorTool: typeof CalculatorTool;
+type index$a_Tool<T extends z.ZodType, R = any> = Tool<T, R>;
+declare const index$a_Tool: typeof Tool;
+type index$a_ToolConfig<T extends z.ZodType> = ToolConfig<T>;
+type index$a_ToolContext = ToolContext;
+declare namespace index$a {
+  export { index$a_ApiCallTool as ApiCallTool, index$a_CalculatorTool as CalculatorTool, index$a_Tool as Tool, type index$a_ToolConfig as ToolConfig, type index$a_ToolContext as ToolContext };
+}
+
+type index$9_ReActAgent = ReActAgent;
+declare const index$9_ReActAgent: typeof ReActAgent;
+type index$9_ReActResult = ReActResult;
+type index$9_ToolAgent = ToolAgent;
+declare const index$9_ToolAgent: typeof ToolAgent;
+type index$9_ToolAgentResult = ToolAgentResult;
+declare namespace index$9 {
+  export { index$9_ReActAgent as ReActAgent, type index$9_ReActResult as ReActResult, index$9_ToolAgent as ToolAgent, type index$9_ToolAgentResult as ToolAgentResult };
+}
+
+declare const END = "__end__";
+type NodeFn<TState> = (state: TState) => Promise<TState>;
+type RouteFn<TState> = (state: TState) => string;
+declare class CompiledGraph<TState> {
+    private readonly config;
+    constructor(config: {
+        initialState: TState;
+        nodes: Map<string, NodeFn<TState>>;
+        edges: Map<string, string>;
+        conditionalEdges: Map<string, RouteFn<TState>>;
+        entrypoint: string;
+    });
+    invoke(state?: Partial<TState>, options?: {
+        maxSteps?: number;
+    }): Promise<TState>;
+}
+declare class StateGraph<TState> {
+    private readonly initialState;
+    private nodes;
+    private edges;
+    private conditionalEdges;
+    private entrypoint?;
+    constructor(initialState: TState);
+    addNode(name: string, fn: NodeFn<TState>): this;
+    addEdge(from: string, to: string): this;
+    addConditionalEdge(from: string, router: RouteFn<TState>): this;
+    setEntryPoint(name: string): this;
+    compile(): CompiledGraph<TState>;
+}
+
+type index$8_CompiledGraph<TState> = CompiledGraph<TState>;
+declare const index$8_CompiledGraph: typeof CompiledGraph;
+declare const index$8_END: typeof END;
+type index$8_NodeFn<TState> = NodeFn<TState>;
+type index$8_RouteFn<TState> = RouteFn<TState>;
+type index$8_StateGraph<TState> = StateGraph<TState>;
+declare const index$8_StateGraph: typeof StateGraph;
+declare namespace index$8 {
+  export { index$8_CompiledGraph as CompiledGraph, index$8_END as END, type index$8_NodeFn as NodeFn, type index$8_RouteFn as RouteFn, index$8_StateGraph as StateGraph };
+}
+
+interface PromptVariables {
+    [key: string]: string | number | boolean;
+}
+declare class PromptTemplate {
+    private readonly config;
+    constructor(config: {
+        template: string;
+        variables?: string[];
+    });
+    format(variables: PromptVariables): string;
+}
+interface ChatMessageTemplate {
+    role: "system" | "user" | "assistant";
+    content: string;
+}
+declare class ChatPromptTemplate {
+    private readonly config;
+    constructor(config: {
+        messages: ChatMessageTemplate[];
+    });
+    format(variables: PromptVariables): any[];
+}
+
+interface PromptRecord {
+    id: string;
+    name: string;
+    version: string;
+    template: string;
+    variables: string[];
+    description?: string;
+    tags: string[];
+    createdAt: number;
+    updatedAt: number;
+}
+declare class PromptRegistry {
+    private readonly db;
+    private tableName;
+    constructor(db: Adapter);
+    save(name: string, prompt: PromptTemplate, options: {
+        version: string;
+        description?: string;
+        tags?: string[];
+    }): Promise<void>;
+    load(name: string, options?: {
+        version?: string;
+    }): Promise<PromptTemplate | null>;
+    list(tags?: string[]): Promise<PromptRecord[]>;
+}
+
+interface FewShotExample {
+    input: string;
+    output: string;
+}
+declare class FewShotPrompt {
+    private readonly config;
+    constructor(config: {
+        prefix: string;
+        examples: FewShotExample[];
+        suffix: string;
+        inputVariables: string[];
+        exampleSeparator?: string;
+    });
+    format(variables: Record<string, any>): string;
+}
+
+type index$7_ChatMessageTemplate = ChatMessageTemplate;
+type index$7_ChatPromptTemplate = ChatPromptTemplate;
+declare const index$7_ChatPromptTemplate: typeof ChatPromptTemplate;
+type index$7_FewShotExample = FewShotExample;
+type index$7_FewShotPrompt = FewShotPrompt;
+declare const index$7_FewShotPrompt: typeof FewShotPrompt;
+type index$7_PromptRecord = PromptRecord;
+type index$7_PromptRegistry = PromptRegistry;
+declare const index$7_PromptRegistry: typeof PromptRegistry;
+type index$7_PromptTemplate = PromptTemplate;
+declare const index$7_PromptTemplate: typeof PromptTemplate;
+type index$7_PromptVariables = PromptVariables;
+declare namespace index$7 {
+  export { type index$7_ChatMessageTemplate as ChatMessageTemplate, index$7_ChatPromptTemplate as ChatPromptTemplate, type index$7_FewShotExample as FewShotExample, index$7_FewShotPrompt as FewShotPrompt, type index$7_PromptRecord as PromptRecord, index$7_PromptRegistry as PromptRegistry, index$7_PromptTemplate as PromptTemplate, type index$7_PromptVariables as PromptVariables };
+}
+
+declare class BufferMemory {
+    private messages;
+    private maxMessages;
+    constructor(options?: {
+        maxMessages?: number;
+    });
+    add(message: Message): Promise<void>;
+    extend(messages: Message[]): Promise<void>;
+    get(): Promise<Message[]>;
+    clear(): Promise<void>;
+}
+
+declare class SummaryMemory {
+    private readonly lang;
+    private messages;
+    private summary?;
+    private maxTokens;
+    private summaryPrompt;
+    constructor(lang: LangFn, options?: {
+        maxTokens?: number;
+        summaryPrompt?: string;
+    });
+    add(message: Message): Promise<void>;
+    private summarize;
+    get(): Promise<Message[]>;
+    clear(): Promise<void>;
+}
+
+type index$6_BufferMemory = BufferMemory;
+declare const index$6_BufferMemory: typeof BufferMemory;
+type index$6_SummaryMemory = SummaryMemory;
+declare const index$6_SummaryMemory: typeof SummaryMemory;
+declare namespace index$6 {
+  export { index$6_BufferMemory as BufferMemory, index$6_SummaryMemory as SummaryMemory };
+}
+
+interface Document {
+    content: string;
+    metadata: Record<string, any>;
+    score?: number;
+}
+declare abstract class Embeddings {
+    abstract embedQuery(text: string): Promise<number[]>;
+    abstract embedDocuments(texts: string[]): Promise<number[][]>;
+}
+declare abstract class VectorStore {
+    abstract addDocuments(documents: Document[]): Promise<void>;
+    abstract search(query: string, options?: {
+        k?: number;
+        filter?: Record<string, any>;
+    }): Promise<Document[]>;
+}
+declare abstract class Retriever {
+    abstract getRelevantDocuments(query: string): Promise<Document[]>;
+}
+
+interface OpenAIEmbeddingsConfig {
+    apiKey: string;
+    model?: string;
+    baseUrl?: string;
+}
+declare class OpenAIEmbeddings extends Embeddings {
+    private apiKey;
+    private model;
+    private baseUrl;
+    constructor(config: OpenAIEmbeddingsConfig);
+    embedQuery(text: string): Promise<number[]>;
+    embedDocuments(texts: string[]): Promise<number[][]>;
+}
+
+declare class InMemoryVectorStore extends VectorStore {
+    private readonly embeddings;
+    private documents;
+    private vectors;
+    constructor(embeddings: Embeddings);
+    addDocuments(documents: Document[]): Promise<void>;
+    search(query: string, options?: {
+        k?: number;
+        filter?: Record<string, any>;
+    }): Promise<Document[]>;
+    private cosineSimilarity;
+}
+
+interface DocumentRecord {
+    id: string;
+    content: string;
+    embedding: number[];
+    metadata: Record<string, any>;
+    namespace: string;
+    createdAt: number;
+}
+declare class DbVectorStore extends VectorStore {
+    private readonly db;
+    private readonly embeddings;
+    private readonly namespace;
+    private tableName;
+    constructor(db: Adapter, embeddings: Embeddings, namespace?: string);
+    addDocuments(documents: Document[]): Promise<void>;
+    search(query: string, options?: {
+        k?: number;
+        filter?: Record<string, any>;
+    }): Promise<Document[]>;
+    private cosineSimilarity;
+}
+
+type index$5_DbVectorStore = DbVectorStore;
+declare const index$5_DbVectorStore: typeof DbVectorStore;
+type index$5_Document = Document;
+type index$5_DocumentRecord = DocumentRecord;
+type index$5_Embeddings = Embeddings;
+declare const index$5_Embeddings: typeof Embeddings;
+type index$5_InMemoryVectorStore = InMemoryVectorStore;
+declare const index$5_InMemoryVectorStore: typeof InMemoryVectorStore;
+type index$5_OpenAIEmbeddings = OpenAIEmbeddings;
+declare const index$5_OpenAIEmbeddings: typeof OpenAIEmbeddings;
+type index$5_OpenAIEmbeddingsConfig = OpenAIEmbeddingsConfig;
+type index$5_Retriever = Retriever;
+declare const index$5_Retriever: typeof Retriever;
+type index$5_VectorStore = VectorStore;
+declare const index$5_VectorStore: typeof VectorStore;
+declare namespace index$5 {
+  export { index$5_DbVectorStore as DbVectorStore, type index$5_Document as Document, type index$5_DocumentRecord as DocumentRecord, index$5_Embeddings as Embeddings, index$5_InMemoryVectorStore as InMemoryVectorStore, index$5_OpenAIEmbeddings as OpenAIEmbeddings, type index$5_OpenAIEmbeddingsConfig as OpenAIEmbeddingsConfig, index$5_Retriever as Retriever, index$5_VectorStore as VectorStore };
+}
+
+declare class ResponseCache {
+    private readonly db;
+    private readonly ttl;
+    private tableName;
+    constructor(db: Adapter, ttl?: number);
+    private generateKey;
+    get(prompt: string, model: string, provider: string, metadata?: Record<string, any>): Promise<any | null>;
+    set(prompt: string, model: string, provider: string, value: any, metadata?: Record<string, any>): Promise<void>;
+}
+
+type index$4_ResponseCache = ResponseCache;
+declare const index$4_ResponseCache: typeof ResponseCache;
+declare namespace index$4 {
+  export { index$4_ResponseCache as ResponseCache };
+}
+
+declare function countTokens(text: string, model?: string): number;
+declare function countMessagesTokens(messages: any[], model?: string): number;
+
+declare const index$3_countMessagesTokens: typeof countMessagesTokens;
+declare const index$3_countTokens: typeof countTokens;
+declare namespace index$3 {
+  export { index$3_countMessagesTokens as countMessagesTokens, index$3_countTokens as countTokens };
+}
+
+interface TraceSpanOptions {
+    name: string;
+    metadata?: Record<string, any>;
+}
+declare class Tracer {
+    private watch;
+    constructor(options?: {
+        watch?: any;
+    });
+    trace<T>(name: string, metadata: Record<string, any>, fn: () => Promise<T>): Promise<T>;
+}
+
+interface TraceRecord {
+    id: string;
+    startTime: number;
+    endTime: number;
+    model: string;
+    provider: string;
+    input: string;
+    output: string;
+    tokens: TokenUsage;
+    latency: number;
+    cost?: Cost;
+    metadata: Record<string, any>;
+    userId?: string;
+}
+declare class TraceStorage {
+    private readonly db;
+    private tableName;
+    constructor(db: Adapter);
+    save(trace: TraceRecord): Promise<void>;
+    findMany(options?: {
+        limit?: number;
+        offset?: number;
+        model?: string;
+        provider?: string;
+    }): Promise<TraceRecord[]>;
+    findOne(id: string): Promise<TraceRecord | null>;
+}
+
+type index$2_TraceRecord = TraceRecord;
+type index$2_TraceSpanOptions = TraceSpanOptions;
+type index$2_TraceStorage = TraceStorage;
+declare const index$2_TraceStorage: typeof TraceStorage;
+type index$2_Tracer = Tracer;
+declare const index$2_Tracer: typeof Tracer;
+declare namespace index$2 {
+  export { type index$2_TraceRecord as TraceRecord, type index$2_TraceSpanOptions as TraceSpanOptions, index$2_TraceStorage as TraceStorage, index$2_Tracer as Tracer };
+}
+
+declare function createLangFnRouter(lang: LangFn): Route[];
+
+declare const index$1_createLangFnRouter: typeof createLangFnRouter;
+declare namespace index$1 {
+  export { index$1_createLangFnRouter as createLangFnRouter };
+}
+
+type index_StructuredOutput<T extends z.ZodType> = StructuredOutput<T>;
+declare const index_StructuredOutput: typeof StructuredOutput;
+declare namespace index {
+  export { index_StructuredOutput as StructuredOutput };
+}
+
+export { Chain, ChatModel, type ChatRequest, type ChatResponse, type CompletionRequest, type CompletionResponse, type ContentEvent, type Cost, type EndEvent, type ErrorEvent, LangFn, type LangFnConfig, type Message, type Role, type Step, type StreamEvent, type TokenUsage, Tool, type ToolCall, type ToolConfig, type ToolContext, index$9 as agents, index$8 as graph, index$1 as http, langfn, index$6 as memory, index$b as models, index$2 as observability, index$c as orchestration, index$7 as prompts, index$5 as rag, index$4 as storage, index as structured, index$a as tools, index$3 as utils };