ChatWebLLM Initialization Failure Due To @mlc-ai/web-llm Refactoring about langchainjs HOT 5 CLOSED

import { ChatWebLLM } from '@langchain/community/chat_models/webllm';
import * as webllm from "@mlc-ai/web-llm";

webllmModel = new ChatWebLLM({
    model: 'Phi2-q4f32_1',
    chatOptions: {
        temperature: 0.1
    }
});
await webllmModel.initialize();

import * as webllm from "@mlc-ai/web-llm";

export class ChatWebLLM extends SimpleChatModel<WebLLMCallOptions> {
  protected engine: webllm.MLCEngine;

  async initialize(progressCallback?: webllm.InitProgressCallback) {
    this.engine = new webllm.MLCEngine();
    if (progressCallback !== undefined) {
      this.engine.setInitProgressCallback(progressCallback);
    }
    await this.reload(this.model, this.chatOptions, this.appConfig);
    this.engine.setInitProgressCallback(() => {});
  }

  async reload(
    modelId: string,
    newAppConfig?: webllm.AppConfig,
    newChatOpts?: webllm.ChatOptions
  ) {
    if (this.engine !== undefined) {
      await this.engine.reload(modelId, newAppConfig, newChatOpts);
    } else {
      throw new Error("Initialize model before reloading.");
    }
  }

  async *_streamResponseChunks(
    messages: BaseMessage[],
    options: this["ParsedCallOptions"],
    runManager?: CallbackManagerForLLMRun
  ): AsyncGenerator<ChatGenerationChunk> {
    await this.initialize();

    const messagesInput: ChatCompletionMessageParam[] = messages.map(
      (message) => {
        if (typeof message.content !== "string") {
          throw new Error(
            "ChatWebLLM does not support non-string message content in sessions."
          );
        }
        const langChainType = message._getType();
        let role;
        if (langChainType === "ai") {
          role = "assistant" as const;
        } else if (langChainType === "human") {
          role = "user" as const;
        } else if (langChainType === "system") {
          role = "system" as const;
        } else {
          throw new Error(
            "Function, tool, and generic messages are not supported."
          );
        }
        return {
          role,
          content: message.content,
        };
      }
    );

    const stream = this.engine.chatCompletionAsyncChunkGenerator(
      {
        stream: true,
        messages: messagesInput,
        stop: options.stop,
        logprobs: true,
      },
      {}
    );
    for await (const chunk of stream) {
      const text = chunk.choices[0].delta.content ?? "";
      yield new ChatGenerationChunk({
        text,
        message: new AIMessageChunk({
          content: text,
          additional_kwargs: {
            logprobs: chunk.choices[0].logprobs,
            finish_reason: chunk.choices[0].finish_reason,
          },
        }),
      });
      await runManager?.handleLLMNewToken(text ?? "");
    }
  }

  async _call(
    messages: BaseMessage[],
    options: this["ParsedCallOptions"],
    runManager?: CallbackManagerForLLMRun
  ): Promise<string> {
    const chunks = [];
    for await (const chunk of this._streamResponseChunks(
      messages,
      options,
      runManager
    )) {
      chunks.push(chunk.text);
    }
    return chunks.join("");
  }
}