@langchain/core 1.3.7 → 1.4.0

package/dist/decisions/types.d.ts

@@ -0,0 +1,368 @@
+import { BaseMessage } from "../messages/base.js";
+import { UsageMetadata } from "../messages/metadata.js";
+import * as z$1 from "zod/v4";
+declare const jsonValueSchema: z$1.ZodJSONSchema;
+/** Any value expressible in JSON. */
+export type JsonValue = z$1.infer<typeof jsonValueSchema>;
+declare const contentSchema: z$1.ZodUnion<readonly [z$1.ZodString, z$1.ZodRecord<z$1.ZodString, z$1.ZodJSONSchema>, z$1.ZodArray<z$1.ZodJSONSchema>]>;
+/**
+ * Text, a JSON object, or a JSON array used in question instructions.
+ *
+ * As in `State`, LangChain standard media blocks may appear anywhere in
+ * instructions and criteria. Providers send them as media, or throw an error
+ * if their API does not accept that media in questions.
+ */
+export type Content = z$1.infer<typeof contentSchema>;
+/** A value allowed below the root of `State`. */
+export type StateValue = string | number | boolean | null | BaseMessage | StateValue[] | {
+  [key: string]: StateValue;
+};
+/**
+ * Root state accepted by decision models.
+ *
+ * State is a string, JSON object, or JSON array. LangChain `BaseMessage` objects
+ * and message arrays can appear at the root or at any depth inside objects and
+ * arrays.
+ *
+ * LangChain standard media blocks (for example `{ type: "image", data: ...,
+ * mimeType: ... }`) may appear anywhere in the state. Each provider documents
+ * which media it supports and how it sends state its API cannot accept natively.
+ */
+export type State = string | BaseMessage | StateValue[] | {
+  [key: string]: StateValue;
+};
+declare const noulCriteriaSchema: z$1.ZodObject<{
+  true: z$1.ZodOptional<z$1.ZodJSONSchema>;
+  false: z$1.ZodOptional<z$1.ZodJSONSchema>;
+}, z$1.core.$strict>;
+declare const noulSchema: z$1.ZodObject<{
+  type: z$1.ZodLiteral<"noul">;
+  instructions: z$1.ZodUnion<readonly [z$1.ZodString, z$1.ZodRecord<z$1.ZodString, z$1.ZodJSONSchema>, z$1.ZodArray<z$1.ZodJSONSchema>]>;
+  criteria: z$1.ZodOptional<z$1.ZodNullable<z$1.ZodObject<{
+    true: z$1.ZodOptional<z$1.ZodJSONSchema>;
+    false: z$1.ZodOptional<z$1.ZodJSONSchema>;
+  }, z$1.core.$strict>>>;
+}, z$1.core.$strict>;
+declare const choiceSchema: z$1.ZodObject<{
+  type: z$1.ZodLiteral<"choice">;
+  criteria: z$1.ZodPipe<z$1.ZodCustom<Record<string, unknown>, Record<string, unknown>>, z$1.ZodTransform<Record<string, z$1.JSONType>, Record<string, unknown>>>;
+  instructions: z$1.ZodUnion<readonly [z$1.ZodString, z$1.ZodRecord<z$1.ZodString, z$1.ZodJSONSchema>, z$1.ZodArray<z$1.ZodJSONSchema>]>;
+}, z$1.core.$strict>;
+declare const scoreSchema: z$1.ZodObject<{
+  type: z$1.ZodLiteral<"score">;
+  criteria: z$1.ZodArray<z$1.ZodJSONSchema>;
+  instructions: z$1.ZodUnion<readonly [z$1.ZodString, z$1.ZodRecord<z$1.ZodString, z$1.ZodJSONSchema>, z$1.ZodArray<z$1.ZodJSONSchema>]>;
+}, z$1.core.$strict>;
+declare const boxSchema: z$1.ZodObject<{
+  type: z$1.ZodLiteral<"box">;
+  instructions: z$1.ZodUnion<readonly [z$1.ZodString, z$1.ZodRecord<z$1.ZodString, z$1.ZodJSONSchema>, z$1.ZodArray<z$1.ZodJSONSchema>]>;
+}, z$1.core.$strict>;
+declare const questionSchema: z$1.ZodDiscriminatedUnion<[z$1.ZodObject<{
+  type: z$1.ZodLiteral<"noul">;
+  instructions: z$1.ZodUnion<readonly [z$1.ZodString, z$1.ZodRecord<z$1.ZodString, z$1.ZodJSONSchema>, z$1.ZodArray<z$1.ZodJSONSchema>]>;
+  criteria: z$1.ZodOptional<z$1.ZodNullable<z$1.ZodObject<{
+    true: z$1.ZodOptional<z$1.ZodJSONSchema>;
+    false: z$1.ZodOptional<z$1.ZodJSONSchema>;
+  }, z$1.core.$strict>>>;
+}, z$1.core.$strict>, z$1.ZodObject<{
+  type: z$1.ZodLiteral<"choice">;
+  criteria: z$1.ZodPipe<z$1.ZodCustom<Record<string, unknown>, Record<string, unknown>>, z$1.ZodTransform<Record<string, z$1.JSONType>, Record<string, unknown>>>;
+  instructions: z$1.ZodUnion<readonly [z$1.ZodString, z$1.ZodRecord<z$1.ZodString, z$1.ZodJSONSchema>, z$1.ZodArray<z$1.ZodJSONSchema>]>;
+}, z$1.core.$strict>, z$1.ZodObject<{
+  type: z$1.ZodLiteral<"score">;
+  criteria: z$1.ZodArray<z$1.ZodJSONSchema>;
+  instructions: z$1.ZodUnion<readonly [z$1.ZodString, z$1.ZodRecord<z$1.ZodString, z$1.ZodJSONSchema>, z$1.ZodArray<z$1.ZodJSONSchema>]>;
+}, z$1.core.$strict>, z$1.ZodObject<{
+  type: z$1.ZodLiteral<"box">;
+  instructions: z$1.ZodUnion<readonly [z$1.ZodString, z$1.ZodRecord<z$1.ZodString, z$1.ZodJSONSchema>, z$1.ZodArray<z$1.ZodJSONSchema>]>;
+}, z$1.core.$strict>], "type">;
+/**
+ * Optional descriptions for the two outcomes of a `Noul` question.
+ *
+ * Criteria clarify what should count as yes and no when the instructions alone
+ * leave room for interpretation. Both values accept any JSON value, so callers
+ * can provide a short description or structured examples. The keys are
+ * literally `true` and `false`.
+ */
+export type NoulCriteria = z$1.infer<typeof noulCriteriaSchema>;
+/**
+ * Ask a binary question and receive the probability that its answer is yes.
+ *
+ * Use `Noul` when the probability itself is useful to application code, such as
+ * deciding whether a message reports a bug or requests a refund. A value near
+ * `1` indicates strong support for yes, near `0` strong support for no, and
+ * near `0.5` uncertainty. Noul answers have no separate confidence.
+ *
+ * Write the complete judgment in `instructions`, even when the question ID
+ * seems self-explanatory. Optional `criteria` define the yes and no outcomes.
+ *
+ * @example
+ * ```ts
+ * const response = await model.invoke({
+ *   state: "Production is down. Please help immediately.",
+ *   questions: {
+ *     urgent: {
+ *       type: "noul",
+ *       instructions: "Does this message require an urgent response?",
+ *     },
+ *   },
+ * });
+ * if (response.nouls.urgent.noul >= 0.8) pageOnCallEngineer();
+ * ```
+ */
+export type Noul = z$1.infer<typeof noulSchema>;
+/**
+ * Select one label from a fixed set of alternatives.
+ *
+ * Use `Choice` for categorical decisions with no inherent ordering, such as
+ * routing a support request, detecting a document type, or selecting an
+ * intent. The answer includes the selected label, a probability for every
+ * supplied label, and a confidence value.
+ *
+ * `criteria` maps each label to its description, which may be text, JSON, or
+ * `null`. Include an `other` or `none_of_the_above` label when the alternatives
+ * may not cover every input.
+ *
+ * @example
+ * ```ts
+ * const response = await model.invoke({
+ *   state: "Stripe fails whenever I connect my account.",
+ *   questions: {
+ *     department: {
+ *       type: "choice",
+ *       instructions: "Which team should handle this request?",
+ *       criteria: {
+ *         billing: "Payment, invoice, or subscription issues.",
+ *         technical: "Product bugs or integration failures.",
+ *         sales: "Pricing or purchasing questions.",
+ *       },
+ *     },
+ *   },
+ * });
+ * const department = response.choices.department;
+ *
+ * if (department.confidence >= 0.7) {
+ *   routeTo(department.choice);
+ * } else {
+ *   routeToHumanTriage();
+ * }
+ * ```
+ */
+export type Choice = z$1.infer<typeof choiceSchema>;
+/**
+ * Evaluate state against an ordered rubric.
+ *
+ * Use `Score` when the answer lies on a spectrum whose levels can be described,
+ * such as severity, urgency, or customer frustration. `criteria` lists two or
+ * more levels, numbered from zero in their supplied order. The returned score
+ * is an expected value and may fall between integer levels; the full
+ * probability distribution remains available for custom decision logic.
+ *
+ * @example
+ * ```ts
+ * const response = await model.invoke({
+ *   state: "This has failed three times. Fix it now.",
+ *   questions: {
+ *     frustration: {
+ *       type: "score",
+ *       instructions: "How frustrated does the customer appear?",
+ *       criteria: [
+ *         "Calm and neutral.",
+ *         "Concerned but civil.",
+ *         "Very angry or using strong language.",
+ *       ],
+ *     },
+ *   },
+ * });
+ * const frustration = response.scores.frustration;
+ *
+ * frustration.score; // May be fractional, for example 1.35.
+ * frustration.legend; // The original zero-based rubric.
+ * frustration.probabilities; // Probability for each rubric level.
+ * ```
+ */
+export type Score = z$1.infer<typeof scoreSchema>;
+/**
+ * Locate what the instructions describe in an image in the state.
+ *
+ * The answer gives the edges of a box as fractions of the image height and
+ * width.
+ */
+export type Box = z$1.infer<typeof boxSchema>;
+/** A discriminated union of question types accepted by decision models. */
+export type Question = z$1.infer<typeof questionSchema>;
+/**
+ * Complete input for one decision model invocation.
+ *
+ * Keeping the state and questions in the runnable input ensures both values
+ * participate in composition, batching, and tracing.
+ */
+export interface ClassifierRequest<Q extends Record<string, Question> = Record<string, Question>> {
+  /** Text, structured JSON, or LangChain messages to classify. */
+  state: State;
+  /** Non-empty map of answer IDs to typed classification questions. */
+  questions: Q;
+}
+declare const noulAnswerSchema: z$1.ZodObject<{
+  type: z$1.ZodLiteral<"noul">;
+  noul: z$1.ZodNumber;
+}, z$1.core.$strip>;
+declare const scoreAnswerSchema: z$1.ZodObject<{
+  type: z$1.ZodLiteral<"score">;
+  score: z$1.ZodNumber;
+  legend: z$1.ZodPipe<z$1.ZodCustom<Record<string, unknown>, Record<string, unknown>>, z$1.ZodTransform<Record<string, z$1.JSONType>, Record<string, unknown>>>;
+  probabilities: z$1.ZodPipe<z$1.ZodCustom<Record<string, unknown>, Record<string, unknown>>, z$1.ZodTransform<Record<string, number>, Record<string, unknown>>>;
+  confidence: z$1.ZodNumber;
+}, z$1.core.$strip>;
+declare const boxCoordinatesSchema: z$1.ZodObject<{
+  top: z$1.ZodNumber;
+  bottom: z$1.ZodNumber;
+  left: z$1.ZodNumber;
+  right: z$1.ZodNumber;
+}, z$1.core.$strip>;
+declare const boxAnswerSchema: z$1.ZodObject<{
+  type: z$1.ZodLiteral<"box">;
+  box: z$1.ZodObject<{
+    top: z$1.ZodNumber;
+    bottom: z$1.ZodNumber;
+    left: z$1.ZodNumber;
+    right: z$1.ZodNumber;
+  }, z$1.core.$strip>;
+  confidence: z$1.ZodPipe<z$1.ZodOptional<z$1.ZodNullable<z$1.ZodNumber>>, z$1.ZodTransform<number | undefined, number | null | undefined>>;
+}, z$1.core.$strip>;
+/** Probability, from `0` to `1`, that a `Noul` question's answer is yes. */
+export type NoulAnswer = z$1.infer<typeof noulAnswerSchema>;
+/**
+ * Selected `Choice` label with its probability distribution and confidence.
+ *
+ * `choice` is one of the labels supplied in `Choice.criteria`. `probabilities`
+ * keeps the complete distribution, keyed by label, so applications can use a
+ * confidence measure or risk policy different from the provider's.
+ * `confidence` is the certainty from `0` to `1` in the selected label. Each
+ * provider documents how it derives it; choose thresholds according to the
+ * consequences of an incorrect automated decision.
+ */
+export type ChoiceAnswer<K extends string = string> = {
+  type: "choice";
+  choice: K;
+  probabilities: Record<K, number>;
+  confidence: number;
+};
+/**
+ * Expected `Score` value with its rubric, distribution, and confidence.
+ *
+ * `score` is the expected position on the rubric and may be fractional, because
+ * it summarizes the distribution rather than selecting one level. `legend`
+ * holds the original rubric descriptions and `probabilities` the distribution,
+ * both keyed by zero-based level. `confidence`, from `0` to `1`, is derived
+ * from the level distribution.
+ *
+ * `legend` and `probabilities` are typed `Record<string, ...>` because JSON
+ * keys are strings; `legend[0]` still works.
+ */
+export type ScoreAnswer = z$1.infer<typeof scoreAnswerSchema>;
+/**
+ * Edges of a box as fractions of the image height and width, from `0` to `1`.
+ *
+ * `top` and `bottom` are measured from the top of the image, `left` and
+ * `right` from the left.
+ */
+export type BoxCoordinates = z$1.infer<typeof boxCoordinatesSchema>;
+/**
+ * Location of what a `Box` question describes.
+ *
+ * `confidence` is the certainty from `0` to `1`, or `undefined` when the
+ * provider does not report it.
+ */
+export type BoxAnswer = z$1.infer<typeof boxAnswerSchema>;
+/** A discriminated union of answers returned by decision models. */
+export type Answer = NoulAnswer | ChoiceAnswer | ScoreAnswer | BoxAnswer;
+/**
+ * The answer type a question produces. A `Choice` answer's `choice` is typed
+ * as one of the question's labels.
+ */
+export type AnswerFor<T extends Question> = T extends {
+  type: "noul";
+} ? NoulAnswer : T extends {
+  type: "choice";
+  criteria: infer C;
+} ? ChoiceAnswer<Extract<keyof C, string>> : T extends {
+  type: "score";
+} ? ScoreAnswer : T extends {
+  type: "box";
+} ? BoxAnswer : never;
+/** Answers keyed by question ID, typed from the questions that were asked. */
+export type Answers<Q extends Record<string, Question>> = { -readonly [K in keyof Q]: AnswerFor<Q[K]>; };
+type AnswersOfType<Q extends Record<string, Question>, T extends Question["type"]> = string extends keyof Q ? Record<string, AnswerFor<Extract<Question, {
+  type: T;
+}>>> : { -readonly [K in keyof Q as Q[K] extends {
+  type: T;
+} ? K : never]: AnswerFor<Q[K]>; };
+/** Fields a provider supplies to build a `ClassifierResponse`. */
+export interface ClassifierResponseFields {
+  /** Model that answered the request. */
+  model: string;
+  /** All answers keyed by their original question IDs. */
+  answers: Record<string, unknown>;
+  /**
+   * Token usage, or omitted when not reported. A missing count is treated as
+   * `0`, and `total_tokens` defaults to their sum.
+   */
+  usage_metadata?: Partial<UsageMetadata> | null;
+  /** Provider request ID, useful when diagnosing a request with provider support. */
+  requestId?: string | null;
+}
+/**
+ * Typed answers and metadata returned from one classification request.
+ *
+ * Read every answer from `answers`, or use `nouls`, `choices`, `scores`, and
+ * `boxes` for views filtered by answer type. Each map preserves the question
+ * IDs supplied in `ClassifierRequest.questions`. The views are non-enumerable
+ * so they are not duplicated into traces or `JSON.stringify` output.
+ *
+ * `Q` is the questions map that was asked. When it is known, answers and views
+ * are typed per question ID, and a `Choice` answer's `choice` is one of its
+ * labels.
+ */
+export interface ClassifierResponse<Q extends Record<string, Question> = Record<string, Question>> {
+  /** Model that answered the request. */
+  model: string;
+  /** All answers keyed by their original question IDs. */
+  answers: Answers<Q>;
+  /**
+   * Token usage reported for the request, if any. A missing count is treated
+   * as `0`, and `total_tokens` defaults to their sum.
+   */
+  usage_metadata?: UsageMetadata;
+  /** Provider request ID, useful when diagnosing a request with provider support. */
+  requestId?: string;
+  /** Binary answers keyed by their original question IDs. */
+  readonly nouls: AnswersOfType<Q, "noul">;
+  /** Categorical answers keyed by their original question IDs. */
+  readonly choices: AnswersOfType<Q, "choice">;
+  /** Ordinal answers keyed by their original question IDs. */
+  readonly scores: AnswersOfType<Q, "score">;
+  /** Localization answers keyed by their original question IDs. */
+  readonly boxes: AnswersOfType<Q, "box">;
+}
+/**
+ * Validates a questions map.
+ *
+ * Every question must match its type's schema, including required
+ * `instructions` and each type's minimum number of options, and unknown keys
+ * are rejected. The map itself is returned unchanged.
+ *
+ * @throws Error naming the invalid question ID.
+ */
+export declare function parseQuestions(questions: Record<string, Question>): Record<string, Question>;
+/**
+ * Validates a provider's response and returns a `ClassifierResponse`.
+ *
+ * Unknown answer types are rejected; unknown fields are dropped. Partial usage
+ * is completed with zero counts and a summed `total_tokens`.
+ *
+ * @throws Error if the response does not match the expected shape.
+ */
+export declare function parseClassifierResponse(fields: ClassifierResponseFields): ClassifierResponse;
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/decisions/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","names":["z"],"sources":["../../src/decisions/types.ts"],"mappings":";;;cAKM,iBAAeA,IAAA;;YAGT,YAAYA,IAAE,aAAa;cAEjC,eAAaA,IAAA,mBAAAA,IAAA,WAAAA,IAAA,UAAAA,IAAA,WAAAA,IAAA,gBAAAA,IAAA,SAAAA,IAAA;;;;;;;;YAaP,UAAUA,IAAE,aAAa;;YAGzB,gDAKR,cACA;GACG,cAAc;;;;;;;;;;;;;YAaT,iBAER,cACA;GACG,cAAc;;cA+Bf,oBAAkBA,IAAA;;;GAGtBA,IAAA,KAAA;cAEI,YAAUA,IAAA;;;;;;;GAIdA,IAAA,KAAA;cAEI,cAAYA,IAAA;;;;GAOhBA,IAAA,KAAA;cAEI,aAAWA,IAAA;;;;GAMfA,IAAA,KAAA;cAEI,WAASA,IAAA;;;GAGbA,IAAA,KAAA;cAEI,gBAAcA,IAAA,uBAAAA,IAAA;;;;;;;;;;;;;;;;;;GAKlBA,IAAA,KAAA;;;;;;;;;YAUU,eAAeA,IAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;YA2B9B,OAAOA,IAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAuCtB,SAASA,IAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAkCxB,QAAQA,IAAE,aAAa;;;;;;;YAQvB,MAAMA,IAAE,aAAa;;YAGrB,WAAWA,IAAE,aAAa;;;;;;;iBAQrB,kBACf,UAAU,eAAe,YAAY,eAAe;;EAGpD,OAAO;;EAEP,WAAW;;cAKP,kBAAgBA,IAAA;;;GAGpBA,IAAA,KAAA;cASI,mBAAiBA,IAAA;;;;;;GAMrBA,IAAA,KAAA;cAEI,sBAAoBA,IAAA;;;;;GAKxBA,IAAA,KAAA;cAEI,iBAAeA,IAAA;;;;;;;;;GAMnBA,IAAA,KAAA;;YAUU,aAAaA,IAAE,aAAa;;;;;;;;;;;YAY5B,aAAa;EACvB;EACA,QAAQ;EACR,eAAe,OAAO;EACtB;;;;;;;;;;;;;;YAeU,cAAcA,IAAE,aAAa;;;;;;;YAQ7B,iBAAiBA,IAAE,aAAa;;;;;;;YAQhC,YAAYA,IAAE,aAAa;;YAG3B,SAAS,aAAa,eAAe,cAAc;;;;;YAMnD,UAAU,UAAU,YAAY;EAAY;IACpD,aACA;EAAY;EAAgB,gBAAgB;IAC1C,aAAa,cAAc,cAC3B;EAAY;IACV,cACA;EAAY;IACV;;YAIE,QAAQ,UAAU,eAAe,0BAChC,WAAW,IAAI,UAAU,EAAE;KAGnC,cACH,UAAU,eAAe,WACzB,UAAU,yCACa,IACrB,eAAe,UAAU,QAAQ;EAAY,MAAM;oBAG/C,WAAW,KAAK,EAAE;EAAa,MAAM;IAAM,YAC1C,UAAU,EAAE;;iBAiCJ;;EAEf;;EAEA,SAAS;;;;;EAKT,iBAAiB,QAAQ;;EAEzB;;;;;;;;;;;;;;iBAee,mBACf,UAAU,eAAe,YAAY,eAAe;;EAGpD;;EAEA,SAAS,QAAQ;;;;;EAKjB,iBAAiB;;EAEjB;;WAES,OAAO,cAAc;;WAErB,SAAS,cAAc;;WAEvB,QAAQ,cAAc;;WAEtB,OAAO,cAAc;;;;;;;;;;;wBA4ChB,eACd,WAAW,eAAe,YACzB,eAAe;;;;;;;;;wBAmCF,wBACd,QAAQ,2BACP"}

package/dist/decisions/types.js

@@ -0,0 +1,173 @@
+import * as z$1 from "zod/v4";
+// src/decisions/types.ts
+const jsonValueSchema = z$1.json();
+const contentSchema = z$1.union([
+	z$1.string(),
+	z$1.record(z$1.string(), jsonValueSchema),
+	z$1.array(jsonValueSchema)
+]);
+const isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+function recordOf(valueSchema) {
+	return z$1.custom(isPlainObject, "Expected an object.").transform((record, ctx) => {
+		const entries = [];
+		for (const [key, value] of Object.entries(record)) {
+			const result = valueSchema.safeParse(value);
+			if (result.success) entries.push([key, result.data]);
+			else for (const issue of result.error.issues) ctx.issues.push({
+				code: "custom",
+				message: issue.message,
+				input: value,
+				path: [key, ...issue.path]
+			});
+		}
+		return Object.fromEntries(entries);
+	});
+}
+const noulCriteriaSchema = z$1.strictObject({
+	true: jsonValueSchema.optional(),
+	false: jsonValueSchema.optional()
+});
+const noulSchema = z$1.strictObject({
+	type: z$1.literal("noul"),
+	instructions: contentSchema,
+	criteria: noulCriteriaSchema.nullish()
+});
+const choiceSchema = z$1.strictObject({
+	type: z$1.literal("choice"),
+	criteria: recordOf(jsonValueSchema).refine((criteria) => Object.keys(criteria).length >= 1, "Choice question must have at least 1 option."),
+	instructions: contentSchema
+});
+const scoreSchema = z$1.strictObject({
+	type: z$1.literal("score"),
+	criteria: z$1.array(jsonValueSchema).min(2, "Score question must have at least 2 ordered levels."),
+	instructions: contentSchema
+});
+const boxSchema = z$1.strictObject({
+	type: z$1.literal("box"),
+	instructions: contentSchema
+});
+const questionSchema = z$1.discriminatedUnion("type", [
+	noulSchema,
+	choiceSchema,
+	scoreSchema,
+	boxSchema
+]);
+const probabilitySchema = z$1.number().min(0).max(1);
+const noulAnswerSchema = z$1.object({
+	type: z$1.literal("noul"),
+	noul: probabilitySchema
+});
+const choiceAnswerSchema = z$1.object({
+	type: z$1.literal("choice"),
+	choice: z$1.string(),
+	probabilities: recordOf(z$1.number()),
+	confidence: probabilitySchema
+});
+const scoreAnswerSchema = z$1.object({
+	type: z$1.literal("score"),
+	score: z$1.number(),
+	legend: recordOf(jsonValueSchema),
+	probabilities: recordOf(z$1.number()),
+	confidence: probabilitySchema
+});
+const boxCoordinatesSchema = z$1.object({
+	top: z$1.number(),
+	bottom: z$1.number(),
+	left: z$1.number(),
+	right: z$1.number()
+});
+const boxAnswerSchema = z$1.object({
+	type: z$1.literal("box"),
+	box: boxCoordinatesSchema,
+	confidence: probabilitySchema.nullish().transform((value) => value ?? void 0)
+});
+const answerSchema = z$1.discriminatedUnion("type", [
+	noulAnswerSchema,
+	choiceAnswerSchema,
+	scoreAnswerSchema,
+	boxAnswerSchema
+]);
+const usageSchema = z$1.looseObject({
+	input_tokens: z$1.number().nullish(),
+	output_tokens: z$1.number().nullish(),
+	total_tokens: z$1.number().nullish()
+}).transform((usage) => {
+	const input_tokens = usage.input_tokens ?? 0;
+	const output_tokens = usage.output_tokens ?? 0;
+	return {
+		...usage,
+		input_tokens,
+		output_tokens,
+		total_tokens: usage.total_tokens || input_tokens + output_tokens
+	};
+});
+const responseSchema = z$1.object({
+	model: z$1.string(),
+	answers: recordOf(answerSchema),
+	usage_metadata: usageSchema.nullish().transform((value) => value ?? void 0),
+	requestId: z$1.string().nullish().transform((value) => value ?? void 0)
+});
+function withAnswerViews(response) {
+	const define = (name, type) => {
+		Object.defineProperty(response, name, {
+			enumerable: false,
+			configurable: true,
+			get() {
+				return Object.fromEntries(Object.entries(response.answers).filter(([, answer]) => answer.type === type));
+			}
+		});
+	};
+	define("nouls", "noul");
+	define("choices", "choice");
+	define("scores", "score");
+	define("boxes", "box");
+	return response;
+}
+function describeIssue(issue) {
+	const path = issue.path.map(String).join(".");
+	const message = issue.code === "unrecognized_keys" ? "Unrecognized key." : issue.message;
+	return path ? `${path}: ${message}` : message;
+}
+/**
+* Validates a questions map.
+*
+* Every question must match its type's schema, including required
+* `instructions` and each type's minimum number of options, and unknown keys
+* are rejected. The map itself is returned unchanged.
+*
+* @throws Error naming the invalid question ID.
+*/
+function parseQuestions(questions) {
+	if (typeof questions !== "object" || questions === null || Array.isArray(questions) || Object.keys(questions).length === 0) throw new Error("Decision models require at least one question.");
+	for (const [id, question] of Object.entries(questions)) {
+		let result;
+		try {
+			result = questionSchema.safeParse(question);
+		} catch {
+			throw new Error(`Invalid question "${id}": content is too deeply nested or circular.`);
+		}
+		if (!result.success) throw new Error(`Invalid question "${id}": ${describeIssue(result.error.issues[0])}`);
+	}
+	return questions;
+}
+/**
+* Validates a provider's response and returns a `ClassifierResponse`.
+*
+* Unknown answer types are rejected; unknown fields are dropped. Partial usage
+* is completed with zero counts and a summed `total_tokens`.
+*
+* @throws Error if the response does not match the expected shape.
+*/
+function parseClassifierResponse(fields) {
+	const result = responseSchema.safeParse(fields);
+	if (!result.success) throw new Error(`Invalid decision model response: ${describeIssue(result.error.issues[0])}`);
+	const { usage_metadata, requestId, ...rest } = result.data;
+	return withAnswerViews({
+		...rest,
+		...usage_metadata === void 0 ? {} : { usage_metadata },
+		...requestId === void 0 ? {} : { requestId }
+	});
+}
+export { parseClassifierResponse, parseQuestions };
+
+//# sourceMappingURL=types.js.map

package/dist/decisions/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","names":["z"],"sources":["../../src/decisions/types.ts"],"sourcesContent":["import * as z from \"zod/v4\";\n\nimport type { BaseMessage } from \"../messages/base.js\";\nimport type { UsageMetadata } from \"../messages/metadata.js\";\n\nconst jsonValueSchema = z.json();\n\n/** Any value expressible in JSON. */\nexport type JsonValue = z.infer<typeof jsonValueSchema>;\n\nconst contentSchema = z.union([\n  z.string(),\n  z.record(z.string(), jsonValueSchema),\n  z.array(jsonValueSchema),\n]);\n\n/**\n * Text, a JSON object, or a JSON array used in question instructions.\n *\n * As in `State`, LangChain standard media blocks may appear anywhere in\n * instructions and criteria. Providers send them as media, or throw an error\n * if their API does not accept that media in questions.\n */\nexport type Content = z.infer<typeof contentSchema>;\n\n/** A value allowed below the root of `State`. */\nexport type StateValue =\n  | string\n  | number\n  | boolean\n  | null\n  | BaseMessage\n  | StateValue[]\n  | { [key: string]: StateValue };\n\n/**\n * Root state accepted by decision models.\n *\n * State is a string, JSON object, or JSON array. LangChain `BaseMessage` objects\n * and message arrays can appear at the root or at any depth inside objects and\n * arrays.\n *\n * LangChain standard media blocks (for example `{ type: \"image\", data: ...,\n * mimeType: ... }`) may appear anywhere in the state. Each provider documents\n * which media it supports and how it sends state its API cannot accept natively.\n */\nexport type State =\n  | string\n  | BaseMessage\n  | StateValue[]\n  | { [key: string]: StateValue };\n\nconst isPlainObject = (value: unknown): value is Record<string, unknown> =>\n  typeof value === \"object\" && value !== null && !Array.isArray(value);\n\n// Unlike `z.record`, keeps an own `__proto__` key, which can be a valid label\n// or question ID.\nfunction recordOf<T extends z.ZodType>(valueSchema: T) {\n  return z\n    .custom<Record<string, unknown>>(isPlainObject, \"Expected an object.\")\n    .transform((record, ctx) => {\n      const entries: [string, z.output<T>][] = [];\n      for (const [key, value] of Object.entries(record)) {\n        const result = valueSchema.safeParse(value);\n        if (result.success) {\n          entries.push([key, result.data]);\n        } else {\n          for (const issue of result.error.issues) {\n            ctx.issues.push({\n              code: \"custom\",\n              message: issue.message,\n              input: value,\n              path: [key, ...issue.path],\n            });\n          }\n        }\n      }\n      return Object.fromEntries(entries) as Record<string, z.output<T>>;\n    });\n}\n\nconst noulCriteriaSchema = z.strictObject({\n  true: jsonValueSchema.optional(),\n  false: jsonValueSchema.optional(),\n});\n\nconst noulSchema = z.strictObject({\n  type: z.literal(\"noul\"),\n  instructions: contentSchema,\n  criteria: noulCriteriaSchema.nullish(),\n});\n\nconst choiceSchema = z.strictObject({\n  type: z.literal(\"choice\"),\n  criteria: recordOf(jsonValueSchema).refine(\n    (criteria) => Object.keys(criteria).length >= 1,\n    \"Choice question must have at least 1 option.\"\n  ),\n  instructions: contentSchema,\n});\n\nconst scoreSchema = z.strictObject({\n  type: z.literal(\"score\"),\n  criteria: z\n    .array(jsonValueSchema)\n    .min(2, \"Score question must have at least 2 ordered levels.\"),\n  instructions: contentSchema,\n});\n\nconst boxSchema = z.strictObject({\n  type: z.literal(\"box\"),\n  instructions: contentSchema,\n});\n\nconst questionSchema = z.discriminatedUnion(\"type\", [\n  noulSchema,\n  choiceSchema,\n  scoreSchema,\n  boxSchema,\n]);\n\n/**\n * Optional descriptions for the two outcomes of a `Noul` question.\n *\n * Criteria clarify what should count as yes and no when the instructions alone\n * leave room for interpretation. Both values accept any JSON value, so callers\n * can provide a short description or structured examples. The keys are\n * literally `true` and `false`.\n */\nexport type NoulCriteria = z.infer<typeof noulCriteriaSchema>;\n\n/**\n * Ask a binary question and receive the probability that its answer is yes.\n *\n * Use `Noul` when the probability itself is useful to application code, such as\n * deciding whether a message reports a bug or requests a refund. A value near\n * `1` indicates strong support for yes, near `0` strong support for no, and\n * near `0.5` uncertainty. Noul answers have no separate confidence.\n *\n * Write the complete judgment in `instructions`, even when the question ID\n * seems self-explanatory. Optional `criteria` define the yes and no outcomes.\n *\n * @example\n * ```ts\n * const response = await model.invoke({\n *   state: \"Production is down. Please help immediately.\",\n *   questions: {\n *     urgent: {\n *       type: \"noul\",\n *       instructions: \"Does this message require an urgent response?\",\n *     },\n *   },\n * });\n * if (response.nouls.urgent.noul >= 0.8) pageOnCallEngineer();\n * ```\n */\nexport type Noul = z.infer<typeof noulSchema>;\n\n/**\n * Select one label from a fixed set of alternatives.\n *\n * Use `Choice` for categorical decisions with no inherent ordering, such as\n * routing a support request, detecting a document type, or selecting an\n * intent. The answer includes the selected label, a probability for every\n * supplied label, and a confidence value.\n *\n * `criteria` maps each label to its description, which may be text, JSON, or\n * `null`. Include an `other` or `none_of_the_above` label when the alternatives\n * may not cover every input.\n *\n * @example\n * ```ts\n * const response = await model.invoke({\n *   state: \"Stripe fails whenever I connect my account.\",\n *   questions: {\n *     department: {\n *       type: \"choice\",\n *       instructions: \"Which team should handle this request?\",\n *       criteria: {\n *         billing: \"Payment, invoice, or subscription issues.\",\n *         technical: \"Product bugs or integration failures.\",\n *         sales: \"Pricing or purchasing questions.\",\n *       },\n *     },\n *   },\n * });\n * const department = response.choices.department;\n *\n * if (department.confidence >= 0.7) {\n *   routeTo(department.choice);\n * } else {\n *   routeToHumanTriage();\n * }\n * ```\n */\nexport type Choice = z.infer<typeof choiceSchema>;\n\n/**\n * Evaluate state against an ordered rubric.\n *\n * Use `Score` when the answer lies on a spectrum whose levels can be described,\n * such as severity, urgency, or customer frustration. `criteria` lists two or\n * more levels, numbered from zero in their supplied order. The returned score\n * is an expected value and may fall between integer levels; the full\n * probability distribution remains available for custom decision logic.\n *\n * @example\n * ```ts\n * const response = await model.invoke({\n *   state: \"This has failed three times. Fix it now.\",\n *   questions: {\n *     frustration: {\n *       type: \"score\",\n *       instructions: \"How frustrated does the customer appear?\",\n *       criteria: [\n *         \"Calm and neutral.\",\n *         \"Concerned but civil.\",\n *         \"Very angry or using strong language.\",\n *       ],\n *     },\n *   },\n * });\n * const frustration = response.scores.frustration;\n *\n * frustration.score; // May be fractional, for example 1.35.\n * frustration.legend; // The original zero-based rubric.\n * frustration.probabilities; // Probability for each rubric level.\n * ```\n */\nexport type Score = z.infer<typeof scoreSchema>;\n\n/**\n * Locate what the instructions describe in an image in the state.\n *\n * The answer gives the edges of a box as fractions of the image height and\n * width.\n */\nexport type Box = z.infer<typeof boxSchema>;\n\n/** A discriminated union of question types accepted by decision models. */\nexport type Question = z.infer<typeof questionSchema>;\n\n/**\n * Complete input for one decision model invocation.\n *\n * Keeping the state and questions in the runnable input ensures both values\n * participate in composition, batching, and tracing.\n */\nexport interface ClassifierRequest<\n  Q extends Record<string, Question> = Record<string, Question>,\n> {\n  /** Text, structured JSON, or LangChain messages to classify. */\n  state: State;\n  /** Non-empty map of answer IDs to typed classification questions. */\n  questions: Q;\n}\n\nconst probabilitySchema = z.number().min(0).max(1);\n\nconst noulAnswerSchema = z.object({\n  type: z.literal(\"noul\"),\n  noul: probabilitySchema,\n});\n\nconst choiceAnswerSchema = z.object({\n  type: z.literal(\"choice\"),\n  choice: z.string(),\n  probabilities: recordOf(z.number()),\n  confidence: probabilitySchema,\n});\n\nconst scoreAnswerSchema = z.object({\n  type: z.literal(\"score\"),\n  score: z.number(),\n  legend: recordOf(jsonValueSchema),\n  probabilities: recordOf(z.number()),\n  confidence: probabilitySchema,\n});\n\nconst boxCoordinatesSchema = z.object({\n  top: z.number(),\n  bottom: z.number(),\n  left: z.number(),\n  right: z.number(),\n});\n\nconst boxAnswerSchema = z.object({\n  type: z.literal(\"box\"),\n  box: boxCoordinatesSchema,\n  confidence: probabilitySchema\n    .nullish()\n    .transform((value) => value ?? undefined),\n});\n\nconst answerSchema = z.discriminatedUnion(\"type\", [\n  noulAnswerSchema,\n  choiceAnswerSchema,\n  scoreAnswerSchema,\n  boxAnswerSchema,\n]);\n\n/** Probability, from `0` to `1`, that a `Noul` question's answer is yes. */\nexport type NoulAnswer = z.infer<typeof noulAnswerSchema>;\n\n/**\n * Selected `Choice` label with its probability distribution and confidence.\n *\n * `choice` is one of the labels supplied in `Choice.criteria`. `probabilities`\n * keeps the complete distribution, keyed by label, so applications can use a\n * confidence measure or risk policy different from the provider's.\n * `confidence` is the certainty from `0` to `1` in the selected label. Each\n * provider documents how it derives it; choose thresholds according to the\n * consequences of an incorrect automated decision.\n */\nexport type ChoiceAnswer<K extends string = string> = {\n  type: \"choice\";\n  choice: K;\n  probabilities: Record<K, number>;\n  confidence: number;\n};\n\n/**\n * Expected `Score` value with its rubric, distribution, and confidence.\n *\n * `score` is the expected position on the rubric and may be fractional, because\n * it summarizes the distribution rather than selecting one level. `legend`\n * holds the original rubric descriptions and `probabilities` the distribution,\n * both keyed by zero-based level. `confidence`, from `0` to `1`, is derived\n * from the level distribution.\n *\n * `legend` and `probabilities` are typed `Record<string, ...>` because JSON\n * keys are strings; `legend[0]` still works.\n */\nexport type ScoreAnswer = z.infer<typeof scoreAnswerSchema>;\n\n/**\n * Edges of a box as fractions of the image height and width, from `0` to `1`.\n *\n * `top` and `bottom` are measured from the top of the image, `left` and\n * `right` from the left.\n */\nexport type BoxCoordinates = z.infer<typeof boxCoordinatesSchema>;\n\n/**\n * Location of what a `Box` question describes.\n *\n * `confidence` is the certainty from `0` to `1`, or `undefined` when the\n * provider does not report it.\n */\nexport type BoxAnswer = z.infer<typeof boxAnswerSchema>;\n\n/** A discriminated union of answers returned by decision models. */\nexport type Answer = NoulAnswer | ChoiceAnswer | ScoreAnswer | BoxAnswer;\n\n/**\n * The answer type a question produces. A `Choice` answer's `choice` is typed\n * as one of the question's labels.\n */\nexport type AnswerFor<T extends Question> = T extends { type: \"noul\" }\n  ? NoulAnswer\n  : T extends { type: \"choice\"; criteria: infer C }\n    ? ChoiceAnswer<Extract<keyof C, string>>\n    : T extends { type: \"score\" }\n      ? ScoreAnswer\n      : T extends { type: \"box\" }\n        ? BoxAnswer\n        : never;\n\n/** Answers keyed by question ID, typed from the questions that were asked. */\nexport type Answers<Q extends Record<string, Question>> = {\n  -readonly [K in keyof Q]: AnswerFor<Q[K]>;\n};\n\ntype AnswersOfType<\n  Q extends Record<string, Question>,\n  T extends Question[\"type\"],\n> = string extends keyof Q\n  ? Record<string, AnswerFor<Extract<Question, { type: T }>>>\n  : {\n      -readonly [\n        K in keyof Q as Q[K] extends { type: T } ? K : never\n      ]: AnswerFor<Q[K]>;\n    };\n\nconst usageSchema = z\n  .looseObject({\n    input_tokens: z.number().nullish(),\n    output_tokens: z.number().nullish(),\n    total_tokens: z.number().nullish(),\n  })\n  .transform((usage) => {\n    const input_tokens = usage.input_tokens ?? 0;\n    const output_tokens = usage.output_tokens ?? 0;\n    return {\n      ...usage,\n      input_tokens,\n      output_tokens,\n      total_tokens: usage.total_tokens || input_tokens + output_tokens,\n    } as UsageMetadata;\n  });\n\nconst responseSchema = z.object({\n  model: z.string(),\n  answers: recordOf(answerSchema),\n  usage_metadata: usageSchema\n    .nullish()\n    .transform((value) => value ?? undefined),\n  requestId: z\n    .string()\n    .nullish()\n    .transform((value) => value ?? undefined),\n});\n\n/** Fields a provider supplies to build a `ClassifierResponse`. */\nexport interface ClassifierResponseFields {\n  /** Model that answered the request. */\n  model: string;\n  /** All answers keyed by their original question IDs. */\n  answers: Record<string, unknown>;\n  /**\n   * Token usage, or omitted when not reported. A missing count is treated as\n   * `0`, and `total_tokens` defaults to their sum.\n   */\n  usage_metadata?: Partial<UsageMetadata> | null;\n  /** Provider request ID, useful when diagnosing a request with provider support. */\n  requestId?: string | null;\n}\n\n/**\n * Typed answers and metadata returned from one classification request.\n *\n * Read every answer from `answers`, or use `nouls`, `choices`, `scores`, and\n * `boxes` for views filtered by answer type. Each map preserves the question\n * IDs supplied in `ClassifierRequest.questions`. The views are non-enumerable\n * so they are not duplicated into traces or `JSON.stringify` output.\n *\n * `Q` is the questions map that was asked. When it is known, answers and views\n * are typed per question ID, and a `Choice` answer's `choice` is one of its\n * labels.\n */\nexport interface ClassifierResponse<\n  Q extends Record<string, Question> = Record<string, Question>,\n> {\n  /** Model that answered the request. */\n  model: string;\n  /** All answers keyed by their original question IDs. */\n  answers: Answers<Q>;\n  /**\n   * Token usage reported for the request, if any. A missing count is treated\n   * as `0`, and `total_tokens` defaults to their sum.\n   */\n  usage_metadata?: UsageMetadata;\n  /** Provider request ID, useful when diagnosing a request with provider support. */\n  requestId?: string;\n  /** Binary answers keyed by their original question IDs. */\n  readonly nouls: AnswersOfType<Q, \"noul\">;\n  /** Categorical answers keyed by their original question IDs. */\n  readonly choices: AnswersOfType<Q, \"choice\">;\n  /** Ordinal answers keyed by their original question IDs. */\n  readonly scores: AnswersOfType<Q, \"score\">;\n  /** Localization answers keyed by their original question IDs. */\n  readonly boxes: AnswersOfType<Q, \"box\">;\n}\n\nfunction withAnswerViews(\n  response: Omit<ClassifierResponse, \"nouls\" | \"choices\" | \"scores\" | \"boxes\">\n): ClassifierResponse {\n  const define = (name: string, type: Answer[\"type\"]) => {\n    Object.defineProperty(response, name, {\n      enumerable: false,\n      configurable: true,\n      get() {\n        return Object.fromEntries(\n          Object.entries(response.answers).filter(\n            ([, answer]) => answer.type === type\n          )\n        );\n      },\n    });\n  };\n  define(\"nouls\", \"noul\");\n  define(\"choices\", \"choice\");\n  define(\"scores\", \"score\");\n  define(\"boxes\", \"box\");\n  return response as ClassifierResponse;\n}\n\n// Names the field path and the kind of problem, never the caller's values or\n// unknown key names, so the message is safe to log.\nfunction describeIssue(issue: z.core.$ZodIssue): string {\n  const path = issue.path.map(String).join(\".\");\n  const message =\n    issue.code === \"unrecognized_keys\" ? \"Unrecognized key.\" : issue.message;\n  return path ? `${path}: ${message}` : message;\n}\n\n/**\n * Validates a questions map.\n *\n * Every question must match its type's schema, including required\n * `instructions` and each type's minimum number of options, and unknown keys\n * are rejected. The map itself is returned unchanged.\n *\n * @throws Error naming the invalid question ID.\n */\nexport function parseQuestions(\n  questions: Record<string, Question>\n): Record<string, Question> {\n  if (\n    typeof questions !== \"object\" ||\n    questions === null ||\n    Array.isArray(questions) ||\n    Object.keys(questions).length === 0\n  ) {\n    throw new Error(\"Decision models require at least one question.\");\n  }\n  for (const [id, question] of Object.entries(questions)) {\n    let result: ReturnType<typeof questionSchema.safeParse>;\n    try {\n      result = questionSchema.safeParse(question);\n    } catch {\n      throw new Error(\n        `Invalid question \"${id}\": content is too deeply nested or circular.`\n      );\n    }\n    if (!result.success) {\n      throw new Error(\n        `Invalid question \"${id}\": ${describeIssue(result.error.issues[0])}`\n      );\n    }\n  }\n  return questions;\n}\n\n/**\n * Validates a provider's response and returns a `ClassifierResponse`.\n *\n * Unknown answer types are rejected; unknown fields are dropped. Partial usage\n * is completed with zero counts and a summed `total_tokens`.\n *\n * @throws Error if the response does not match the expected shape.\n */\nexport function parseClassifierResponse(\n  fields: ClassifierResponseFields\n): ClassifierResponse {\n  const result = responseSchema.safeParse(fields);\n  if (!result.success) {\n    throw new Error(\n      `Invalid decision model response: ${describeIssue(result.error.issues[0])}`\n    );\n  }\n  const { usage_metadata, requestId, ...rest } = result.data;\n  return withAnswerViews({\n    ...rest,\n    ...(usage_metadata === undefined ? {} : { usage_metadata }),\n    ...(requestId === undefined ? {} : { requestId }),\n  });\n}\n"],"mappings":"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"}

package/dist/language_models/base.cjs

@@ -139,7 +139,7 @@ var BaseLangChain = class extends require_base.Runnable {
 		this.callbacks = params.callbacks;
 		this.tags = params.tags ?? [];
 		this.metadata = params.metadata ?? {};
-		this._addVersion("@langchain/core", "1.3.7");
+		this._addVersion("@langchain/core", "1.4.0");
 	}
 	_addVersion(pkg, version) {
 		const existing = this.metadata?.versions;

package/dist/language_models/base.js

@@ -138,7 +138,7 @@ var BaseLangChain = class extends Runnable {
 		this.callbacks = params.callbacks;
 		this.tags = params.tags ?? [];
 		this.metadata = params.metadata ?? {};
-		this._addVersion("@langchain/core", "1.3.7");
+		this._addVersion("@langchain/core", "1.4.0");
 	}
 	_addVersion(pkg, version) {
 		const existing = this.metadata?.versions;

package/dist/load/import_map.cjs

@@ -5,6 +5,7 @@ const require_callbacks_base = require("../callbacks/base.cjs");
 const require_callbacks_manager = require("../callbacks/manager.cjs");
 const require_callbacks_promises = require("../callbacks/promises.cjs");
 const require_chat_history = require("../chat_history.cjs");
+const require_decisions_index = require("../decisions/index.cjs");
 const require_document_loaders_base = require("../document_loaders/base.cjs");
 const require_document_loaders_langsmith = require("../document_loaders/langsmith.cjs");
 const require_documents_index = require("../documents/index.cjs");
@@ -75,6 +76,7 @@ var import_map_exports = /* @__PURE__ */ require_runtime.__exportAll({
 	callbacks__manager: () => require_callbacks_manager.manager_exports,
 	callbacks__promises: () => require_callbacks_promises.promises_exports,
 	chat_history: () => require_chat_history.chat_history_exports,
+	decisions: () => require_decisions_index.decisions_exports,
 	document_loaders__base: () => require_document_loaders_base.base_exports,
 	document_loaders__langsmith: () => require_document_loaders_langsmith.langsmith_exports,
 	documents: () => require_documents_index.documents_exports,
@@ -174,6 +176,12 @@ Object.defineProperty(exports, "chat_history", {
 		return require_chat_history.chat_history_exports;
 	}
 });
+Object.defineProperty(exports, "decisions", {
+	enumerable: true,
+	get: function() {
+		return require_decisions_index.decisions_exports;
+	}
+});
 Object.defineProperty(exports, "document_loaders__base", {
 	enumerable: true,
 	get: function() {