@langchain/core 0.3.24 → 0.3.26

package/dist/messages/base.d.ts

@@ -23,7 +23,7 @@ export interface StoredMessageV1 {
     role: string | undefined;
     text: string;
 }
-export type MessageType = "human" | "ai" | "generic" | "system" | "function" | "tool" | "remove";
+export type MessageType = "human" | "ai" | "generic" | "developer" | "system" | "function" | "tool" | "remove";
 export type ImageDetail = "auto" | "low" | "high";
 export type MessageContentText = {
     type: "text";

package/dist/messages/transformers.cjs

@@ -292,6 +292,10 @@ const _MSG_CHUNK_MAP = {
         message: system_js_1.SystemMessage,
         messageChunk: system_js_1.SystemMessageChunk,
     },
+    developer: {
+        message: system_js_1.SystemMessage,
+        messageChunk: system_js_1.SystemMessageChunk,
+    },
     tool: {
         message: tool_js_1.ToolMessage,
         messageChunk: tool_js_1.ToolMessageChunk,
@@ -351,6 +355,26 @@ function _switchTypeToMessage(messageType, fields, returnChunk) {
                 msg = new system_js_1.SystemMessage(fields);
             }
             break;
+        case "developer":
+            if (returnChunk) {
+                chunk = new system_js_1.SystemMessageChunk({
+                    ...fields,
+                    additional_kwargs: {
+                        ...fields.additional_kwargs,
+                        __openai_role__: "developer",
+                    },
+                });
+            }
+            else {
+                msg = new system_js_1.SystemMessage({
+                    ...fields,
+                    additional_kwargs: {
+                        ...fields.additional_kwargs,
+                        __openai_role__: "developer",
+                    },
+                });
+            }
+            break;
         case "tool":
             if ("tool_call_id" in fields) {
                 if (returnChunk) {

package/dist/messages/transformers.js

@@ -286,6 +286,10 @@ const _MSG_CHUNK_MAP = {
         message: SystemMessage,
         messageChunk: SystemMessageChunk,
     },
+    developer: {
+        message: SystemMessage,
+        messageChunk: SystemMessageChunk,
+    },
     tool: {
         message: ToolMessage,
         messageChunk: ToolMessageChunk,
@@ -345,6 +349,26 @@ function _switchTypeToMessage(messageType, fields, returnChunk) {
                 msg = new SystemMessage(fields);
             }
             break;
+        case "developer":
+            if (returnChunk) {
+                chunk = new SystemMessageChunk({
+                    ...fields,
+                    additional_kwargs: {
+                        ...fields.additional_kwargs,
+                        __openai_role__: "developer",
+                    },
+                });
+            }
+            else {
+                msg = new SystemMessage({
+                    ...fields,
+                    additional_kwargs: {
+                        ...fields.additional_kwargs,
+                        __openai_role__: "developer",
+                    },
+                });
+            }
+            break;
         case "tool":
             if ("tool_call_id" in fields) {
                 if (returnChunk) {

package/dist/messages/utils.cjs

@@ -83,6 +83,15 @@ function _constructMessageFromParams(params) {
     else if (type === "system") {
         return new system_js_1.SystemMessage(rest);
     }
+    else if (type === "developer") {
+        return new system_js_1.SystemMessage({
+            ...rest,
+            additional_kwargs: {
+                ...rest.additional_kwargs,
+                __openai_role__: "developer",
+            },
+        });
+    }
     else if (type === "tool" && "tool_call_id" in rest) {
         return new tool_js_1.ToolMessage({
             ...rest,
@@ -92,7 +101,7 @@ function _constructMessageFromParams(params) {
         });
     }
     else {
-        const error = (0, index_js_1.addLangChainErrorFields)(new Error(`Unable to coerce message from array: only human, AI, system, or tool message coercion is currently supported.\n\nReceived: ${JSON.stringify(params, null, 2)}`), "MESSAGE_COERCION_FAILURE");
+        const error = (0, index_js_1.addLangChainErrorFields)(new Error(`Unable to coerce message from array: only human, AI, system, developer, or tool message coercion is currently supported.\n\nReceived: ${JSON.stringify(params, null, 2)}`), "MESSAGE_COERCION_FAILURE");
         throw error;
     }
 }

package/dist/messages/utils.js

@@ -80,6 +80,15 @@ function _constructMessageFromParams(params) {
     else if (type === "system") {
         return new SystemMessage(rest);
     }
+    else if (type === "developer") {
+        return new SystemMessage({
+            ...rest,
+            additional_kwargs: {
+                ...rest.additional_kwargs,
+                __openai_role__: "developer",
+            },
+        });
+    }
     else if (type === "tool" && "tool_call_id" in rest) {
         return new ToolMessage({
             ...rest,
@@ -89,7 +98,7 @@ function _constructMessageFromParams(params) {
         });
     }
     else {
-        const error = addLangChainErrorFields(new Error(`Unable to coerce message from array: only human, AI, system, or tool message coercion is currently supported.\n\nReceived: ${JSON.stringify(params, null, 2)}`), "MESSAGE_COERCION_FAILURE");
+        const error = addLangChainErrorFields(new Error(`Unable to coerce message from array: only human, AI, system, developer, or tool message coercion is currently supported.\n\nReceived: ${JSON.stringify(params, null, 2)}`), "MESSAGE_COERCION_FAILURE");
         throw error;
     }
 }

package/dist/runnables/base.cjs

@@ -1944,32 +1944,38 @@ class RunnableWithFallbacks extends Runnable {
     }
     async invoke(input, options) {
         const config = (0, config_js_1.ensureConfig)(options);
-        const callbackManager_ = await (0, config_js_1.getCallbackManagerForConfig)(options);
+        const callbackManager_ = await (0, config_js_1.getCallbackManagerForConfig)(config);
         const { runId, ...otherConfigFields } = config;
         const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), runId, undefined, undefined, undefined, otherConfigFields?.runName);
-        let firstError;
-        for (const runnable of this.runnables()) {
-            config?.signal?.throwIfAborted();
-            try {
-                const output = await runnable.invoke(input, (0, config_js_1.patchConfig)(otherConfigFields, { callbacks: runManager?.getChild() }));
-                await runManager?.handleChainEnd(_coerceToDict(output, "output"));
-                return output;
-            }
-            catch (e) {
-                if (firstError === undefined) {
-                    firstError = e;
+        const childConfig = (0, config_js_1.patchConfig)(otherConfigFields, {
+            callbacks: runManager?.getChild(),
+        });
+        const res = await index_js_1.AsyncLocalStorageProviderSingleton.runWithConfig(childConfig, async () => {
+            let firstError;
+            for (const runnable of this.runnables()) {
+                config?.signal?.throwIfAborted();
+                try {
+                    const output = await runnable.invoke(input, childConfig);
+                    await runManager?.handleChainEnd(_coerceToDict(output, "output"));
+                    return output;
+                }
+                catch (e) {
+                    if (firstError === undefined) {
+                        firstError = e;
+                    }
                 }
             }
-        }
-        if (firstError === undefined) {
-            throw new Error("No error stored at end of fallback.");
-        }
-        await runManager?.handleChainError(firstError);
-        throw firstError;
+            if (firstError === undefined) {
+                throw new Error("No error stored at end of fallback.");
+            }
+            await runManager?.handleChainError(firstError);
+            throw firstError;
+        });
+        return res;
     }
     async *_streamIterator(input, options) {
         const config = (0, config_js_1.ensureConfig)(options);
-        const callbackManager_ = await (0, config_js_1.getCallbackManagerForConfig)(options);
+        const callbackManager_ = await (0, config_js_1.getCallbackManagerForConfig)(config);
         const { runId, ...otherConfigFields } = config;
         const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), runId, undefined, undefined, undefined, otherConfigFields?.runName);
         let firstError;
@@ -1980,7 +1986,8 @@ class RunnableWithFallbacks extends Runnable {
                 callbacks: runManager?.getChild(),
             });
             try {
-                stream = await runnable.stream(input, childConfig);
+                const originalStream = await runnable.stream(input, childConfig);
+                stream = (0, iter_js_1.consumeAsyncIterableInContext)(childConfig, originalStream);
                 break;
             }
             catch (e) {

package/dist/runnables/base.js

@@ -1928,32 +1928,38 @@ export class RunnableWithFallbacks extends Runnable {
     }
     async invoke(input, options) {
         const config = ensureConfig(options);
-        const callbackManager_ = await getCallbackManagerForConfig(options);
+        const callbackManager_ = await getCallbackManagerForConfig(config);
         const { runId, ...otherConfigFields } = config;
         const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), runId, undefined, undefined, undefined, otherConfigFields?.runName);
-        let firstError;
-        for (const runnable of this.runnables()) {
-            config?.signal?.throwIfAborted();
-            try {
-                const output = await runnable.invoke(input, patchConfig(otherConfigFields, { callbacks: runManager?.getChild() }));
-                await runManager?.handleChainEnd(_coerceToDict(output, "output"));
-                return output;
-            }
-            catch (e) {
-                if (firstError === undefined) {
-                    firstError = e;
+        const childConfig = patchConfig(otherConfigFields, {
+            callbacks: runManager?.getChild(),
+        });
+        const res = await AsyncLocalStorageProviderSingleton.runWithConfig(childConfig, async () => {
+            let firstError;
+            for (const runnable of this.runnables()) {
+                config?.signal?.throwIfAborted();
+                try {
+                    const output = await runnable.invoke(input, childConfig);
+                    await runManager?.handleChainEnd(_coerceToDict(output, "output"));
+                    return output;
+                }
+                catch (e) {
+                    if (firstError === undefined) {
+                        firstError = e;
+                    }
                 }
             }
-        }
-        if (firstError === undefined) {
-            throw new Error("No error stored at end of fallback.");
-        }
-        await runManager?.handleChainError(firstError);
-        throw firstError;
+            if (firstError === undefined) {
+                throw new Error("No error stored at end of fallback.");
+            }
+            await runManager?.handleChainError(firstError);
+            throw firstError;
+        });
+        return res;
     }
     async *_streamIterator(input, options) {
         const config = ensureConfig(options);
-        const callbackManager_ = await getCallbackManagerForConfig(options);
+        const callbackManager_ = await getCallbackManagerForConfig(config);
         const { runId, ...otherConfigFields } = config;
         const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), runId, undefined, undefined, undefined, otherConfigFields?.runName);
         let firstError;
@@ -1964,7 +1970,8 @@ export class RunnableWithFallbacks extends Runnable {
                 callbacks: runManager?.getChild(),
             });
             try {
-                stream = await runnable.stream(input, childConfig);
+                const originalStream = await runnable.stream(input, childConfig);
+                stream = consumeAsyncIterableInContext(childConfig, originalStream);
                 break;
             }
             catch (e) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/core",
-  "version": "0.3.24",
+  "version": "0.3.26",
   "description": "Core LangChain.js abstractions and schemas",
   "type": "module",
   "engines": {