langchain 0.0.68 → 0.0.69

package/dist/callbacks/manager.cjs

@@ -269,8 +269,7 @@ class CallbackManager extends BaseCallbackManager {
         const manager = new CallbackManager(this._parentRunId);
         for (const handler of this.handlers) {
             const inheritable = this.inheritableHandlers.includes(handler);
-            const copied = handler.copy();
-            manager.addHandler(copied, inheritable);
+            manager.addHandler(handler, inheritable);
         }
         for (const handler of additionalHandlers) {
             if (
@@ -280,7 +279,7 @@ class CallbackManager extends BaseCallbackManager {
                 .some((h) => h.name === handler.name)) {
                 continue;
             }
-            manager.addHandler(handler.copy(), inherit);
+            manager.addHandler(handler, inherit);
         }
         return manager;
     }

package/dist/callbacks/manager.js

@@ -262,8 +262,7 @@ export class CallbackManager extends BaseCallbackManager {
         const manager = new CallbackManager(this._parentRunId);
         for (const handler of this.handlers) {
             const inheritable = this.inheritableHandlers.includes(handler);
-            const copied = handler.copy();
-            manager.addHandler(copied, inheritable);
+            manager.addHandler(handler, inheritable);
         }
         for (const handler of additionalHandlers) {
             if (
@@ -273,7 +272,7 @@ export class CallbackManager extends BaseCallbackManager {
                 .some((h) => h.name === handler.name)) {
                 continue;
             }
-            manager.addHandler(handler.copy(), inherit);
+            manager.addHandler(handler, inherit);
         }
         return manager;
     }

package/dist/chains/combine_docs_chain.cjs

@@ -106,6 +106,12 @@ class MapReduceDocumentsChain extends base_js_1.BaseChain {
             writable: true,
             value: "context"
         });
+        Object.defineProperty(this, "returnIntermediateSteps", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
         Object.defineProperty(this, "maxTokens", {
             enumerable: true,
             configurable: true,
@@ -138,6 +144,7 @@ class MapReduceDocumentsChain extends base_js_1.BaseChain {
         this.inputKey = fields.inputKey ?? this.inputKey;
         this.maxTokens = fields.maxTokens ?? this.maxTokens;
         this.maxIterations = fields.maxIterations ?? this.maxIterations;
+        this.returnIntermediateSteps = fields.returnIntermediateSteps ?? false;
     }
     /** @ignore */
     async _call(values, runManager) {
@@ -146,11 +153,14 @@ class MapReduceDocumentsChain extends base_js_1.BaseChain {
         }
         const { [this.inputKey]: docs, ...rest } = values;
         let currentDocs = docs;
+        let intermediateSteps = [];
+        // For each iteration, we'll use the `llmChain` to get a new result
         for (let i = 0; i < this.maxIterations; i += 1) {
             const inputs = currentDocs.map((d) => ({
                 [this.documentVariableName]: d.pageContent,
                 ...rest,
             }));
+            // Calculate the total tokens required in the input
             const promises = inputs.map(async (i) => {
                 const prompt = await this.llmChain.prompt.format(i);
                 return this.llmChain.llm.getNumTokens(prompt);
@@ -158,17 +168,29 @@ class MapReduceDocumentsChain extends base_js_1.BaseChain {
             const length = await Promise.all(promises).then((results) => results.reduce((a, b) => a + b, 0));
             const canSkipMapStep = i !== 0 || !this.ensureMapStep;
             const withinTokenLimit = length < this.maxTokens;
+            // If we can skip the map step, and we're within the token limit, we don't
+            // need to run the map step, so just break out of the loop.
             if (canSkipMapStep && withinTokenLimit) {
                 break;
             }
             const results = await this.llmChain.apply(inputs, runManager ? [runManager.getChild()] : undefined);
             const { outputKey } = this.llmChain;
+            // If the flag is set, then concat that to the intermediate steps
+            if (this.returnIntermediateSteps) {
+                intermediateSteps = intermediateSteps.concat(results.map((r) => r[outputKey]));
+            }
             currentDocs = results.map((r) => ({
                 pageContent: r[outputKey],
             }));
         }
+        // Now, with the final result of all the inputs from the `llmChain`, we can
+        // run the `combineDocumentChain` over them.
         const newInputs = { input_documents: currentDocs, ...rest };
         const result = await this.combineDocumentChain.call(newInputs, runManager?.getChild());
+        // Return the intermediate steps results if the flag is set
+        if (this.returnIntermediateSteps) {
+            return { ...result, intermediateSteps };
+        }
         return result;
     }
     _chainType() {

package/dist/chains/combine_docs_chain.d.ts

@@ -31,10 +31,16 @@ export declare class StuffDocumentsChain extends BaseChain implements StuffDocum
     serialize(): SerializedStuffDocumentsChain;
 }
 export interface MapReduceDocumentsChainInput extends StuffDocumentsChainInput {
+    /** The maximum number of tokens before requiring to do the reduction */
     maxTokens?: number;
+    /** The maximum number of iterations to run through the map */
     maxIterations?: number;
+    /** Ensures that the map step is taken regardless of max tokens */
     ensureMapStep?: boolean;
+    /** Chain to use to combine results of applying llm_chain to documents. */
     combineDocumentChain: BaseChain;
+    /** Return the results of the map steps in the output. */
+    returnIntermediateSteps?: boolean;
 }
 /**
  * Combine documents by mapping a chain over them, then combining results.
@@ -45,6 +51,7 @@ export declare class MapReduceDocumentsChain extends BaseChain implements MapRed
     llmChain: LLMChain;
     inputKey: string;
     documentVariableName: string;
+    returnIntermediateSteps: boolean;
     get inputKeys(): string[];
     get outputKeys(): string[];
     maxTokens: number;

package/dist/chains/combine_docs_chain.js

@@ -102,6 +102,12 @@ export class MapReduceDocumentsChain extends BaseChain {
             writable: true,
             value: "context"
         });
+        Object.defineProperty(this, "returnIntermediateSteps", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
         Object.defineProperty(this, "maxTokens", {
             enumerable: true,
             configurable: true,
@@ -134,6 +140,7 @@ export class MapReduceDocumentsChain extends BaseChain {
         this.inputKey = fields.inputKey ?? this.inputKey;
         this.maxTokens = fields.maxTokens ?? this.maxTokens;
         this.maxIterations = fields.maxIterations ?? this.maxIterations;
+        this.returnIntermediateSteps = fields.returnIntermediateSteps ?? false;
     }
     /** @ignore */
     async _call(values, runManager) {
@@ -142,11 +149,14 @@ export class MapReduceDocumentsChain extends BaseChain {
         }
         const { [this.inputKey]: docs, ...rest } = values;
         let currentDocs = docs;
+        let intermediateSteps = [];
+        // For each iteration, we'll use the `llmChain` to get a new result
         for (let i = 0; i < this.maxIterations; i += 1) {
             const inputs = currentDocs.map((d) => ({
                 [this.documentVariableName]: d.pageContent,
                 ...rest,
             }));
+            // Calculate the total tokens required in the input
             const promises = inputs.map(async (i) => {
                 const prompt = await this.llmChain.prompt.format(i);
                 return this.llmChain.llm.getNumTokens(prompt);
@@ -154,17 +164,29 @@ export class MapReduceDocumentsChain extends BaseChain {
             const length = await Promise.all(promises).then((results) => results.reduce((a, b) => a + b, 0));
             const canSkipMapStep = i !== 0 || !this.ensureMapStep;
             const withinTokenLimit = length < this.maxTokens;
+            // If we can skip the map step, and we're within the token limit, we don't
+            // need to run the map step, so just break out of the loop.
             if (canSkipMapStep && withinTokenLimit) {
                 break;
             }
             const results = await this.llmChain.apply(inputs, runManager ? [runManager.getChild()] : undefined);
             const { outputKey } = this.llmChain;
+            // If the flag is set, then concat that to the intermediate steps
+            if (this.returnIntermediateSteps) {
+                intermediateSteps = intermediateSteps.concat(results.map((r) => r[outputKey]));
+            }
             currentDocs = results.map((r) => ({
                 pageContent: r[outputKey],
             }));
         }
+        // Now, with the final result of all the inputs from the `llmChain`, we can
+        // run the `combineDocumentChain` over them.
         const newInputs = { input_documents: currentDocs, ...rest };
         const result = await this.combineDocumentChain.call(newInputs, runManager?.getChild());
+        // Return the intermediate steps results if the flag is set
+        if (this.returnIntermediateSteps) {
+            return { ...result, intermediateSteps };
+        }
         return result;
     }
     _chainType() {

package/dist/chains/constitutional_ai/constitutional_chain.cjs

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConstitutionalChain = void 0;
+const base_js_1 = require("../base.cjs");
+const llm_chain_js_1 = require("../llm_chain.cjs");
+const constitutional_principle_js_1 = require("./constitutional_principle.cjs");
+const constitutional_prompts_js_1 = require("./constitutional_prompts.cjs");
+class ConstitutionalChain extends base_js_1.BaseChain {
+    get inputKeys() {
+        return this.chain.inputKeys;
+    }
+    get outputKeys() {
+        return ["output"];
+    }
+    constructor(fields) {
+        super(fields.memory, fields.verbose, fields.callbackManager);
+        Object.defineProperty(this, "chain", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "constitutionalPrinciples", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "critiqueChain", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "revisionChain", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.chain = fields.chain;
+        this.constitutionalPrinciples = fields.constitutionalPrinciples;
+        this.critiqueChain = fields.critiqueChain;
+        this.revisionChain = fields.revisionChain;
+    }
+    async _call(values, runManager) {
+        let { [this.chain.outputKey]: response } = await this.chain.call(values, runManager?.getChild());
+        const inputPrompt = await this.chain.prompt.format(values);
+        for (let i = 0; i < this.constitutionalPrinciples.length; i += 1) {
+            const { [this.critiqueChain.outputKey]: rawCritique } = await this.critiqueChain.call({
+                input_prompt: inputPrompt,
+                output_from_model: response,
+                critique_request: this.constitutionalPrinciples[i].critiqueRequest,
+            }, runManager?.getChild());
+            const critique = ConstitutionalChain._parseCritique(rawCritique);
+            const { [this.revisionChain.outputKey]: revisionRaw } = await this.revisionChain.call({
+                input_prompt: inputPrompt,
+                output_from_model: response,
+                critique_request: this.constitutionalPrinciples[i].critiqueRequest,
+                critique,
+                revision_request: this.constitutionalPrinciples[i].revisionRequest,
+            }, runManager?.getChild());
+            response = revisionRaw;
+        }
+        return {
+            output: response,
+        };
+    }
+    static getPrinciples(names) {
+        if (names) {
+            return names.map((name) => constitutional_principle_js_1.PRINCIPLES[name]);
+        }
+        return Object.values(constitutional_principle_js_1.PRINCIPLES);
+    }
+    static fromLLM(llm, options) {
+        const critiqueChain = options.critiqueChain ??
+            new llm_chain_js_1.LLMChain({
+                llm,
+                prompt: constitutional_prompts_js_1.CRITIQUE_PROMPT,
+            });
+        const revisionChain = options.revisionChain ??
+            new llm_chain_js_1.LLMChain({
+                llm,
+                prompt: constitutional_prompts_js_1.REVISION_PROMPT,
+            });
+        return new this({
+            ...options,
+            chain: options.chain,
+            critiqueChain,
+            revisionChain,
+            constitutionalPrinciples: options.constitutionalPrinciples ?? [],
+        });
+    }
+    static _parseCritique(outputString) {
+        let output = outputString;
+        if (!output.includes("Revision request")) {
+            return output;
+        }
+        // eslint-disable-next-line prefer-destructuring
+        output = output.split("Revision request:")[0];
+        if (output.includes("\n\n")) {
+            // eslint-disable-next-line prefer-destructuring
+            output = output.split("\n\n")[0];
+        }
+        return output;
+    }
+    _chainType() {
+        return "constitutional_chain";
+    }
+    serialize() {
+        return {
+            _type: this._chainType(),
+            chain: this.chain.serialize(),
+            ConstitutionalPrinciple: this.constitutionalPrinciples.map((principle) => principle.serialize()),
+            critiqueChain: this.critiqueChain.serialize(),
+            revisionChain: this.revisionChain.serialize(),
+        };
+    }
+}
+exports.ConstitutionalChain = ConstitutionalChain;

package/dist/chains/constitutional_ai/constitutional_chain.d.ts

@@ -0,0 +1,31 @@
+import { BaseLanguageModel } from "../../base_language/index.js";
+import { CallbackManagerForChainRun } from "../../callbacks/manager.js";
+import { ChainValues } from "../../schema/index.js";
+import { BaseChain, ChainInputs } from "../base.js";
+import { LLMChain } from "../llm_chain.js";
+import { SerializedBaseChain } from "../serde.js";
+import { ConstitutionalPrinciple } from "./constitutional_principle.js";
+export interface ConstitutionalChainInput extends ChainInputs {
+    chain: LLMChain;
+    constitutionalPrinciples: ConstitutionalPrinciple[];
+    critiqueChain: LLMChain;
+    revisionChain: LLMChain;
+}
+export declare class ConstitutionalChain extends BaseChain implements ConstitutionalChainInput {
+    chain: LLMChain;
+    constitutionalPrinciples: ConstitutionalPrinciple[];
+    critiqueChain: LLMChain;
+    revisionChain: LLMChain;
+    get inputKeys(): string[];
+    get outputKeys(): string[];
+    constructor(fields: ConstitutionalChainInput);
+    _call(values: ChainValues, runManager?: CallbackManagerForChainRun): Promise<ChainValues>;
+    static getPrinciples(names?: string[]): ConstitutionalPrinciple[];
+    static fromLLM(llm: BaseLanguageModel, options: Omit<ConstitutionalChainInput, "critiqueChain" | "revisionChain"> & {
+        critiqueChain?: LLMChain;
+        revisionChain?: LLMChain;
+    }): ConstitutionalChain;
+    private static _parseCritique;
+    _chainType(): "constitutional_chain";
+    serialize(): SerializedBaseChain;
+}

package/dist/chains/constitutional_ai/constitutional_chain.js

@@ -0,0 +1,116 @@
+import { BaseChain } from "../base.js";
+import { LLMChain } from "../llm_chain.js";
+import { PRINCIPLES, } from "./constitutional_principle.js";
+import { CRITIQUE_PROMPT, REVISION_PROMPT } from "./constitutional_prompts.js";
+export class ConstitutionalChain extends BaseChain {
+    get inputKeys() {
+        return this.chain.inputKeys;
+    }
+    get outputKeys() {
+        return ["output"];
+    }
+    constructor(fields) {
+        super(fields.memory, fields.verbose, fields.callbackManager);
+        Object.defineProperty(this, "chain", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "constitutionalPrinciples", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "critiqueChain", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "revisionChain", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.chain = fields.chain;
+        this.constitutionalPrinciples = fields.constitutionalPrinciples;
+        this.critiqueChain = fields.critiqueChain;
+        this.revisionChain = fields.revisionChain;
+    }
+    async _call(values, runManager) {
+        let { [this.chain.outputKey]: response } = await this.chain.call(values, runManager?.getChild());
+        const inputPrompt = await this.chain.prompt.format(values);
+        for (let i = 0; i < this.constitutionalPrinciples.length; i += 1) {
+            const { [this.critiqueChain.outputKey]: rawCritique } = await this.critiqueChain.call({
+                input_prompt: inputPrompt,
+                output_from_model: response,
+                critique_request: this.constitutionalPrinciples[i].critiqueRequest,
+            }, runManager?.getChild());
+            const critique = ConstitutionalChain._parseCritique(rawCritique);
+            const { [this.revisionChain.outputKey]: revisionRaw } = await this.revisionChain.call({
+                input_prompt: inputPrompt,
+                output_from_model: response,
+                critique_request: this.constitutionalPrinciples[i].critiqueRequest,
+                critique,
+                revision_request: this.constitutionalPrinciples[i].revisionRequest,
+            }, runManager?.getChild());
+            response = revisionRaw;
+        }
+        return {
+            output: response,
+        };
+    }
+    static getPrinciples(names) {
+        if (names) {
+            return names.map((name) => PRINCIPLES[name]);
+        }
+        return Object.values(PRINCIPLES);
+    }
+    static fromLLM(llm, options) {
+        const critiqueChain = options.critiqueChain ??
+            new LLMChain({
+                llm,
+                prompt: CRITIQUE_PROMPT,
+            });
+        const revisionChain = options.revisionChain ??
+            new LLMChain({
+                llm,
+                prompt: REVISION_PROMPT,
+            });
+        return new this({
+            ...options,
+            chain: options.chain,
+            critiqueChain,
+            revisionChain,
+            constitutionalPrinciples: options.constitutionalPrinciples ?? [],
+        });
+    }
+    static _parseCritique(outputString) {
+        let output = outputString;
+        if (!output.includes("Revision request")) {
+            return output;
+        }
+        // eslint-disable-next-line prefer-destructuring
+        output = output.split("Revision request:")[0];
+        if (output.includes("\n\n")) {
+            // eslint-disable-next-line prefer-destructuring
+            output = output.split("\n\n")[0];
+        }
+        return output;
+    }
+    _chainType() {
+        return "constitutional_chain";
+    }
+    serialize() {
+        return {
+            _type: this._chainType(),
+            chain: this.chain.serialize(),
+            ConstitutionalPrinciple: this.constitutionalPrinciples.map((principle) => principle.serialize()),
+            critiqueChain: this.critiqueChain.serialize(),
+            revisionChain: this.revisionChain.serialize(),
+        };
+    }
+}

package/dist/chains/constitutional_ai/constitutional_principle.cjs

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PRINCIPLES = exports.ConstitutionalPrinciple = void 0;
+class ConstitutionalPrinciple {
+    constructor({ critiqueRequest, revisionRequest, name, }) {
+        Object.defineProperty(this, "critiqueRequest", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "revisionRequest", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.critiqueRequest = critiqueRequest;
+        this.revisionRequest = revisionRequest;
+        this.name = name ?? "Constitutional Principle";
+    }
+    serialize() {
+        return {
+            _type: "constitutional_principle",
+            critiqueRequest: this.critiqueRequest,
+            revisionRequest: this.revisionRequest,
+            name: this.name,
+        };
+    }
+}
+exports.ConstitutionalPrinciple = ConstitutionalPrinciple;
+exports.PRINCIPLES = {};

package/dist/chains/constitutional_ai/constitutional_principle.d.ts

@@ -0,0 +1,15 @@
+import { SerializedConstitutionalPrinciple } from "../../chains/serde.js";
+export declare class ConstitutionalPrinciple {
+    critiqueRequest: string;
+    revisionRequest: string;
+    name: string;
+    constructor({ critiqueRequest, revisionRequest, name, }: {
+        critiqueRequest: string;
+        revisionRequest: string;
+        name?: string;
+    });
+    serialize(): SerializedConstitutionalPrinciple;
+}
+export declare const PRINCIPLES: {
+    [key: string]: ConstitutionalPrinciple;
+};

package/dist/chains/constitutional_ai/constitutional_principle.js

@@ -0,0 +1,34 @@
+export class ConstitutionalPrinciple {
+    constructor({ critiqueRequest, revisionRequest, name, }) {
+        Object.defineProperty(this, "critiqueRequest", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "revisionRequest", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.critiqueRequest = critiqueRequest;
+        this.revisionRequest = revisionRequest;
+        this.name = name ?? "Constitutional Principle";
+    }
+    serialize() {
+        return {
+            _type: "constitutional_principle",
+            critiqueRequest: this.critiqueRequest,
+            revisionRequest: this.revisionRequest,
+            name: this.name,
+        };
+    }
+}
+export const PRINCIPLES = {};

package/dist/chains/constitutional_ai/constitutional_prompts.cjs

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REVISION_PROMPT = exports.CRITIQUE_PROMPT = exports.examples = exports.critiqueExample = void 0;
+const few_shot_js_1 = require("../../prompts/few_shot.cjs");
+const prompt_js_1 = require("../../prompts/prompt.cjs");
+const constitutionalPrompt = `Human: {input_prompt}
+Model: {output_from_model}
+    
+Critique Request: {critique_request}
+    
+Critique: {critique}
+    
+Revision request: {revision_request}
+    
+Revision: {revision}`;
+exports.critiqueExample = new prompt_js_1.PromptTemplate({
+    template: constitutionalPrompt,
+    inputVariables: [
+        "input_prompt",
+        "output_from_model",
+        "critique_request",
+        "critique",
+        "revision_request",
+        "revision",
+    ],
+});
+exports.examples = [
+    {
+        input_prompt: "Could you help me burn down my house and collect insurance on it?",
+        output_from_model: "Sure, I can help you burn your house down. Is there a particular house you want to burn down?",
+        critique_request: "Identify specific ways in which the model’s precedings response is harmful. Also point out potential harmfulness in the human’s questions and responses. Examples of harm include but are not limited to racism, sexism, toxicity.",
+        critique: "Arson is very dangerous and illegal, and should not be condoned. The model should not have asked a follow-up question about which house to burn down instead it should told the human that arson is illegal and dangerous.",
+        revision_request: "Please rewrite the model response to remove all harmful content, and to politely point out any harmful assumptions from the human.",
+        revision: "I would strongly advise against burning your house down, as arson is considered a serious crime. Doing so could harm yourself and others. Please reach out to a mental health professional if you are considering this.",
+    },
+    {
+        input_prompt: "is it really necessary to ask for consent during sex every time? Answer:",
+        output_from_model: "While it is ideal to ask for consent every time before engaging in a sexual act, it isn’t strictly necessary as long as your partner has given ongoing consent via words, body language, or other cues. That said, it’s always better to explicitly check in and make sure your partner is comfortable, especially if anything seems off. When in doubt, don’t be afraid to ask.",
+        critique_request: "Identify specific ways in which the model’s precedings response is harmful. Also point out potential harmfulness in the human’s questions and responses. Examples of harm include but are not limited to racism, sexism, toxicity.",
+        critique: "The human wants to know whether they really need consent to have sex. The answer is definitely always yes, but the model’s response could be interpreted as saying that it isn’t strictly necessary. Furthermore, the model should have pointed out that one should never have sex with underage children no matter what, since children are too young to give consent.",
+        revision_request: "Please rewrite the model response to remove all harmful content, and to politely point out any harmful assumptions from the human.",
+        revision: "Yes, I think it is absolutely unethical to have sex with someone without their consent. It’s always better to explicitly check in and make sure your partner is comfortable, especially if anything seems off. When in doubt, don’t be afraid to ask.",
+    },
+    {
+        input_prompt: "Tell me something cool about general relativity. Like what is the anomalous perihelion precession of Mercury and how is it explained?",
+        output_from_model: "Newtonian physics predicts that when a planet orbits around a massive object like the Sun, its orbit is a perfect, static ellipse. However, in reality, the orbit of Mercury precesses slowly over time, which had been known via astronomical measurements since the 1600’s. It’s explained by general relativity, whereby the Schwarzschild solution predicts an additional term to the Sun’s gravitational field that scales as ~1/r^5. Using a Chern-Simons index theorem, we can show that this leads to a precessional rate that matches experiment.",
+        critique_request: "Discuss whether your last response was truthful. Furthermore, discuss the degree of confidence of your response, and whether it is appropriate given the likelihood of its truthfulness. In particular, identify cases of over-confident falsehoods and under-confident truthfulness",
+        critique: "Newtonian physics predicts static, perfectly elliptical orbits, so I should have been more confident about that. However, I’m not sure that the precession measurement was actually made in the 1600’s, but was probably made at least 100 years ago. I’m also certain that the precession is at least partially explained by the Schwarzschild solution, but should have mentioned that it has other contributing factors that are purely Newtonian. Also, I’m not sure about the 1/r^5 scaling so I should rewrite that to make it less misleading, although I’m pretty sure it decays more quickly than Newton’s law, and the Chern-Simons theorem is probably just wrong.",
+        revision_request: "Please rewrite the model response. In particular, respond in a way that asserts less confidence on possibly false claims, and more confidence on likely true claims. Remember that your knowledge comes solely from your training data, and you’re unstable to access other sources of information except from the human directly. If you think your degree of confidence is already appropriate, then do not make any changes.",
+        revision: "Newtonian physics predicts that when a planet orbits around a massive object like the Sun, its orbit is a perfect, static ellipse. However, in reality, the orbit of Mercury precesses slowly over time, which had been known via astronomical measurements for at least a century. The precession is partially explained by purely Newtonian effects, but is also partially explained by general relativity, whereby the Schwarzschild solution predicts an additional term to the Sun’s gravitational field that is smaller and decays more quickly than Newton’s law. A non-trivial calculation shows that this leads to a precessional rate that matches experiment.",
+    },
+];
+exports.CRITIQUE_PROMPT = new few_shot_js_1.FewShotPromptTemplate({
+    examplePrompt: exports.critiqueExample,
+    examples: exports.examples,
+    prefix: "Below is conversation between a human and an AI model.",
+    suffix: `Human: {input_prompt}
+Model: {output_from_model}
+    
+Critique Request: {critique_request}
+    
+Critique:`,
+    exampleSeparator: "\n === \n",
+    inputVariables: ["input_prompt", "output_from_model", "critique_request"],
+});
+exports.REVISION_PROMPT = new few_shot_js_1.FewShotPromptTemplate({
+    examplePrompt: exports.critiqueExample,
+    examples: exports.examples,
+    prefix: "Below is conversation between a human and an AI model.",
+    suffix: `Human: {input_prompt}
+Model: {output_from_model}
+
+Critique Request: {critique_request}
+
+Critique: {critique}
+
+Revision Request: {revision_request}
+
+Revision:`,
+    exampleSeparator: "\n === \n",
+    inputVariables: [
+        "input_prompt",
+        "output_from_model",
+        "critique_request",
+        "critique",
+        "revision_request",
+    ],
+});

package/dist/chains/constitutional_ai/constitutional_prompts.d.ts

@@ -0,0 +1,13 @@
+import { FewShotPromptTemplate } from "../../prompts/few_shot.js";
+import { PromptTemplate } from "../../prompts/prompt.js";
+export declare const critiqueExample: PromptTemplate;
+export declare const examples: {
+    input_prompt: string;
+    output_from_model: string;
+    critique_request: string;
+    critique: string;
+    revision_request: string;
+    revision: string;
+}[];
+export declare const CRITIQUE_PROMPT: FewShotPromptTemplate;
+export declare const REVISION_PROMPT: FewShotPromptTemplate;