@langchain/core/dist/decisions/base.d.cts

Core LangChain.js abstractions and schemas

import { RunnableConfig } from "../runnables/types.cjs";
import { Runnable } from "../runnables/base.cjs";
import "../runnables/config.cjs";
import { ClassifierRequest, ClassifierResponse, Question, State } from "./types.cjs";
/** Fields shared by every decision model. */
export interface BaseDecisionModelFields {
  /** Provider model name used to answer questions. */
  model: string;
}
/**
 * Answer typed questions about text, messages, or structured state.
 *
 * A decision model evaluates shared state against one or more questions and
 * returns typed answers: a probability for a `Noul`, a selected label for a
 * `Choice`, an expected level for a `Score`, and a location for a `Box`.
 * Answers keep their probability distributions and confidence so applications
 * can choose their own thresholds.
 *
 * Subclasses implement `_classify` to call a provider. This class validates
 * questions and handles callbacks, tracing metadata, and token-usage
 * reporting.
 *
 * @example
 * ```ts
 * import {
 *   BaseDecisionModel,
 *   parseClassifierResponse,
 * } from "@langchain/core/decisions";
 *
 * class MyDecisionModel extends BaseDecisionModel {
 *   lc_namespace = ["my_provider", "decisions"];
 *
 *   get _provider() {
 *     return "my_provider";
 *   }
 *
 *   async _classify(
 *     state: State,
 *     questions: Record<string, Question>,
 *     config?: Partial<RunnableConfig>
 *   ) {
 *     const body = await myClient.classify(
 *       { model: this.model, state, questions },
 *       { signal: config?.signal }
 *     );
 *     return parseClassifierResponse(body);
 *   }
 * }
 * ```
 */
export declare abstract class BaseDecisionModel extends Runnable<ClassifierRequest, ClassifierResponse> {
  /** Provider model name used to answer questions. */
  readonly model: string;
  constructor(fields: BaseDecisionModelFields);
  /** Provider name reported to LangSmith as `ls_provider`. */
  abstract get _provider(): string;
  /**
   * Answer one request.
   *
   * @param state State to evaluate.
   * @param questions Validated questions keyed by answer ID.
   * @param config Runnable config, including the abort `signal`.
   * @returns Typed answers keyed by answer ID, with request metadata.
   */
  abstract _classify(state: State, questions: Record<string, Question>, config?: Partial<RunnableConfig>): Promise<ClassifierResponse>;
  /**
   * Classify one request.
   *
   * The run is traced as an LLM run with `ls_provider` and `ls_model_name`
   * metadata, and its output carries `usage_metadata` when the provider reports
   * usage.
   *
   * @param input State and questions to evaluate.
   * @param options Callbacks, tags, metadata, and other runnable config.
   * @returns Answers keyed by answer ID and typed from `questions`, with
   *   request metadata.
   * @throws Error if a question is invalid, `questions` is empty, or the
   *   provider leaves a question unanswered or answers it with the wrong type
   *   or an unknown `Choice` label.
   */
  invoke<const Q extends Record<string, Question>>(input: ClassifierRequest<Q>, options?: Partial<RunnableConfig>): Promise<ClassifierResponse<Q>>;
}
//# sourceMappingURL=base.d.cts.map