@langchain/core 0.2.0 → 0.2.1

package/dist/runnables/history.js

@@ -123,68 +123,123 @@ export class RunnableWithMessageHistory extends RunnableBinding {
         this.outputMessagesKey = fields.outputMessagesKey;
         this.historyMessagesKey = fields.historyMessagesKey;
     }
-    _getInputMessages(inputValue) {
-        if (typeof inputValue === "string") {
-            return [new HumanMessage(inputValue)];
+    _getInputMessages(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    inputValue) {
+        let parsedInputValue;
+        if (typeof inputValue === "object" &&
+            !Array.isArray(inputValue) &&
+            !isBaseMessage(inputValue)) {
+            let key;
+            if (this.inputMessagesKey) {
+                key = this.inputMessagesKey;
+            }
+            else if (Object.keys(inputValue).length === 1) {
+                key = Object.keys(inputValue)[0];
+            }
+            else {
+                key = "input";
+            }
+            if (Array.isArray(inputValue[key]) && Array.isArray(inputValue[key][0])) {
+                parsedInputValue = inputValue[key][0];
+            }
+            else {
+                parsedInputValue = inputValue[key];
+            }
+        }
+        else {
+            parsedInputValue = inputValue;
+        }
+        if (typeof parsedInputValue === "string") {
+            return [new HumanMessage(parsedInputValue)];
         }
-        else if (Array.isArray(inputValue)) {
-            return inputValue;
+        else if (Array.isArray(parsedInputValue)) {
+            return parsedInputValue;
+        }
+        else if (isBaseMessage(parsedInputValue)) {
+            return [parsedInputValue];
         }
         else {
-            return [inputValue];
+            throw new Error(`Expected a string, BaseMessage, or array of BaseMessages.\nGot ${JSON.stringify(parsedInputValue, null, 2)}`);
         }
     }
     _getOutputMessages(
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     outputValue) {
-        let newOutputValue = outputValue;
+        let parsedOutputValue;
         if (!Array.isArray(outputValue) &&
             !isBaseMessage(outputValue) &&
             typeof outputValue !== "string") {
-            newOutputValue = outputValue[this.outputMessagesKey ?? "output"];
+            let key;
+            if (this.outputMessagesKey !== undefined) {
+                key = this.outputMessagesKey;
+            }
+            else if (Object.keys(outputValue).length === 1) {
+                key = Object.keys(outputValue)[0];
+            }
+            else {
+                key = "output";
+            }
+            // If you are wrapping a chat model directly
+            // The output is actually this weird generations object
+            if (outputValue.generations !== undefined) {
+                parsedOutputValue = outputValue.generations[0][0].message;
+            }
+            else {
+                parsedOutputValue = outputValue[key];
+            }
+        }
+        else {
+            parsedOutputValue = outputValue;
         }
-        if (typeof newOutputValue === "string") {
-            return [new AIMessage(newOutputValue)];
+        if (typeof parsedOutputValue === "string") {
+            return [new AIMessage(parsedOutputValue)];
         }
-        else if (Array.isArray(newOutputValue)) {
-            return newOutputValue;
+        else if (Array.isArray(parsedOutputValue)) {
+            return parsedOutputValue;
         }
-        else if (isBaseMessage(newOutputValue)) {
-            return [newOutputValue];
+        else if (isBaseMessage(parsedOutputValue)) {
+            return [parsedOutputValue];
+        }
+        else {
+            throw new Error(`Expected a string, BaseMessage, or array of BaseMessages. Received: ${JSON.stringify(parsedOutputValue, null, 2)}`);
         }
-        throw new Error(`Expected a string, BaseMessage, or array of BaseMessages. Received: ${JSON.stringify(newOutputValue, null, 2)}`);
     }
     async _enterHistory(
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     input, kwargs) {
         const history = kwargs?.config?.configurable?.messageHistory;
-        if (this.historyMessagesKey) {
-            return history.getMessages();
-        }
-        const inputVal = input ||
-            (this.inputMessagesKey ? input[this.inputMessagesKey] : undefined);
-        const historyMessages = history ? await history.getMessages() : [];
-        const returnType = [
-            ...historyMessages,
-            ...this._getInputMessages(inputVal),
-        ];
-        return returnType;
+        const messages = await history.getMessages();
+        if (this.historyMessagesKey === undefined) {
+            return messages.concat(this._getInputMessages(input));
+        }
+        return messages;
     }
     async _exitHistory(run, config) {
         const history = config.configurable?.messageHistory;
         // Get input messages
-        const { inputs } = run;
-        const inputValue = inputs[this.inputMessagesKey ?? "input"];
-        const inputMessages = this._getInputMessages(inputValue);
+        let inputs;
+        // Chat model inputs are nested arrays
+        if (Array.isArray(run.inputs) && Array.isArray(run.inputs[0])) {
+            inputs = run.inputs[0];
+        }
+        else {
+            inputs = run.inputs;
+        }
+        let inputMessages = this._getInputMessages(inputs);
+        // If historic messages were prepended to the input messages, remove them to
+        // avoid adding duplicate messages to history.
+        if (this.historyMessagesKey === undefined) {
+            const existingMessages = await history.getMessages();
+            inputMessages = inputMessages.slice(existingMessages.length);
+        }
         // Get output messages
         const outputValue = run.outputs;
         if (!outputValue) {
             throw new Error(`Output values from 'Run' undefined. Run: ${JSON.stringify(run, null, 2)}`);
         }
         const outputMessages = this._getOutputMessages(outputValue);
-        for await (const message of [...inputMessages, ...outputMessages]) {
-            await history.addMessage(message);
-        }
+        await history.addMessages([...inputMessages, ...outputMessages]);
     }
     async _mergeConfig(...configs) {
         const config = await super._mergeConfig(...configs);

package/dist/runnables/remote.cjs

@@ -461,8 +461,8 @@ class RemoteRunnable extends base_js_1.Runnable {
         return generator();
     }
     streamEvents(input, options, streamOptions) {
-        if (options?.version !== "v1") {
-            throw new Error(`Only version "v1" of the events schema is currently supported.`);
+        if (options.version !== "v1" && options.version !== "v2") {
+            throw new Error(`Only versions "v1" and "v2" of the events schema is currently supported.`);
         }
         if (options.encoding !== undefined) {
             throw new Error("Special encodings are not supported for this runnable.");

package/dist/runnables/remote.d.ts

@@ -29,13 +29,13 @@ export declare class RemoteRunnable<RunInput, RunOutput, CallOptions extends Run
     _streamIterator(input: RunInput, options?: Partial<CallOptions>): AsyncGenerator<RunOutput>;
     streamLog(input: RunInput, options?: Partial<CallOptions>, streamOptions?: Omit<LogStreamCallbackHandlerInput, "autoClose">): AsyncGenerator<RunLogPatch>;
     _streamEvents(input: RunInput, options: Partial<CallOptions> & {
-        version: "v1";
+        version: "v1" | "v2";
     }, streamOptions?: Omit<LogStreamCallbackHandlerInput, "autoClose"> | undefined): AsyncGenerator<StreamEvent>;
     streamEvents(input: RunInput, options: Partial<CallOptions> & {
-        version: "v1";
+        version: "v1" | "v2";
     }, streamOptions?: Omit<LogStreamCallbackHandlerInput, "autoClose">): IterableReadableStream<StreamEvent>;
     streamEvents(input: RunInput, options: Partial<CallOptions> & {
-        version: "v1";
+        version: "v1" | "v2";
         encoding: "text/event-stream";
     }, streamOptions?: Omit<LogStreamCallbackHandlerInput, "autoClose">): IterableReadableStream<Uint8Array>;
 }

package/dist/runnables/remote.js

@@ -458,8 +458,8 @@ export class RemoteRunnable extends Runnable {
         return generator();
     }
     streamEvents(input, options, streamOptions) {
-        if (options?.version !== "v1") {
-            throw new Error(`Only version "v1" of the events schema is currently supported.`);
+        if (options.version !== "v1" && options.version !== "v2") {
+            throw new Error(`Only versions "v1" and "v2" of the events schema is currently supported.`);
         }
         if (options.encoding !== undefined) {
             throw new Error("Special encodings are not supported for this runnable.");

package/dist/runnables/tests/runnable.test.d.ts

@@ -0,0 +1 @@
+export {};