langchain 0.0.133 → 0.0.135

package/dist/document_loaders/web/recursive_url.js

@@ -0,0 +1,173 @@
+import { JSDOM } from "jsdom";
+import { AsyncCaller } from "../../util/async_caller.js";
+import { BaseDocumentLoader } from "../base.js";
+export class RecursiveUrlLoader extends BaseDocumentLoader {
+    constructor(url, options) {
+        super();
+        Object.defineProperty(this, "caller", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "url", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "excludeDirs", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "extractor", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "maxDepth", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "timeout", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "preventOutside", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.caller = new AsyncCaller({
+            maxConcurrency: 64,
+            maxRetries: 0,
+            ...options.callerOptions,
+        });
+        this.url = url;
+        this.excludeDirs = options.excludeDirs ?? [];
+        this.extractor = options.extractor ?? ((s) => s);
+        this.maxDepth = options.maxDepth ?? 2;
+        this.timeout = options.timeout ?? 10000;
+        this.preventOutside = options.preventOutside ?? true;
+    }
+    async fetchWithTimeout(resource, options) {
+        const { timeout, ...rest } = options;
+        return this.caller.call(() => fetch(resource, { ...rest, signal: AbortSignal.timeout(timeout) }));
+    }
+    getChildLinks(html, baseUrl) {
+        const allLinks = Array.from(new JSDOM(html).window.document.querySelectorAll("a")).map((a) => a.href);
+        const absolutePaths = [];
+        // eslint-disable-next-line no-script-url
+        const invalidPrefixes = ["javascript:", "mailto:", "#"];
+        const invalidSuffixes = [
+            ".css",
+            ".js",
+            ".ico",
+            ".png",
+            ".jpg",
+            ".jpeg",
+            ".gif",
+            ".svg",
+        ];
+        for (const link of allLinks) {
+            if (invalidPrefixes.some((prefix) => link.startsWith(prefix)) ||
+                invalidSuffixes.some((suffix) => link.endsWith(suffix)))
+                continue;
+            if (link.startsWith("http")) {
+                const isAllowed = !this.preventOutside || link.startsWith(baseUrl);
+                if (isAllowed)
+                    absolutePaths.push(link);
+            }
+            else if (link.startsWith("//")) {
+                const base = new URL(baseUrl);
+                absolutePaths.push(base.protocol + link);
+            }
+            else {
+                const newLink = new URL(link, baseUrl).href;
+                absolutePaths.push(newLink);
+            }
+        }
+        return Array.from(new Set(absolutePaths));
+    }
+    extractMetadata(rawHtml, url) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const metadata = { source: url };
+        const { document } = new JSDOM(rawHtml).window;
+        const title = document.getElementsByTagName("title")[0];
+        if (title) {
+            metadata.title = title.textContent;
+        }
+        const description = document.querySelector("meta[name=description]");
+        if (description) {
+            metadata.description = description.getAttribute("content");
+        }
+        const html = document.getElementsByTagName("html")[0];
+        if (html) {
+            metadata.language = html.getAttribute("lang");
+        }
+        return metadata;
+    }
+    async getUrlAsDoc(url) {
+        let res;
+        try {
+            res = await this.fetchWithTimeout(url, { timeout: this.timeout });
+            res = await res.text();
+        }
+        catch (e) {
+            return null;
+        }
+        return {
+            pageContent: this.extractor(res),
+            metadata: this.extractMetadata(res, url),
+        };
+    }
+    async getChildUrlsRecursive(inputUrl, visited = new Set(), depth = 0) {
+        if (depth > this.maxDepth)
+            return [];
+        let url = inputUrl;
+        if (!inputUrl.endsWith("/"))
+            url += "/";
+        const isExcluded = this.excludeDirs.some((exDir) => url.startsWith(exDir));
+        if (isExcluded)
+            return [];
+        let res;
+        try {
+            res = await this.fetchWithTimeout(url, { timeout: this.timeout });
+            res = await res.text();
+        }
+        catch (e) {
+            return [];
+        }
+        const childUrls = this.getChildLinks(res, url);
+        const results = await Promise.all(childUrls.map((childUrl) => (async () => {
+            if (visited.has(childUrl))
+                return null;
+            visited.add(childUrl);
+            const childDoc = await this.getUrlAsDoc(childUrl);
+            if (!childDoc)
+                return null;
+            if (childUrl.endsWith("/")) {
+                const childUrlResponses = await this.getChildUrlsRecursive(childUrl, visited, depth + 1);
+                return [childDoc, ...childUrlResponses];
+            }
+            return [childDoc];
+        })()));
+        return results.flat().filter((docs) => docs !== null);
+    }
+    async load() {
+        const rootDoc = await this.getUrlAsDoc(this.url);
+        if (!rootDoc)
+            return [];
+        const docs = [rootDoc];
+        docs.push(...(await this.getChildUrlsRecursive(this.url, new Set([this.url]))));
+        return docs;
+    }
+}

package/dist/hub.cjs

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pull = exports.push = void 0;
+const langchainhub_1 = require("langchainhub");
+const index_js_1 = require("./load/index.cjs");
+async function push(repoFullName, runnable, options) {
+    const client = new langchainhub_1.Client(options);
+    return client.push(repoFullName, JSON.stringify(runnable), options);
+}
+exports.push = push;
+async function pull(ownerRepoCommit, options) {
+    const client = new langchainhub_1.Client(options);
+    const result = await client.pull(ownerRepoCommit);
+    return (0, index_js_1.load)(result);
+}
+exports.pull = pull;

package/dist/hub.d.ts

@@ -0,0 +1,4 @@
+import { ClientConfiguration, HubPushOptions } from "langchainhub";
+import { Runnable } from "./schema/runnable.js";
+export declare function push(repoFullName: string, runnable: Runnable, options?: HubPushOptions & ClientConfiguration): Promise<any>;
+export declare function pull<T extends Runnable>(ownerRepoCommit: string, options?: ClientConfiguration): Promise<T>;

package/dist/hub.js

@@ -0,0 +1,11 @@
+import { Client } from "langchainhub";
+import { load } from "./load/index.js";
+export async function push(repoFullName, runnable, options) {
+    const client = new Client(options);
+    return client.push(repoFullName, JSON.stringify(runnable), options);
+}
+export async function pull(ownerRepoCommit, options) {
+    const client = new Client(options);
+    const result = await client.pull(ownerRepoCommit);
+    return load(result);
+}

package/dist/llms/bedrock.cjs

@@ -4,9 +4,12 @@ exports.Bedrock = void 0;
 const signature_v4_1 = require("@aws-sdk/signature-v4");
 const credential_provider_node_1 = require("@aws-sdk/credential-provider-node");
 const protocol_http_1 = require("@aws-sdk/protocol-http");
+const eventstream_codec_1 = require("@smithy/eventstream-codec");
+const util_utf8_1 = require("@smithy/util-utf8");
 const sha256_js_1 = require("@aws-crypto/sha256-js");
 const env_js_1 = require("../util/env.cjs");
 const base_js_1 = require("./base.cjs");
+const index_js_1 = require("../schema/index.cjs");
 /**
  * A helper class used within the `Bedrock` class. It is responsible for
  * preparing the input and output for the Bedrock service. It formats the
@@ -17,20 +20,24 @@ class BedrockLLMInputOutputAdapter {
     /** Adapter class to prepare the inputs from Langchain to a format
     that LLM model expects. Also, provides a helper function to extract
     the generated text from the model response. */
-    static prepareInput(provider, prompt) {
+    static prepareInput(provider, prompt, maxTokens = 50, temperature = 0) {
         const inputBody = {};
-        if (provider === "anthropic" || provider === "ai21") {
+        if (provider === "anthropic") {
             inputBody.prompt = prompt;
+            inputBody.max_tokens_to_sample = maxTokens;
+            inputBody.temperature = temperature;
         }
-        else if (provider === "amazon") {
-            inputBody.inputText = prompt;
-            inputBody.textGenerationConfig = {};
+        else if (provider === "ai21") {
+            inputBody.prompt = prompt;
+            inputBody.maxTokens = maxTokens;
+            inputBody.temperature = temperature;
         }
-        else {
+        else if (provider === "amazon") {
             inputBody.inputText = prompt;
-        }
-        if (provider === "anthropic" && !("max_tokens_to_sample" in inputBody)) {
-            inputBody.max_tokens_to_sample = 50;
+            inputBody.textGenerationConfig = {
+                maxTokenCount: maxTokens,
+                temperature,
+            };
         }
         return inputBody;
     }
@@ -46,9 +53,9 @@ class BedrockLLMInputOutputAdapter {
             return responseBody.completion;
         }
         else if (provider === "ai21") {
-            return responseBody.completions[0].data.text;
+            return responseBody.data.text;
         }
-        return responseBody.results[0].outputText;
+        return responseBody.outputText;
     }
 }
 /**
@@ -105,6 +112,12 @@ class Bedrock extends base_js_1.LLM {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "codec", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new eventstream_codec_1.EventStreamCodec(util_utf8_1.toUtf8, util_utf8_1.fromUtf8)
+        });
         this.model = fields?.model ?? this.model;
         const allowedModels = ["ai21", "anthropic", "amazon"];
         if (!allowedModels.includes(this.model.split(".")[0])) {
@@ -130,11 +143,18 @@ class Bedrock extends base_js_1.LLM {
       Example:
         response = model.call("Tell me a joke.")
     */
-    async _call(prompt) {
+    async _call(prompt, options, runManager) {
+        const chunks = [];
+        for await (const chunk of this._streamResponseChunks(prompt, options, runManager)) {
+            chunks.push(chunk);
+        }
+        return chunks.map((chunk) => chunk.text).join("");
+    }
+    async *_streamResponseChunks(prompt, options, runManager) {
         const provider = this.model.split(".")[0];
         const service = "bedrock";
-        const inputBody = BedrockLLMInputOutputAdapter.prepareInput(provider, prompt);
-        const url = new URL(`https://${service}.${this.region}.amazonaws.com/model/${this.model}/invoke`);
+        const inputBody = BedrockLLMInputOutputAdapter.prepareInput(provider, prompt, this.maxTokens, this.temperature);
+        const url = new URL(`https://${service}.${this.region}.amazonaws.com/model/${this.model}/invoke-with-response-stream`);
         const request = new protocol_http_1.HttpRequest({
             hostname: url.hostname,
             path: url.pathname,
@@ -157,17 +177,41 @@ class Bedrock extends base_js_1.LLM {
         });
         const signedRequest = await signer.sign(request);
         // Send request to AWS using the low-level fetch API
-        const response = await this.fetchFn(url, {
+        const response = await this.caller.callWithOptions({ signal: options.signal }, async () => this.fetchFn(url, {
             headers: signedRequest.headers,
             body: signedRequest.body,
             method: signedRequest.method,
-        });
+        }));
         if (response.status < 200 || response.status >= 300) {
             throw Error(`Failed to access underlying url '${url}': got ${response.status} ${response.statusText}: ${await response.text()}`);
         }
-        const responseJson = await response.json();
-        const text = BedrockLLMInputOutputAdapter.prepareOutput(provider, responseJson);
-        return text;
+        const reader = response.body?.getReader();
+        for await (const chunk of this._readChunks(reader)) {
+            const event = this.codec.decode(chunk);
+            if (event.headers[":event-type"].value !== "chunk" ||
+                event.headers[":content-type"].value !== "application/json") {
+                throw Error(`Failed to get event chunk: got ${chunk}`);
+            }
+            const body = JSON.parse(Buffer.from(JSON.parse(new TextDecoder("utf-8").decode(event.body)).bytes, "base64").toString());
+            const text = BedrockLLMInputOutputAdapter.prepareOutput(provider, body);
+            yield new index_js_1.GenerationChunk({
+                text,
+                generationInfo: {},
+            });
+            await runManager?.handleLLMNewToken(text);
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    _readChunks(reader) {
+        return {
+            async *[Symbol.asyncIterator]() {
+                let readResult = await reader.read();
+                while (!readResult.done) {
+                    yield readResult.value;
+                    readResult = await reader.read();
+                }
+            },
+        };
     }
 }
 exports.Bedrock = Bedrock;

package/dist/llms/bedrock.d.ts

@@ -1,5 +1,8 @@
+import { EventStreamCodec } from "@smithy/eventstream-codec";
 import type { AwsCredentialIdentity, Provider } from "@aws-sdk/types";
 import { LLM, BaseLLMParams } from "./base.js";
+import { CallbackManagerForLLMRun } from "../callbacks/manager.js";
+import { GenerationChunk } from "../schema/index.js";
 type CredentialType = AwsCredentialIdentity | Provider<AwsCredentialIdentity>;
 /** Bedrock models.
     To authenticate, the AWS client uses the following methods to automatically load credentials:
@@ -43,6 +46,7 @@ export declare class Bedrock extends LLM implements BedrockInput {
     temperature?: number | undefined;
     maxTokens?: number | undefined;
     fetchFn: typeof fetch;
+    codec: EventStreamCodec;
     get lc_secrets(): {
         [key: string]: string;
     } | undefined;
@@ -58,6 +62,10 @@ export declare class Bedrock extends LLM implements BedrockInput {
       Example:
         response = model.call("Tell me a joke.")
     */
-    _call(prompt: string): Promise<string>;
+    _call(prompt: string, options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): Promise<string>;
+    _streamResponseChunks(prompt: string, options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): AsyncGenerator<GenerationChunk>;
+    _readChunks(reader: any): {
+        [Symbol.asyncIterator](): AsyncGenerator<any, void, unknown>;
+    };
 }
 export {};

package/dist/llms/bedrock.js

@@ -1,9 +1,12 @@
 import { SignatureV4 } from "@aws-sdk/signature-v4";
 import { defaultProvider } from "@aws-sdk/credential-provider-node";
 import { HttpRequest } from "@aws-sdk/protocol-http";
+import { EventStreamCodec } from "@smithy/eventstream-codec";
+import { fromUtf8, toUtf8 } from "@smithy/util-utf8";
 import { Sha256 } from "@aws-crypto/sha256-js";
 import { getEnvironmentVariable } from "../util/env.js";
 import { LLM } from "./base.js";
+import { GenerationChunk } from "../schema/index.js";
 /**
  * A helper class used within the `Bedrock` class. It is responsible for
  * preparing the input and output for the Bedrock service. It formats the
@@ -14,20 +17,24 @@ class BedrockLLMInputOutputAdapter {
     /** Adapter class to prepare the inputs from Langchain to a format
     that LLM model expects. Also, provides a helper function to extract
     the generated text from the model response. */
-    static prepareInput(provider, prompt) {
+    static prepareInput(provider, prompt, maxTokens = 50, temperature = 0) {
         const inputBody = {};
-        if (provider === "anthropic" || provider === "ai21") {
+        if (provider === "anthropic") {
             inputBody.prompt = prompt;
+            inputBody.max_tokens_to_sample = maxTokens;
+            inputBody.temperature = temperature;
         }
-        else if (provider === "amazon") {
-            inputBody.inputText = prompt;
-            inputBody.textGenerationConfig = {};
+        else if (provider === "ai21") {
+            inputBody.prompt = prompt;
+            inputBody.maxTokens = maxTokens;
+            inputBody.temperature = temperature;
         }
-        else {
+        else if (provider === "amazon") {
             inputBody.inputText = prompt;
-        }
-        if (provider === "anthropic" && !("max_tokens_to_sample" in inputBody)) {
-            inputBody.max_tokens_to_sample = 50;
+            inputBody.textGenerationConfig = {
+                maxTokenCount: maxTokens,
+                temperature,
+            };
         }
         return inputBody;
     }
@@ -43,9 +50,9 @@ class BedrockLLMInputOutputAdapter {
             return responseBody.completion;
         }
         else if (provider === "ai21") {
-            return responseBody.completions[0].data.text;
+            return responseBody.data.text;
         }
-        return responseBody.results[0].outputText;
+        return responseBody.outputText;
     }
 }
 /**
@@ -102,6 +109,12 @@ export class Bedrock extends LLM {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "codec", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new EventStreamCodec(toUtf8, fromUtf8)
+        });
         this.model = fields?.model ?? this.model;
         const allowedModels = ["ai21", "anthropic", "amazon"];
         if (!allowedModels.includes(this.model.split(".")[0])) {
@@ -127,11 +140,18 @@ export class Bedrock extends LLM {
       Example:
         response = model.call("Tell me a joke.")
     */
-    async _call(prompt) {
+    async _call(prompt, options, runManager) {
+        const chunks = [];
+        for await (const chunk of this._streamResponseChunks(prompt, options, runManager)) {
+            chunks.push(chunk);
+        }
+        return chunks.map((chunk) => chunk.text).join("");
+    }
+    async *_streamResponseChunks(prompt, options, runManager) {
         const provider = this.model.split(".")[0];
         const service = "bedrock";
-        const inputBody = BedrockLLMInputOutputAdapter.prepareInput(provider, prompt);
-        const url = new URL(`https://${service}.${this.region}.amazonaws.com/model/${this.model}/invoke`);
+        const inputBody = BedrockLLMInputOutputAdapter.prepareInput(provider, prompt, this.maxTokens, this.temperature);
+        const url = new URL(`https://${service}.${this.region}.amazonaws.com/model/${this.model}/invoke-with-response-stream`);
         const request = new HttpRequest({
             hostname: url.hostname,
             path: url.pathname,
@@ -154,16 +174,40 @@ export class Bedrock extends LLM {
         });
         const signedRequest = await signer.sign(request);
         // Send request to AWS using the low-level fetch API
-        const response = await this.fetchFn(url, {
+        const response = await this.caller.callWithOptions({ signal: options.signal }, async () => this.fetchFn(url, {
             headers: signedRequest.headers,
             body: signedRequest.body,
             method: signedRequest.method,
-        });
+        }));
         if (response.status < 200 || response.status >= 300) {
             throw Error(`Failed to access underlying url '${url}': got ${response.status} ${response.statusText}: ${await response.text()}`);
         }
-        const responseJson = await response.json();
-        const text = BedrockLLMInputOutputAdapter.prepareOutput(provider, responseJson);
-        return text;
+        const reader = response.body?.getReader();
+        for await (const chunk of this._readChunks(reader)) {
+            const event = this.codec.decode(chunk);
+            if (event.headers[":event-type"].value !== "chunk" ||
+                event.headers[":content-type"].value !== "application/json") {
+                throw Error(`Failed to get event chunk: got ${chunk}`);
+            }
+            const body = JSON.parse(Buffer.from(JSON.parse(new TextDecoder("utf-8").decode(event.body)).bytes, "base64").toString());
+            const text = BedrockLLMInputOutputAdapter.prepareOutput(provider, body);
+            yield new GenerationChunk({
+                text,
+                generationInfo: {},
+            });
+            await runManager?.handleLLMNewToken(text);
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    _readChunks(reader) {
+        return {
+            async *[Symbol.asyncIterator]() {
+                let readResult = await reader.read();
+                while (!readResult.done) {
+                    yield readResult.value;
+                    readResult = await reader.read();
+                }
+            },
+        };
     }
 }

package/dist/llms/writer.cjs

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Writer = void 0;
+const writer_sdk_1 = require("@writerai/writer-sdk");
+const base_js_1 = require("./base.cjs");
+const env_js_1 = require("../util/env.cjs");
+/**
+ * Class representing a Writer Large Language Model (LLM). It interacts
+ * with the Writer API to generate text completions.
+ */
+class Writer extends base_js_1.LLM {
+    static lc_name() {
+        return "Writer";
+    }
+    get lc_secrets() {
+        return {
+            apiKey: "WRITER_API_KEY",
+            orgId: "WRITER_ORG_ID",
+        };
+    }
+    get lc_aliases() {
+        return {
+            apiKey: "writer_api_key",
+            orgId: "writer_org_id",
+        };
+    }
+    constructor(fields) {
+        super(fields ?? {});
+        Object.defineProperty(this, "lc_serializable", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        Object.defineProperty(this, "apiKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "orgId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "model", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "palmyra-instruct"
+        });
+        Object.defineProperty(this, "temperature", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "minTokens", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "maxTokens", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "bestOf", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "frequencyPenalty", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "logprobs", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "n", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "presencePenalty", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "topP", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        const apiKey = fields?.apiKey ?? (0, env_js_1.getEnvironmentVariable)("WRITER_API_KEY");
+        const orgId = fields?.orgId ?? (0, env_js_1.getEnvironmentVariable)("WRITER_ORG_ID");
+        if (!apiKey) {
+            throw new Error("Please set the WRITER_API_KEY environment variable or pass it to the constructor as the apiKey field.");
+        }
+        if (!orgId) {
+            throw new Error("Please set the WRITER_ORG_ID environment variable or pass it to the constructor as the orgId field.");
+        }
+        this.apiKey = apiKey;
+        this.orgId = typeof orgId === "string" ? parseInt(orgId, 10) : orgId;
+        this.model = fields?.model ?? this.model;
+        this.temperature = fields?.temperature ?? this.temperature;
+        this.minTokens = fields?.minTokens ?? this.minTokens;
+        this.maxTokens = fields?.maxTokens ?? this.maxTokens;
+        this.bestOf = fields?.bestOf ?? this.bestOf;
+        this.frequencyPenalty = fields?.frequencyPenalty ?? this.frequencyPenalty;
+        this.logprobs = fields?.logprobs ?? this.logprobs;
+        this.n = fields?.n ?? this.n;
+        this.presencePenalty = fields?.presencePenalty ?? this.presencePenalty;
+        this.topP = fields?.topP ?? this.topP;
+    }
+    _llmType() {
+        return "writer";
+    }
+    /** @ignore */
+    async _call(prompt, options) {
+        const sdk = new writer_sdk_1.Writer({
+            security: {
+                apiKey: this.apiKey,
+            },
+            organizationId: this.orgId,
+        });
+        return this.caller.callWithOptions({ signal: options.signal }, async () => {
+            try {
+                const res = await sdk.completions.create({
+                    completionRequest: {
+                        prompt,
+                        stop: options.stop,
+                        temperature: this.temperature,
+                        minTokens: this.minTokens,
+                        maxTokens: this.maxTokens,
+                        bestOf: this.bestOf,
+                        n: this.n,
+                        frequencyPenalty: this.frequencyPenalty,
+                        logprobs: this.logprobs,
+                        presencePenalty: this.presencePenalty,
+                        topP: this.topP,
+                    },
+                    modelId: this.model,
+                });
+                return (res.completionResponse?.choices?.[0].text ?? "No completion found.");
+            }
+            catch (e) {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                e.response = e.rawResponse;
+                throw e;
+            }
+        });
+    }
+}
+exports.Writer = Writer;