@langchain/core 0.2.14 → 0.2.16

package/dist/runnables/base.d.ts

@@ -1,3 +1,4 @@
+import { z } from "zod";
 import { type TraceableFunction } from "langsmith/singletons/traceable";
 import type { RunnableInterface, RunnableBatchOptions } from "./types.js";
 import { CallbackManagerForChainRun } from "../callbacks/manager.js";
@@ -10,8 +11,10 @@ import { Run } from "../tracers/base.js";
 import { Graph } from "./graph.js";
 export { type RunnableInterface, RunnableBatchOptions };
 export type RunnableFunc<RunInput, RunOutput> = (input: RunInput, options?: ({
+    /** @deprecated Use top-level config fields instead. */
     config?: RunnableConfig;
 } & RunnableConfig) | Record<string, any> | (Record<string, any> & {
+    /** @deprecated Use top-level config fields instead. */
     config: RunnableConfig;
 } & RunnableConfig)) => RunOutput | Promise<RunOutput>;
 export type RunnableMapLike<RunInput, RunOutput> = {
@@ -243,6 +246,23 @@ export declare abstract class Runnable<RunInput = any, RunOutput = any, CallOpti
         onEnd?: (run: Run, config?: RunnableConfig) => void | Promise<void>;
         onError?: (run: Run, config?: RunnableConfig) => void | Promise<void>;
     }): Runnable<RunInput, RunOutput, CallOptions>;
+    /**
+     * Convert a runnable to a tool. Return a new instance of `RunnableToolLike`
+     * which contains the runnable, name, description and schema.
+     *
+     * @template {T extends RunInput = RunInput} RunInput - The input type of the runnable. Should be the same as the `RunInput` type of the runnable.
+     *
+     * @param fields
+     * @param {string | undefined} [fields.name] The name of the tool. If not provided, it will default to the name of the runnable.
+     * @param {string | undefined} [fields.description] The description of the tool. Falls back to the description on the Zod schema if not provided, or undefined if neither are provided.
+     * @param {z.ZodType<T>} [fields.schema] The Zod schema for the input of the tool. Infers the Zod type from the input type of the runnable.
+     * @returns {RunnableToolLike<z.ZodType<T>, RunOutput>} An instance of `RunnableToolLike` which is a runnable that can be used as a tool.
+     */
+    asTool<T extends RunInput = RunInput>(fields: {
+        name?: string;
+        description?: string;
+        schema: z.ZodType<T>;
+    }): RunnableToolLike<z.ZodType<T>, RunOutput>;
 }
 export type RunnableBindingArgs<RunInput, RunOutput, CallOptions extends RunnableConfig = RunnableConfig> = {
     bound: Runnable<RunInput, RunOutput, CallOptions>;
@@ -558,3 +578,34 @@ export declare class RunnablePick<RunInput extends Record<string, any> = Record<
     transform(generator: AsyncGenerator<RunInput>, options?: Partial<RunnableConfig>): AsyncGenerator<RunOutput>;
     stream(input: RunInput, options?: Partial<RunnableConfig>): Promise<IterableReadableStream<RunOutput>>;
 }
+export interface RunnableToolLikeArgs<RunInput extends z.ZodType = z.ZodType, RunOutput = unknown> extends Omit<RunnableBindingArgs<z.infer<RunInput>, RunOutput>, "config"> {
+    name: string;
+    description?: string;
+    schema: RunInput;
+    config?: RunnableConfig;
+}
+export declare class RunnableToolLike<RunInput extends z.ZodType = z.ZodType, RunOutput = unknown> extends RunnableBinding<z.infer<RunInput>, RunOutput> {
+    name: string;
+    description?: string;
+    schema: RunInput;
+    constructor(fields: RunnableToolLikeArgs<RunInput, RunOutput>);
+    static lc_name(): string;
+}
+/**
+ * Given a runnable and a Zod schema, convert the runnable to a tool.
+ *
+ * @template RunInput The input type for the runnable.
+ * @template RunOutput The output type for the runnable.
+ *
+ * @param {Runnable<RunInput, RunOutput>} runnable The runnable to convert to a tool.
+ * @param fields
+ * @param {string | undefined} [fields.name] The name of the tool. If not provided, it will default to the name of the runnable.
+ * @param {string | undefined} [fields.description] The description of the tool. Falls back to the description on the Zod schema if not provided, or undefined if neither are provided.
+ * @param {z.ZodType<RunInput>} [fields.schema] The Zod schema for the input of the tool. Infers the Zod type from the input type of the runnable.
+ * @returns {RunnableToolLike<z.ZodType<RunInput>, RunOutput>} An instance of `RunnableToolLike` which is a runnable that can be used as a tool.
+ */
+export declare function convertRunnableToTool<RunInput, RunOutput>(runnable: Runnable<RunInput, RunOutput>, fields: {
+    name?: string;
+    description?: string;
+    schema: z.ZodType<RunInput>;
+}): RunnableToolLike<z.ZodType<RunInput>, RunOutput>;

package/dist/runnables/base.js

@@ -2,7 +2,6 @@ import { z } from "zod";
 import pRetry from "p-retry";
 import { v4 as uuidv4 } from "uuid";
 import { isTraceableFunction, } from "langsmith/singletons/traceable";
-import { CallbackManager, } from "../callbacks/manager.js";
 import { LogStreamCallbackHandler, RunLog, RunLogPatch, isLogStreamHandler, } from "../tracers/log_stream.js";
 import { EventStreamCallbackHandler, isStreamEventsHandler, } from "../tracers/event_stream.js";
 import { Serializable } from "../load/serializable.js";
@@ -712,6 +711,21 @@ export class Runnable extends Serializable {
             ],
         });
     }
+    /**
+     * Convert a runnable to a tool. Return a new instance of `RunnableToolLike`
+     * which contains the runnable, name, description and schema.
+     *
+     * @template {T extends RunInput = RunInput} RunInput - The input type of the runnable. Should be the same as the `RunInput` type of the runnable.
+     *
+     * @param fields
+     * @param {string | undefined} [fields.name] The name of the tool. If not provided, it will default to the name of the runnable.
+     * @param {string | undefined} [fields.description] The description of the tool. Falls back to the description on the Zod schema if not provided, or undefined if neither are provided.
+     * @param {z.ZodType<T>} [fields.schema] The Zod schema for the input of the tool. Infers the Zod type from the input type of the runnable.
+     * @returns {RunnableToolLike<z.ZodType<T>, RunOutput>} An instance of `RunnableToolLike` which is a runnable that can be used as a tool.
+     */
+    asTool(fields) {
+        return convertRunnableToTool(this, fields);
+    }
 }
 /**
  * A runnable that delegates calls to another runnable with a set of kwargs.
@@ -1560,12 +1574,16 @@ export class RunnableLambda extends Runnable {
                 }
             }
         }
+        const childConfig = patchConfig(config, {
+            callbacks: runManager?.getChild(),
+            recursionLimit: (config?.recursionLimit ?? DEFAULT_RECURSION_LIMIT) - 1,
+        });
         const output = await new Promise((resolve, reject) => {
-            void AsyncLocalStorageProviderSingleton.getInstance().run(config, async () => {
+            void AsyncLocalStorageProviderSingleton.getInstance().run(childConfig, async () => {
                 try {
                     const res = await this.func(finalChunk, {
-                        ...config,
-                        config,
+                        ...childConfig,
+                        config: childConfig,
                     });
                     resolve(res);
                 }
@@ -1578,21 +1596,18 @@ export class RunnableLambda extends Runnable {
             if (config?.recursionLimit === 0) {
                 throw new Error("Recursion limit reached.");
             }
-            const stream = await output.stream(finalChunk, patchConfig(config, {
-                callbacks: runManager?.getChild(),
-                recursionLimit: (config?.recursionLimit ?? DEFAULT_RECURSION_LIMIT) - 1,
-            }));
+            const stream = await output.stream(finalChunk, childConfig);
             for await (const chunk of stream) {
                 yield chunk;
             }
         }
         else if (isAsyncIterable(output)) {
-            for await (const chunk of consumeAsyncIterableInContext(config, output)) {
+            for await (const chunk of consumeAsyncIterableInContext(childConfig, output)) {
                 yield chunk;
             }
         }
         else if (isIterableIterator(output)) {
-            for (const chunk of consumeIteratorInContext(config, output)) {
+            for (const chunk of consumeIteratorInContext(childConfig, output)) {
                 yield chunk;
             }
         }
@@ -1661,13 +1676,14 @@ export class RunnableWithFallbacks extends Runnable {
         }
     }
     async invoke(input, options) {
-        const callbackManager_ = await CallbackManager.configure(options?.callbacks, undefined, options?.tags, undefined, options?.metadata);
-        const { runId, ...otherOptions } = options ?? {};
-        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), runId, undefined, undefined, undefined, otherOptions?.runName);
+        const config = ensureConfig(options);
+        const callbackManager_ = await getCallbackManagerForConfig(options);
+        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()) {
             try {
-                const output = await runnable.invoke(input, patchConfig(otherOptions, { callbacks: runManager?.getChild() }));
+                const output = await runnable.invoke(input, patchConfig(otherConfigFields, { callbacks: runManager?.getChild() }));
                 await runManager?.handleChainEnd(_coerceToDict(output, "output"));
                 return output;
             }
@@ -1688,7 +1704,7 @@ export class RunnableWithFallbacks extends Runnable {
             throw new Error("Not implemented.");
         }
         const configList = this._getOptionsList(options ?? {}, inputs.length);
-        const callbackManagers = await Promise.all(configList.map((config) => CallbackManager.configure(config?.callbacks, undefined, config?.tags, undefined, config?.metadata)));
+        const callbackManagers = await Promise.all(configList.map((config) => getCallbackManagerForConfig(config)));
         const runManagers = await Promise.all(callbackManagers.map(async (callbackManager, i) => {
             const handleStartRes = await callbackManager?.handleChainStart(this.toJSON(), _coerceToDict(inputs[i], "input"), configList[i].runId, undefined, undefined, undefined, configList[i].runName);
             delete configList[i].runId;
@@ -1891,3 +1907,58 @@ export class RunnablePick extends Runnable {
         return IterableReadableStream.fromAsyncGenerator(wrappedGenerator);
     }
 }
+export class RunnableToolLike extends RunnableBinding {
+    constructor(fields) {
+        super({
+            bound: fields.bound,
+            config: fields.config ?? {},
+        });
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "description", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "schema", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.name = fields.name;
+        this.description = fields.description;
+        this.schema = fields.schema;
+    }
+    static lc_name() {
+        return "RunnableToolLike";
+    }
+}
+/**
+ * Given a runnable and a Zod schema, convert the runnable to a tool.
+ *
+ * @template RunInput The input type for the runnable.
+ * @template RunOutput The output type for the runnable.
+ *
+ * @param {Runnable<RunInput, RunOutput>} runnable The runnable to convert to a tool.
+ * @param fields
+ * @param {string | undefined} [fields.name] The name of the tool. If not provided, it will default to the name of the runnable.
+ * @param {string | undefined} [fields.description] The description of the tool. Falls back to the description on the Zod schema if not provided, or undefined if neither are provided.
+ * @param {z.ZodType<RunInput>} [fields.schema] The Zod schema for the input of the tool. Infers the Zod type from the input type of the runnable.
+ * @returns {RunnableToolLike<z.ZodType<RunInput>, RunOutput>} An instance of `RunnableToolLike` which is a runnable that can be used as a tool.
+ */
+export function convertRunnableToTool(runnable, fields) {
+    const name = fields.name ?? runnable.getName();
+    const description = fields.description ?? fields.schema.description;
+    return new RunnableToolLike({
+        name,
+        description,
+        schema: fields.schema,
+        bound: runnable,
+    });
+}

package/dist/runnables/config.cjs

@@ -89,25 +89,47 @@ const PRIMITIVES = new Set(["string", "number", "boolean"]);
  * should not be called with a default or prepopulated config argument.
  */
 function ensureConfig(config) {
-    const loadedConfig = config ?? index_js_1.AsyncLocalStorageProviderSingleton.getInstance().getStore();
+    const implicitConfig = index_js_1.AsyncLocalStorageProviderSingleton.getInstance().getStore();
     let empty = {
         tags: [],
         metadata: {},
-        callbacks: undefined,
         recursionLimit: 25,
         runId: undefined,
     };
-    if (loadedConfig) {
-        empty = { ...empty, ...loadedConfig };
+    if (implicitConfig) {
+        // Don't allow runId to be loaded implicitly, as this can cause
+        // child runs to improperly inherit their parents' run ids.
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const { runId, ...rest } = implicitConfig;
+        empty = Object.entries(rest).reduce(
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (currentConfig, [key, value]) => {
+            if (value !== undefined) {
+                // eslint-disable-next-line no-param-reassign
+                currentConfig[key] = value;
+            }
+            return currentConfig;
+        }, empty);
+    }
+    if (config) {
+        empty = Object.entries(config).reduce(
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (currentConfig, [key, value]) => {
+            if (value !== undefined) {
+                // eslint-disable-next-line no-param-reassign
+                currentConfig[key] = value;
+            }
+            return currentConfig;
+        }, empty);
     }
-    if (loadedConfig?.configurable) {
-        for (const key of Object.keys(loadedConfig.configurable)) {
-            if (PRIMITIVES.has(typeof loadedConfig.configurable[key]) &&
+    if (empty?.configurable) {
+        for (const key of Object.keys(empty.configurable)) {
+            if (PRIMITIVES.has(typeof empty.configurable[key]) &&
                 !empty.metadata?.[key]) {
                 if (!empty.metadata) {
                     empty.metadata = {};
                 }
-                empty.metadata[key] = loadedConfig.configurable[key];
+                empty.metadata[key] = empty.configurable[key];
             }
         }
     }

package/dist/runnables/config.js

@@ -84,25 +84,47 @@ const PRIMITIVES = new Set(["string", "number", "boolean"]);
  * should not be called with a default or prepopulated config argument.
  */
 export function ensureConfig(config) {
-    const loadedConfig = config ?? AsyncLocalStorageProviderSingleton.getInstance().getStore();
+    const implicitConfig = AsyncLocalStorageProviderSingleton.getInstance().getStore();
     let empty = {
         tags: [],
         metadata: {},
-        callbacks: undefined,
         recursionLimit: 25,
         runId: undefined,
     };
-    if (loadedConfig) {
-        empty = { ...empty, ...loadedConfig };
+    if (implicitConfig) {
+        // Don't allow runId to be loaded implicitly, as this can cause
+        // child runs to improperly inherit their parents' run ids.
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const { runId, ...rest } = implicitConfig;
+        empty = Object.entries(rest).reduce(
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (currentConfig, [key, value]) => {
+            if (value !== undefined) {
+                // eslint-disable-next-line no-param-reassign
+                currentConfig[key] = value;
+            }
+            return currentConfig;
+        }, empty);
+    }
+    if (config) {
+        empty = Object.entries(config).reduce(
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (currentConfig, [key, value]) => {
+            if (value !== undefined) {
+                // eslint-disable-next-line no-param-reassign
+                currentConfig[key] = value;
+            }
+            return currentConfig;
+        }, empty);
     }
-    if (loadedConfig?.configurable) {
-        for (const key of Object.keys(loadedConfig.configurable)) {
-            if (PRIMITIVES.has(typeof loadedConfig.configurable[key]) &&
+    if (empty?.configurable) {
+        for (const key of Object.keys(empty.configurable)) {
+            if (PRIMITIVES.has(typeof empty.configurable[key]) &&
                 !empty.metadata?.[key]) {
                 if (!empty.metadata) {
                     empty.metadata = {};
                 }
-                empty.metadata[key] = loadedConfig.configurable[key];
+                empty.metadata[key] = empty.configurable[key];
             }
         }
     }

package/dist/runnables/history.cjs

@@ -211,7 +211,7 @@ class RunnableWithMessageHistory extends base_js_1.RunnableBinding {
     async _enterHistory(
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     input, kwargs) {
-        const history = kwargs?.config?.configurable?.messageHistory;
+        const history = kwargs?.configurable?.messageHistory;
         const messages = await history.getMessages();
         if (this.historyMessagesKey === undefined) {
             return messages.concat(this._getInputMessages(input));

package/dist/runnables/history.d.ts

@@ -85,9 +85,7 @@ export declare class RunnableWithMessageHistory<RunInput, RunOutput> extends Run
     constructor(fields: RunnableWithMessageHistoryInputs<RunInput, RunOutput>);
     _getInputMessages(inputValue: string | BaseMessage | Array<BaseMessage> | Record<string, any>): Array<BaseMessage>;
     _getOutputMessages(outputValue: string | BaseMessage | Array<BaseMessage> | Record<string, any>): Array<BaseMessage>;
-    _enterHistory(input: any, kwargs?: {
-        config?: RunnableConfig;
-    }): Promise<BaseMessage[]>;
+    _enterHistory(input: any, kwargs?: RunnableConfig): Promise<BaseMessage[]>;
     _exitHistory(run: Run, config: RunnableConfig): Promise<void>;
     _mergeConfig(...configs: Array<RunnableConfig | undefined>): Promise<Partial<RunnableConfig>>;
 }

package/dist/runnables/history.js

@@ -208,7 +208,7 @@ export class RunnableWithMessageHistory extends RunnableBinding {
     async _enterHistory(
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     input, kwargs) {
-        const history = kwargs?.config?.configurable?.messageHistory;
+        const history = kwargs?.configurable?.messageHistory;
         const messages = await history.getMessages();
         if (this.historyMessagesKey === undefined) {
             return messages.concat(this._getInputMessages(input));

package/dist/runnables/index.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RunnableWithMessageHistory = exports.RunnableBranch = exports.RouterRunnable = exports.RunnablePassthrough = exports.mergeConfigs = exports.ensureConfig = exports.patchConfig = exports.getCallbackManagerForConfig = exports._coerceToRunnable = exports.RunnablePick = exports.RunnableAssign = exports.RunnableWithFallbacks = exports.RunnableLambda = exports.RunnableParallel = exports.RunnableMap = exports.RunnableSequence = exports.RunnableRetry = exports.RunnableEach = exports.RunnableBinding = exports.Runnable = void 0;
+exports.RunnableWithMessageHistory = exports.RunnableBranch = exports.RouterRunnable = exports.RunnablePassthrough = exports.mergeConfigs = exports.ensureConfig = exports.patchConfig = exports.getCallbackManagerForConfig = exports.RunnableToolLike = exports._coerceToRunnable = exports.RunnablePick = exports.RunnableAssign = exports.RunnableWithFallbacks = exports.RunnableLambda = exports.RunnableParallel = exports.RunnableMap = exports.RunnableSequence = exports.RunnableRetry = exports.RunnableEach = exports.RunnableBinding = exports.Runnable = void 0;
 var base_js_1 = require("./base.cjs");
 Object.defineProperty(exports, "Runnable", { enumerable: true, get: function () { return base_js_1.Runnable; } });
 Object.defineProperty(exports, "RunnableBinding", { enumerable: true, get: function () { return base_js_1.RunnableBinding; } });
@@ -14,6 +14,7 @@ Object.defineProperty(exports, "RunnableWithFallbacks", { enumerable: true, get:
 Object.defineProperty(exports, "RunnableAssign", { enumerable: true, get: function () { return base_js_1.RunnableAssign; } });
 Object.defineProperty(exports, "RunnablePick", { enumerable: true, get: function () { return base_js_1.RunnablePick; } });
 Object.defineProperty(exports, "_coerceToRunnable", { enumerable: true, get: function () { return base_js_1._coerceToRunnable; } });
+Object.defineProperty(exports, "RunnableToolLike", { enumerable: true, get: function () { return base_js_1.RunnableToolLike; } });
 var config_js_1 = require("./config.cjs");
 Object.defineProperty(exports, "getCallbackManagerForConfig", { enumerable: true, get: function () { return config_js_1.getCallbackManagerForConfig; } });
 Object.defineProperty(exports, "patchConfig", { enumerable: true, get: function () { return config_js_1.patchConfig; } });

package/dist/runnables/index.d.ts

@@ -1,4 +1,4 @@
-export { type RunnableFunc, type RunnableLike, type RunnableRetryFailedAttemptHandler, Runnable, type RunnableBindingArgs, RunnableBinding, RunnableEach, RunnableRetry, RunnableSequence, RunnableMap, RunnableParallel, RunnableLambda, RunnableWithFallbacks, RunnableAssign, RunnablePick, _coerceToRunnable, } from "./base.js";
+export { type RunnableFunc, type RunnableLike, type RunnableRetryFailedAttemptHandler, Runnable, type RunnableBindingArgs, RunnableBinding, RunnableEach, RunnableRetry, RunnableSequence, RunnableMap, RunnableParallel, RunnableLambda, RunnableWithFallbacks, RunnableAssign, RunnablePick, _coerceToRunnable, RunnableToolLike, type RunnableToolLikeArgs, } from "./base.js";
 export { type RunnableBatchOptions, type RunnableInterface, type RunnableIOSchema, } from "./types.js";
 export { type RunnableConfig, getCallbackManagerForConfig, patchConfig, ensureConfig, mergeConfigs, } from "./config.js";
 export { RunnablePassthrough } from "./passthrough.js";

package/dist/runnables/index.js

@@ -1,4 +1,4 @@
-export { Runnable, RunnableBinding, RunnableEach, RunnableRetry, RunnableSequence, RunnableMap, RunnableParallel, RunnableLambda, RunnableWithFallbacks, RunnableAssign, RunnablePick, _coerceToRunnable, } from "./base.js";
+export { Runnable, RunnableBinding, RunnableEach, RunnableRetry, RunnableSequence, RunnableMap, RunnableParallel, RunnableLambda, RunnableWithFallbacks, RunnableAssign, RunnablePick, _coerceToRunnable, RunnableToolLike, } from "./base.js";
 export { getCallbackManagerForConfig, patchConfig, ensureConfig, mergeConfigs, } from "./config.js";
 export { RunnablePassthrough } from "./passthrough.js";
 export { RouterRunnable } from "./router.js";

package/dist/runnables/tests/runnable.test.js

@@ -373,19 +373,19 @@ test("Create a runnable sequence with a static method with invalid output and ca
 test("RunnableSequence can pass config to every step in batched request", async () => {
     let numSeen = 0;
     const addOne = (x, options) => {
-        if (options?.config?.configurable?.isPresent === true) {
+        if (options?.configurable?.isPresent === true) {
             numSeen += 1;
         }
         return x + 1;
     };
     const addTwo = (x, options) => {
-        if (options?.config?.configurable?.isPresent === true) {
+        if (options?.configurable?.isPresent === true) {
             numSeen += 1;
         }
         return x + 2;
     };
     const addThree = (x, options) => {
-        if (options?.config?.configurable?.isPresent === true) {
+        if (options?.configurable?.isPresent === true) {
             numSeen += 1;
         }
         return x + 3;

package/dist/runnables/tests/runnable_stream_events.test.js

@@ -8,7 +8,7 @@ import { ChatPromptTemplate } from "../../prompts/chat.js";
 import { FakeListChatModel, FakeRetriever, FakeStreamingLLM, } from "../../utils/testing/index.js";
 import { AIMessageChunk, HumanMessage, SystemMessage, } from "../../messages/index.js";
 import { ChatGenerationChunk, GenerationChunk } from "../../outputs.js";
-import { DynamicStructuredTool, DynamicTool } from "../../tools.js";
+import { DynamicStructuredTool, DynamicTool } from "../../tools/index.js";
 import { Document } from "../../documents/document.js";
 function reverse(s) {
     // Reverse a string.