@cognipeer/agent-sdk 0.1.1

package/dist/index.d.ts

@@ -0,0 +1,373 @@
+import { ToolInterface as ToolInterface$1 } from '@langchain/core/tools';
+import { ZodSchema } from 'zod';
+
+interface BaseChatMessagePart {
+    type?: string;
+    text?: string;
+    content?: string;
+    [key: string]: any;
+}
+interface BaseChatMessage {
+    role: 'system' | 'user' | 'assistant' | 'tool' | string;
+    name?: string;
+    content: string | BaseChatMessagePart[];
+    tool_calls?: Array<{
+        id: string;
+        type?: string;
+        function?: {
+            name: string;
+            arguments: string;
+        };
+    }>;
+    tool_call_id?: string;
+    usage?: any;
+    response_metadata?: any;
+    [key: string]: any;
+}
+interface BaseChatModel {
+    invoke(messages: BaseChatMessage[]): Promise<BaseChatMessage>;
+    bindTools?(tools: any[]): BaseChatModel;
+    modelName?: string;
+    [key: string]: any;
+}
+type SmartModel = BaseChatModel;
+declare function isSmartModel(m: any): m is SmartModel;
+declare function withTools(model: SmartModel, tools: any[]): BaseChatModel;
+declare function fromLangchainModel(lcModel: any): BaseChatModel;
+
+type SmartToolFn = (args: any) => Promise<any> | any;
+declare function createSmartTool({ name, description, schema, func, }: {
+    name: string;
+    description?: string;
+    schema: ZodSchema;
+    func: SmartToolFn;
+}): ToolInterface$1;
+declare function createTool({ name, description, schema, func, }: {
+    name: string;
+    description?: string;
+    schema: ZodSchema;
+    func: SmartToolFn;
+}): ToolInterface$1;
+
+declare function buildSystemPrompt(extra?: string, planning?: boolean, name?: string): string;
+
+type ImageURL = {
+    url: string;
+    detail?: 'auto' | 'low' | 'high';
+} | {
+    base64: string;
+    media_type?: string;
+    detail?: 'auto' | 'low' | 'high';
+} | string;
+type ContentPart = {
+    type: 'text';
+    text: string;
+} | {
+    type: 'image_url';
+    image_url: ImageURL;
+} | {
+    type: string;
+    [key: string]: any;
+};
+interface ToolInterface<TInput = any, TOutput = any, TCallOptions = any> {
+    name: string;
+    description?: string;
+    invoke?: (input: TInput, config?: TCallOptions) => Promise<TOutput> | TOutput;
+    call?: (input: TInput, config?: TCallOptions) => Promise<TOutput> | TOutput;
+    schema?: any;
+    [key: string]: any;
+}
+type RunnableConfig = {
+    [key: string]: any;
+};
+type BaseMessage = {
+    role: string;
+    name?: string;
+    content: string | ContentPart[];
+    tool_calls?: any;
+    tool_call_id?: string;
+    [key: string]: any;
+};
+type AIMessage = BaseMessage & {
+    role: 'assistant';
+};
+type Message = BaseMessage;
+type SmartAgentLimits = {
+    maxToolCalls?: number;
+    toolOutputTokenLimit?: number;
+    contextTokenLimit?: number;
+    summaryTokenLimit?: number;
+    summary_token_limit?: number;
+    maxToken?: number;
+    maxParallelTools?: number;
+};
+type SmartAgentOptions = {
+    name?: string;
+    model: any;
+    tools?: Array<ToolInterface<any, any, any>>;
+    handoffs?: HandoffDescriptor<any, any, any>[];
+    limits?: SmartAgentLimits;
+    summarization?: boolean;
+    systemPrompt?: string;
+    useTodoList?: boolean;
+    usageConverter?: (finalMessage: AIMessage, fullState: SmartState, model: any) => any;
+    debug?: {
+        enabled: boolean;
+        path?: string;
+        callback?: (entry: {
+            sessionId: string;
+            stepIndex: number;
+            fileName: string;
+            markdown: string;
+        }) => void;
+    };
+    outputSchema?: ZodSchema<any>;
+};
+type AgentRuntimeConfig = {
+    name?: string;
+    model: any;
+    tools: Array<ToolInterface<any, any, any>>;
+    systemPrompt?: string;
+    limits?: SmartAgentLimits;
+    useTodoList?: boolean;
+    outputSchema?: ZodSchema<any>;
+};
+type HandoffDescriptor<TIn = any, TOut = any, TParsed = any> = {
+    type: "handoff";
+    toolName: string;
+    description: string;
+    schema?: ZodSchema<any>;
+    target: SmartAgentInstance<TParsed> & {
+        __runtime: AgentRuntimeConfig;
+    };
+};
+type SmartState = {
+    messages: Message[];
+    agent?: AgentRuntimeConfig;
+    summaries?: string[];
+    toolHistory?: Array<{
+        executionId: string;
+        toolName: string;
+        args: any;
+        output: any;
+        rawOutput?: any;
+        timestamp?: string;
+        summarized?: boolean;
+        originalTokenCount?: number | null;
+        messageId?: string;
+        tool_call_id?: string;
+        fromCache?: boolean;
+    }>;
+    toolHistoryArchived?: Array<{
+        executionId: string;
+        toolName: string;
+        args: any;
+        output: any;
+        rawOutput?: any;
+        timestamp?: string;
+        summarized?: boolean;
+        originalTokenCount?: number | null;
+        messageId?: string;
+        tool_call_id?: string;
+        fromCache?: boolean;
+    }>;
+    toolCache?: Record<string, any>;
+    toolCallCount?: number;
+    plan?: {
+        version: number;
+        steps: Array<{
+            index: number;
+            title: string;
+            status: string;
+        }>;
+        lastUpdated?: string;
+    } | null;
+    planVersion?: number;
+    metadata?: Record<string, any>;
+    ctx?: Record<string, any>;
+    usage?: {
+        perRequest: Array<{
+            id: string;
+            modelName: string;
+            usage: any;
+            timestamp: string;
+            turn: number;
+            cachedInput?: number;
+        }>;
+        totals: Record<string, {
+            input: number;
+            output: number;
+            total: number;
+            cachedInput: number;
+        }>;
+    };
+};
+type ToolCallEvent = {
+    type: "tool_call";
+    phase: "start" | "success" | "error" | "skipped";
+    name: string;
+    id?: string;
+    args?: any;
+    result?: any;
+    error?: {
+        message: string;
+    } | undefined;
+    durationMs?: number;
+};
+type PlanEvent = {
+    type: "plan";
+    source: "manage_todo_list" | "system";
+    operation?: "write" | "read";
+    todoList?: Array<{
+        id: number;
+        title: string;
+        description: string;
+        status: string;
+        evidence?: string;
+    }>;
+    version?: number;
+};
+type SummarizationEvent = {
+    type: "summarization";
+    summary: string;
+    archivedCount?: number;
+};
+type FinalAnswerEvent = {
+    type: "finalAnswer";
+    content: string;
+};
+type MetadataEvent = {
+    type: "metadata";
+    usage?: any;
+    modelName?: string;
+    limits?: SmartAgentLimits;
+    [key: string]: any;
+};
+type HandoffEvent = {
+    type: "handoff";
+    from?: string;
+    to?: string;
+    toolName: string;
+};
+type SmartAgentEvent = ToolCallEvent | PlanEvent | SummarizationEvent | FinalAnswerEvent | MetadataEvent | HandoffEvent;
+type InvokeConfig = RunnableConfig & {
+    onEvent?: (event: SmartAgentEvent) => void;
+};
+type AgentInvokeResult<TOutput = unknown> = {
+    content: string;
+    output?: TOutput;
+    metadata: {
+        usage?: any;
+    };
+    messages: Message[];
+    state?: SmartState;
+};
+type SmartAgentInstance<TOutput = unknown> = {
+    invoke: (input: SmartState, config?: InvokeConfig) => Promise<AgentInvokeResult<TOutput>>;
+    asTool: (opts: {
+        toolName: string;
+        description?: string;
+        inputDescription?: string;
+    }) => ToolInterface<any, any, any>;
+    asHandoff: (opts: {
+        toolName?: string;
+        description?: string;
+        schema?: ZodSchema<any>;
+    }) => HandoffDescriptor<any, any, TOutput>;
+    __runtime: AgentRuntimeConfig;
+};
+type AgentLimits = SmartAgentLimits;
+type AgentOptions = SmartAgentOptions;
+type AgentState = SmartState;
+type AgentEvent = SmartAgentEvent;
+type AgentResult<T = unknown> = AgentInvokeResult<T>;
+type AgentInstance<T = unknown> = SmartAgentInstance<T>;
+
+declare function createAgent<TOutput = unknown>(opts: AgentOptions & {
+    outputSchema?: ZodSchema<TOutput>;
+}): AgentInstance<TOutput>;
+
+declare function createAgentNode(opts: SmartAgentOptions): (state: SmartState) => Promise<Partial<SmartState>>;
+
+declare function createToolsNode(initialTools: Array<ToolInterface$1<any, any, any>>, opts?: SmartAgentOptions): (state: SmartState) => Promise<any>;
+
+declare function createResolverNode(): (state: SmartState) => Promise<SmartState>;
+
+declare function createToolLimitFinalizeNode(_opts: SmartAgentOptions): (state: SmartState) => Promise<Partial<SmartState>>;
+
+declare function createContextSummarizeNode(opts: SmartAgentOptions): (state: SmartState) => Promise<Partial<SmartState>>;
+
+type TokenLimits = {
+    contextTokenLimit: number;
+    summaryTokenLimit: number;
+};
+declare function applyTokenLimits({ state, model, limits, }: {
+    state: {
+        messages: Message[];
+        summaries?: string[];
+    };
+    model: any;
+    limits: {
+        contextTokenLimit: number;
+        summaryTokenLimit: number;
+    };
+}): Promise<{
+    messages: Message[];
+    summaries?: string[];
+}>;
+
+declare function countApproxTokens(text: string): number;
+
+declare function createContextTools(stateRef: {
+    toolHistory?: any[];
+    toolHistoryArchived?: any[];
+    todoList?: any[];
+}, opts?: {
+    planningEnabled?: boolean;
+    outputSchema?: any;
+}): any[];
+
+type DebugSession = {
+    sessionId: string;
+    baseDir: string;
+    sessionDir: string;
+    stepIndex: number;
+    callback?: (entry: {
+        sessionId: string;
+        stepIndex: number;
+        fileName: string;
+        markdown: string;
+        messages: Message[];
+        usage?: any;
+        modelName?: string;
+        limits?: any;
+        tools?: any[];
+    }) => void;
+};
+declare function resolveLogsBaseDir(customPath?: string): string;
+declare function createDebugSession(opts: SmartAgentOptions): DebugSession | undefined;
+declare function bumpStep(session: DebugSession): number;
+type UsageLike = any;
+declare function getModelName(model: any): string | undefined;
+declare function serializeAgentTools(tools: any[]): any[];
+declare function formatMarkdown(params: {
+    modelName: string | undefined;
+    date: string;
+    limits?: any;
+    usage?: UsageLike;
+    tools?: any[];
+    messages: Message[];
+}): string;
+declare function writeStepMarkdown(session: DebugSession, fileName: string, markdown: string, payload?: {
+    messages: Message[];
+    usage?: any;
+    modelName?: string;
+    limits?: any;
+    tools?: any[];
+}): Promise<void>;
+
+declare function createSmartAgent<TOutput = unknown>(opts: AgentOptions & {
+    outputSchema?: ZodSchema<TOutput>;
+}): AgentInstance<TOutput>;
+
+export { type AgentEvent, type AgentInstance, type AgentInvokeResult, type AgentLimits, type AgentOptions, type AgentResult, type AgentState, type BaseChatMessage, type BaseChatMessagePart, type BaseChatModel, type DebugSession, type InvokeConfig, type SmartAgentInstance, type SmartAgentLimits, type SmartAgentOptions, type SmartModel, type SmartState, type SmartToolFn, type TokenLimits, applyTokenLimits, buildSystemPrompt, bumpStep, countApproxTokens, createAgent, createAgentNode, createContextSummarizeNode, createContextTools, createDebugSession, createResolverNode, createSmartAgent, createSmartTool, createTool, createToolLimitFinalizeNode, createToolsNode, formatMarkdown, fromLangchainModel, getModelName, isSmartModel, resolveLogsBaseDir, serializeAgentTools, withTools, writeStepMarkdown };