fix: github copilot mapping error, invalid cast that causes runtime errors, token calculation (rn approximation)

Author: caezium

src/LLMProviders/chatModelManager.ts

@@ -12,9 +12,13 @@ import { err2String, isOSeriesModel, safeFetch, withSuppressedTokenWarnings } fr
 import { HarmBlockThreshold, HarmCategory } from "@google/generative-ai";
 import { ChatAnthropic } from "@langchain/anthropic";
 import { ChatCohere } from "@langchain/cohere";
-import { BaseChatModel } from "@langchain/core/language_models/chat_models";
-import { AIMessage } from "@langchain/core/messages";
-import { Runnable } from "@langchain/core/runnables";
+import {
+  BaseChatModel,
+  type BaseChatModelParams,
+} from "@langchain/core/language_models/chat_models";
+import { AIMessage, type BaseMessage, type MessageContent } from "@langchain/core/messages";
+import { type ChatResult, ChatGeneration } from "@langchain/core/outputs";
+import { type CallbackManagerForLLMRun } from "@langchain/core/callbacks/manager";
 import { ChatDeepSeek } from "@langchain/deepseek";
 import { ChatGoogleGenerativeAI } from "@langchain/google-genai";
 import { ChatGroq } from "@langchain/groq";
@@ -24,36 +28,85 @@ import { ChatOpenAI } from "@langchain/openai";
 import { ChatXAI } from "@langchain/xai";
 import { Notice } from "obsidian";
 import { GitHubCopilotProvider } from "./githubCopilotProvider";
-import { ChatPromptValue } from "@langchain/core/prompt_values";
 
-class CopilotRunnable extends Runnable {
+export interface CopilotChatModelParams extends BaseChatModelParams {
+  provider: GitHubCopilotProvider;
+  modelName: string;
+}
+
+class CopilotChatModel extends BaseChatModel {
   lc_serializable = false;
   lc_namespace = ["langchain", "chat_models", "copilot"];
   private provider: GitHubCopilotProvider;
-  private modelName: string;
+  modelName: string;
+
+  constructor(fields: CopilotChatModelParams) {
+    super(fields);
+    this.provider = fields.provider;
+    this.modelName = fields.modelName;
+  }
 
-  constructor(provider: GitHubCopilotProvider, modelName: string) {
-    super();
-    this.provider = provider;
-    this.modelName = modelName;
+  _llmType(): string {
+    return "copilot-chat-model";
   }
 
-  async invoke(input: ChatPromptValue, options?: any): Promise<any> {
-    const messages = input.toChatMessages().map((m) => ({
-      role: m._getType() === "human" ? "user" : "assistant",
+  private _convertMessageType(messageType: string): string {
+    switch (messageType) {
+      case "human":
+        return "user";
+      case "ai":
+        return "assistant";
+      case "system":
+        return "system";
+      case "tool":
+        return "tool";
+      case "function":
+        return "function";
+      case "generic":
+      default:
+        return "user";
+    }
+  }
+
+  async _generate(
+    messages: BaseMessage[],
+    options: this["ParsedCallOptions"],
+    runManager?: CallbackManagerForLLMRun
+  ): Promise<ChatResult> {
+    const chatMessages = messages.map((m) => ({
+      role: this._convertMessageType(m._getType()),
       content: m.content as string,
     }));
-    const response = await this.provider.sendChatMessage(messages, this.modelName);
+
+    const response = await this.provider.sendChatMessage(chatMessages, this.modelName);
     const content = response.choices?.[0]?.message?.content || "";
-    return new AIMessage(content);
+
+    const generation: ChatGeneration = {
+      text: content,
+      message: new AIMessage(content),
+    };
+
+    return {
+      generations: [generation],
+      llmOutput: {}, // add more details here if needed
+    };
+  }
+
+  /**
+   * A simple approximation: ~4 chars per token for English text
+   * This matches the fallback behavior in ChatModelManager.countTokens
+   */
+  async getNumTokens(content: MessageContent): Promise<number> {
+    const text = typeof content === "string" ? content : JSON.stringify(content);
+    if (!text) return 0;
+    return Math.ceil(text.length / 4);
   }
 }
 
 type ChatConstructorType = {
   new (config: any): any;
 };
 
-// Placeholder for GitHub Copilot chat provider
 class ChatGitHubCopilot {
   private provider: GitHubCopilotProvider;
   constructor(config: any) {
@@ -420,9 +473,7 @@ export default class ChatModelManager {
   async createModelInstance(model: CustomModel): Promise<BaseChatModel> {
     if (model.provider === ChatModelProviders.GITHUB_COPILOT) {
       const provider = new GitHubCopilotProvider();
-      const copilotRunnable = new CopilotRunnable(provider, model.name);
-      // The type assertion is a bit of a hack, but it makes it work with the existing structure
-      return copilotRunnable as unknown as BaseChatModel;
+      return new CopilotChatModel({ provider, modelName: model.name });
     }
 
     const AIConstructor = this.getProviderConstructor(model);

src/LLMProviders/githubCopilotProvider.ts

@@ -120,8 +120,9 @@ export class GitHubCopilotProvider {
     if (res.status !== 200) throw new Error("Failed to get Copilot token");
     const data = res.json;
     this.authState.copilotToken = data.token;
-    this.authState.copilotTokenExpiresAt =
-      Date.now() + (data.expires_at ? data.expires_at * 1000 : 3600 * 1000);
+    this.authState.copilotTokenExpiresAt = data.expires_at
+      ? data.expires_at * 1000
+      : Date.now() + 3600 * 1000;
     this.authState.status = "authenticated";
     // Persist Copilot token and expiration
     updateSetting("copilotToken", data.token);