tessl/npm-langchain--core

Core LangChain.js abstractions and schemas for building applications with Large Language Models

—

Pending

Quality

Pending

Does it follow best practices?

Impact

Pending

No eval scenarios have been run

Securityby

Pending

The risk profile of this skill

Overview

Eval results

Files

Callback System

Name: tessl/npm-langchain--core
Author: tessl

Event handling and observability framework for monitoring and debugging LangChain operations. Callbacks provide hooks into the execution lifecycle of runnables, models, and tools.

Capabilities

Base Callback Handler

Abstract base class for all callback handlers.

/**
 * Abstract base class for callback handlers
 */
abstract class BaseCallbackHandler {
  /** Handler name for identification */
  name: string;
  /** Whether to ignore LLM events */
  ignoreLLM: boolean;
  /** Whether to ignore chain events */
  ignoreChain: boolean;
  /** Whether to ignore agent events */
  ignoreAgent: boolean;
  /** Whether to ignore retriever events */
  ignoreRetriever: boolean;
  /** Whether to ignore chat model events */
  ignoreChatModel: boolean;
  /** Whether to ignore custom events */
  ignoreCustomEvent: boolean;
  /** Whether handler should raise errors */
  raiseError: boolean;
  
  constructor(input?: BaseCallbackHandlerInput);
  
  /** LLM start event */
  handleLLMStart?(llm: Serialized, prompts: string[], runId: string, parentRunId?: string, extraParams?: Record<string, unknown>, tags?: string[], metadata?: Record<string, unknown>, runName?: string): Promise<void> | void;
  
  /** LLM new token event */
  handleLLMNewToken?(token: string, idx: NewTokenIndices, runId: string, parentRunId?: string, tags?: string[], fields?: Record<string, unknown>): Promise<void> | void;
  
  /** LLM end event */
  handleLLMEnd?(output: LLMResult, runId: string, parentRunId?: string, tags?: string[]): Promise<void> | void;
  
  /** LLM error event */
  handleLLMError?(err: Error, runId: string, parentRunId?: string, tags?: string[]): Promise<void> | void;
  
  /** Chat model start event */
  handleChatModelStart?(llm: Serialized, messages: BaseMessage[][], runId: string, parentRunId?: string, extraParams?: Record<string, unknown>, tags?: string[], metadata?: Record<string, unknown>, runName?: string): Promise<void> | void;
  
  /** Chain start event */
  handleChainStart?(chain: Serialized, inputs: ChainValues, runId: string, parentRunId?: string, tags?: string[], metadata?: Record<string, unknown>, runType?: string, runName?: string): Promise<void> | void;
  
  /** Chain end event */
  handleChainEnd?(outputs: ChainValues, runId: string, parentRunId?: string, tags?: string[], kwargs?: Record<string, unknown>): Promise<void> | void;
  
  /** Chain error event */
  handleChainError?(err: Error, runId: string, parentRunId?: string, tags?: string[], kwargs?: Record<string, unknown>): Promise<void> | void;
  
  /** Tool start event */
  handleToolStart?(tool: Serialized, input: string, runId: string, parentRunId?: string, tags?: string[], metadata?: Record<string, unknown>, runName?: string): Promise<void> | void;
  
  /** Tool end event */
  handleToolEnd?(output: ToolMessage, runId: string, parentRunId?: string, tags?: string[]): Promise<void> | void;
  
  /** Tool error event */
  handleToolError?(err: Error, runId: string, parentRunId?: string, tags?: string[]): Promise<void> | void;
  
  /** Retriever start event */
  handleRetrieverStart?(retriever: Serialized, query: string, runId: string, parentRunId?: string, tags?: string[], metadata?: Record<string, unknown>, runName?: string): Promise<void> | void;
  
  /** Retriever end event */
  handleRetrieverEnd?(documents: Document[], runId: string, parentRunId?: string, tags?: string[]): Promise<void> | void;
  
  /** Retriever error event */
  handleRetrieverError?(err: Error, runId: string, parentRunId?: string, tags?: string[]): Promise<void> | void;
  
  /** Text event (for streaming) */
  handleText?(text: string, runId: string, parentRunId?: string, tags?: string[]): Promise<void> | void;
  
  /** Custom event */
  handleCustomEvent?(eventName: string, data: unknown, runId: string, tags?: string[], metadata?: Record<string, unknown>): Promise<void> | void;
  
  /** Agent action event */
  handleAgentAction?(action: AgentAction, runId: string, parentRunId?: string, tags?: string[]): Promise<void> | void;
  
  /** Agent end event */
  handleAgentEnd?(action: AgentFinish, runId: string, parentRunId?: string, tags?: string[]): Promise<void> | void;
  
  /** Create handler from methods object */
  static fromMethods(methods: CallbackHandlerMethods): BaseCallbackHandler;
}

Usage Examples:

import { BaseCallbackHandler } from "@langchain/core/callbacks";

// Custom callback handler
class MyCallbackHandler extends BaseCallbackHandler {
  name = "my_callback_handler";
  
  async handleLLMStart(llm: Serialized, prompts: string[], runId: string) {
    console.log(`LLM ${llm._type} started with prompts:`, prompts);
  }
  
  async handleLLMEnd(output: LLMResult, runId: string) {
    console.log("LLM finished with output:", output.generations);
  }
  
  async handleChainStart(chain: Serialized, inputs: any, runId: string) {
    console.log(`Chain ${chain._type} started with inputs:`, inputs);
  }
  
  async handleChainEnd(outputs: any, runId: string) {
    console.log("Chain finished with outputs:", outputs);
  }
}

// Use callback
const handler = new MyCallbackHandler();
const result = await model.invoke(
  "What is the capital of France?",
  { callbacks: [handler] }
);

Callback Manager

Manages multiple callback handlers and coordinates event distribution.

/**
 * Manages and coordinates callback handlers
 */
class CallbackManager extends BaseCallbackManager {
  /** Registered handlers */
  handlers: BaseCallbackHandler[];
  /** Inheritable handlers */
  inheritable_handlers: BaseCallbackHandler[];
  /** Parent callback manager */
  parent_run_id?: string;
  /** Run ID for this manager */
  run_id?: string;
  /** Tags for this manager */
  tags: string[];
  /** Metadata for this manager */
  metadata: Record<string, unknown>;
  
  constructor(parentRunId?: string, options?: CallbackManagerOptions);
  
  /** Add a callback handler */
  addHandler(handler: BaseCallbackHandler, inherit?: boolean): void;
  
  /** Remove a callback handler */
  removeHandler(handler: BaseCallbackHandler): void;
  
  /** Add tags */
  addTags(tags: string[], inherit?: boolean): void;
  
  /** Add metadata */
  addMetadata(metadata: Record<string, unknown>, inherit?: boolean): void;
  
  /** Configure callback manager from environment */
  static configure(inheritable_handlers?: Callbacks, local_handlers?: Callbacks, verbose?: boolean, tags?: string[], metadata?: Record<string, unknown>): CallbackManager | undefined;
  
  /** Create child manager for a specific run */
  child(runType?: string, runId?: string, tags?: string[], metadata?: Record<string, unknown>): CallbackManagerForLLMRun | CallbackManagerForChainRun | CallbackManagerForToolRun | CallbackManagerForRetrieverRun;
}

Specialized Run Managers

Run managers for specific operation types.

/**
 * Callback manager for LLM runs
 */
class CallbackManagerForLLMRun extends BaseCallbackManager {
  /** Handle new token */
  async handleLLMNewToken(token: string, idx: NewTokenIndices): Promise<void>;
  
  /** Handle LLM end */
  async handleLLMEnd(output: LLMResult): Promise<void>;
  
  /** Handle LLM error */
  async handleLLMError(err: Error): Promise<void>;
}

/**
 * Callback manager for chain runs
 */
class CallbackManagerForChainRun extends BaseCallbackManager {
  /** Handle chain end */
  async handleChainEnd(output: ChainValues, kwargs?: Record<string, unknown>): Promise<void>;
  
  /** Handle chain error */
  async handleChainError(err: Error, kwargs?: Record<string, unknown>): Promise<void>;
  
  /** Get child manager for nested operations */
  getChild(tag?: string): CallbackManager;
}

/**
 * Callback manager for tool runs
 */
class CallbackManagerForToolRun extends BaseCallbackManager {
  /** Handle tool end */
  async handleToolEnd(output: ToolMessage): Promise<void>;
  
  /** Handle tool error */
  async handleToolError(err: Error): Promise<void>;
}

/**
 * Callback manager for retriever runs
 */
class CallbackManagerForRetrieverRun extends BaseCallbackManager {
  /** Handle retriever end */
  async handleRetrieverEnd(documents: Document[]): Promise<void>;
  
  /** Handle retriever error */
  async handleRetrieverError(err: Error): Promise<void>;
}

Console Callback Handler

Built-in handler for logging to console.

/**
 * Built-in callback handler for console logging
 */
class ConsoleCallbackHandler extends BaseCallbackHandler {
  name = "console_callback_handler";
  
  /** Log all events to console with formatting */
  handleLLMStart?(llm: Serialized, prompts: string[], runId: string): void;
  handleLLMEnd?(output: LLMResult, runId: string): void;
  handleChainStart?(chain: Serialized, inputs: ChainValues, runId: string): void;
  handleChainEnd?(outputs: ChainValues, runId: string): void;
  handleToolStart?(tool: Serialized, input: string, runId: string): void;
  handleToolEnd?(output: ToolMessage, runId: string): void;
}

Usage Examples:

import { ConsoleCallbackHandler } from "@langchain/core/callbacks";

// Use built-in console handler
const consoleHandler = new ConsoleCallbackHandler();

const result = await chain.invoke(
  { question: "What is LangChain?" },
  { callbacks: [consoleHandler] }
);
// Logs all events to console

Callback Configuration

Base Callback Config

interface BaseCallbackConfig {
  /** Callback handlers or manager */
  callbacks?: Callbacks;
  /** Tags for categorizing runs */
  tags?: string[];
  /** Additional metadata */
  metadata?: Record<string, unknown>;
  /** Human-readable name for the run */
  runName?: string;
  /** Unique run identifier */
  runId?: string;
}

Callback Types

type Callbacks = CallbackManager | (BaseCallbackHandler | CallbackHandlerMethods)[];

interface CallbackHandlerMethods {
  handleLLMStart?: (llm: Serialized, prompts: string[], runId: string, parentRunId?: string, extraParams?: Record<string, unknown>, tags?: string[], metadata?: Record<string, unknown>) => Promise<void> | void;
  handleLLMEnd?: (output: LLMResult, runId: string, parentRunId?: string, tags?: string[]) => Promise<void> | void;
  handleLLMError?: (err: Error, runId: string, parentRunId?: string, tags?: string[]) => Promise<void> | void;
  handleChainStart?: (chain: Serialized, inputs: ChainValues, runId: string, parentRunId?: string, tags?: string[], metadata?: Record<string, unknown>) => Promise<void> | void;
  handleChainEnd?: (outputs: ChainValues, runId: string, parentRunId?: string, tags?: string[]) => Promise<void> | void;
  handleChainError?: (err: Error, runId: string, parentRunId?: string, tags?: string[]) => Promise<void> | void;
  // ... other methods
}

interface BaseCallbackHandlerInput {
  ignoreLLM?: boolean;
  ignoreChain?: boolean;
  ignoreAgent?: boolean;
  ignoreRetriever?: boolean;
  ignoreChatModel?: boolean;
  ignoreCustomEvent?: boolean;
  raiseError?: boolean;
}

interface CallbackManagerOptions {
  verbose?: boolean;
  tags?: string[];
  metadata?: Record<string, unknown>;
}

Types

interface NewTokenIndices {
  prompt: number;
  completion: number;
}

type ChainValues = Record<string, unknown>;

interface Serialized {
  _type: string;
  [key: string]: unknown;
}