Fix auth and model discovery

credentials/OpenCodeApi.credentials.ts

@@ -1,7 +1,8 @@
 import type {
-  IAuthenticateGeneric,
+  ICredentialDataDecryptedObject,
   ICredentialTestRequest,
   ICredentialType,
+  IHttpRequestOptions,
   INodeProperties,
 } from "n8n-workflow";
 
@@ -21,40 +22,103 @@ export class OpenCodeApi implements ICredentialType {
       description: "The base URL of your OpenCode server instance",
       placeholder: "http://127.0.0.1:4096",
     },
+    {
+      displayName: "Authentication",
+      name: "authType",
+      type: "options",
+      default: "none",
+      options: [
+        {
+          name: "None",
+          value: "none",
+        },
+        {
+          name: "Basic Auth",
+          value: "basic",
+        },
+        {
+          name: "Bearer Token",
+          value: "bearer",
+        },
+      ],
+      description: "How to authenticate against the OpenCode server",
+    },
+    {
+      displayName: "Username",
+      name: "username",
+      type: "string",
+      default: "opencode",
+      displayOptions: {
+        show: {
+          authType: ["basic"],
+        },
+      },
+      description: "Username for OpenCode Basic auth",
+    },
+    {
+      displayName: "Password",
+      name: "password",
+      type: "string",
+      typeOptions: { password: true },
+      default: "",
+      displayOptions: {
+        show: {
+          authType: ["basic"],
+        },
+      },
+      description: "Password for OpenCode Basic auth",
+    },
     {
       displayName: "API Key",
       name: "apiKey",
       type: "string",
       typeOptions: { password: true },
       default: "",
-      description: "Optional API key for authenticated OpenCode instances",
+      displayOptions: {
+        show: {
+          authType: ["bearer"],
+        },
+      },
+      description: "Bearer token for OpenCode instances using token auth",
     },
   ];
 
-  authenticate: IAuthenticateGeneric = {
-    type: "generic",
-    properties: {
-      headers: {
-        Authorization:
-          '={{$credentials.apiKey ? "Bearer " + $credentials.apiKey : ""}}',
-      },
-    },
+  authenticate = async (
+    credentials: ICredentialDataDecryptedObject,
+    requestOptions: IHttpRequestOptions,
+  ): Promise<IHttpRequestOptions> => {
+    const authType = credentials.authType as string | undefined;
+
+    if (authType === "basic" && credentials.password) {
+      return {
+        ...requestOptions,
+        auth: {
+          username: (credentials.username as string) || "opencode",
+          password: credentials.password as string,
+        },
+      };
+    }
+
+    if (authType === "bearer" && credentials.apiKey) {
+      return {
+        ...requestOptions,
+        headers: {
+          ...(requestOptions.headers || {}),
+          Authorization: `Bearer ${credentials.apiKey as string}`,
+        },
+      };
+    }
+
+    return requestOptions;
   };
 
   test: ICredentialTestRequest = {
     request: {
       baseURL: "={{$credentials.baseUrl}}",
-      url: "/session",
-      method: "POST",
+      url: "/global/health",
+      method: "GET",
       headers: {
-        "Content-Type": "application/json",
-      },
-      body: {
-        agent: "coder",
-        model: {
-          providerID: "anthropic",
-          modelID: "claude-sonnet-4",
-        },
+        Accept: "application/json",
       },
     },
   };

jest.config.cjs

@@ -0,0 +1,7 @@
+module.exports = {
+  preset: "ts-jest",
+  testEnvironment: "node",
+  testMatch: ["**/tests/**/*.test.ts"],
+  modulePathIgnorePatterns: ["<rootDir>/dist/"],
+  clearMocks: true,
+};

nodes/LmChatOpenCode/LmChatOpenCode.node.ts

@@ -8,6 +8,8 @@ import type {
 } from "n8n-workflow";
 import { NodeConnectionTypes } from "n8n-workflow";
 import { OpenCodeChatModel } from "./OpenCodeChatModel";
+import { getOpenCodeAuthHeaders } from "./auth";
+import { findProviderById, mapModelOptions, mapProviderOptions } from "./discovery";
 
 export class LmChatOpenCode implements INodeType {
   description: INodeTypeDescription = {
@@ -71,6 +73,7 @@ export class LmChatOpenCode implements INodeType {
         default: "",
         typeOptions: {
           loadOptionsMethod: "getModels",
+          loadOptionsDependsOn: ["providerID"],
         },
       },
       {
@@ -128,24 +131,21 @@ export class LmChatOpenCode implements INodeType {
         const credentials = await this.getCredentials("openCodeApi");
         const baseUrl =
           (credentials?.baseUrl as string) || "http://127.0.0.1:4096";
-        const apiKey = credentials?.apiKey as string | undefined;
+        const headers = getOpenCodeAuthHeaders({
+          authType: credentials?.authType as string | undefined,
+          apiKey: credentials?.apiKey as string | undefined,
+          username: credentials?.username as string | undefined,
+          password: credentials?.password as string | undefined,
+        });
 
         try {
           const response = await this.helpers.httpRequest({
             method: "GET",
             url: `${baseUrl}/config/providers`,
-            headers: apiKey ? { Authorization: `Bearer ${apiKey}` } : {},
+            headers,
           });
 
-          // Transform providers array to options
-          return response.providers
-            .map((provider: any) => ({
-              name: provider.name,
-              value: provider.id,
-            }))
-            .sort((a: INodePropertyOptions, b: INodePropertyOptions) =>
-              a.name.localeCompare(b.name),
-            );
+          return mapProviderOptions(response.providers);
         } catch (error) {
           console.warn(
             "Failed to load providers from OpenCode:",
@@ -166,13 +166,18 @@ export class LmChatOpenCode implements INodeType {
         const credentials = await this.getCredentials("openCodeApi");
         const baseUrl =
           (credentials?.baseUrl as string) || "http://127.0.0.1:4096";
-        const apiKey = credentials?.apiKey as string | undefined;
+        const headers = getOpenCodeAuthHeaders({
+          authType: credentials?.authType as string | undefined,
+          apiKey: credentials?.apiKey as string | undefined,
+          username: credentials?.username as string | undefined,
+          password: credentials?.password as string | undefined,
+        });
 
         try {
           const response = await this.helpers.httpRequest({
             method: "GET",
             url: `${baseUrl}/agent`,
-            headers: apiKey ? { Authorization: `Bearer ${apiKey}` } : {},
+            headers,
           });
 
           // Transform agents array to options
@@ -205,8 +210,13 @@ export class LmChatOpenCode implements INodeType {
         const credentials = await this.getCredentials("openCodeApi");
         const baseUrl =
           (credentials?.baseUrl as string) || "http://127.0.0.1:4096";
-        const apiKey = credentials?.apiKey as string | undefined;
-        const providerID = this.getCurrentNodeParameter("providerID") as string;
+        const headers = getOpenCodeAuthHeaders({
+          authType: credentials?.authType as string | undefined,
+          apiKey: credentials?.apiKey as string | undefined,
+          username: credentials?.username as string | undefined,
+          password: credentials?.password as string | undefined,
+        });
+        const providerID = this.getNodeParameter("providerID") as string;
 
         if (!providerID) {
           return [];
@@ -216,20 +226,11 @@ export class LmChatOpenCode implements INodeType {
           const response = await this.helpers.httpRequest({
             method: "GET",
             url: `${baseUrl}/config/providers`,
-            headers: apiKey ? { Authorization: `Bearer ${apiKey}` } : {},
+            headers,
           });
 
-          // Find provider in array and get models object
-          const provider = response.providers.find(
-            (p: any) => p.id === providerID,
-          );
-          const models = provider?.models || {};
-
-          // Convert models object keys to array
-          return Object.keys(models).map((modelId: string) => ({
-            name: modelId,
-            value: modelId,
-          }));
+          const provider = findProviderById(response.providers, providerID);
+          return mapModelOptions(provider);
         } catch (error) {
           console.warn(
             "Failed to load models from OpenCode:",
@@ -264,7 +265,10 @@ export class LmChatOpenCode implements INodeType {
 
     const model = new OpenCodeChatModel({
       baseUrl,
+      authType: credentials?.authType as string | undefined,
       apiKey: credentials?.apiKey as string | undefined,
+      username: credentials?.username as string | undefined,
+      password: credentials?.password as string | undefined,
       agent,
       providerID,
       modelID,

nodes/LmChatOpenCode/OpenCodeChatModel.ts

@@ -7,10 +7,14 @@ import { CallbackManagerForLLMRun } from "@langchain/core/callbacks/manager";
 import { BaseMessage, AIMessage } from "@langchain/core/messages";
 import { ChatResult } from "@langchain/core/outputs";
 import type { Runnable } from "@langchain/core/runnables";
+import { getOpenCodeAuthHeaders } from "./auth";
 
 export interface OpenCodeChatModelInput extends BaseChatModelParams {
   baseUrl?: string;
+  authType?: string;
   apiKey?: string;
+  username?: string;
+  password?: string;
   agent?: string;
   providerID?: string;
   modelID?: string;
@@ -38,7 +42,10 @@ interface OpenCodeMessageResponse {
 
 export class OpenCodeChatModel extends BaseChatModel {
   baseUrl = "http://127.0.0.1:4096";
+  authType = "none";
   apiKey?: string;
+  username?: string;
+  password?: string;
   agent = "build";
   providerID = "anthropic";
   modelID = "claude-3-5-sonnet-20241022";
@@ -69,7 +76,10 @@ export class OpenCodeChatModel extends BaseChatModel {
       throw new Error("modelID is required and cannot be empty");
     }
 
+    this.authType = fields.authType ?? this.authType;
     this.apiKey = fields.apiKey;
+    this.username = fields.username;
+    this.password = fields.password;
     this.agent = fields.agent ?? this.agent;
     this.providerID = providerID;
     this.modelID = modelID;
@@ -142,12 +152,14 @@ export class OpenCodeChatModel extends BaseChatModel {
   private async createSession(): Promise<string> {
     const headers: Record<string, string> = {
       "Content-Type": "application/json",
+      ...getOpenCodeAuthHeaders({
+        authType: this.authType,
+        apiKey: this.apiKey,
+        username: this.username,
+        password: this.password,
+      }),
     };
 
-    if (this.apiKey) {
-      headers["Authorization"] = `Bearer ${this.apiKey}`;
-    }
-
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), this.requestTimeout);
 
@@ -234,12 +246,14 @@ export class OpenCodeChatModel extends BaseChatModel {
   ): Promise<string> {
     const headers: Record<string, string> = {
       "Content-Type": "application/json",
+      ...getOpenCodeAuthHeaders({
+        authType: this.authType,
+        apiKey: this.apiKey,
+        username: this.username,
+        password: this.password,
+      }),
     };
 
-    if (this.apiKey) {
-      headers["Authorization"] = `Bearer ${this.apiKey}`;
-    }
-
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), this.requestTimeout);
 
@@ -318,10 +332,12 @@ export class OpenCodeChatModel extends BaseChatModel {
 
   private async deleteSession(sessionId: string): Promise<void> {
     try {
-      const headers: Record<string, string> = {};
-      if (this.apiKey) {
-        headers["Authorization"] = `Bearer ${this.apiKey}`;
-      }
+      const headers = getOpenCodeAuthHeaders({
+        authType: this.authType,
+        apiKey: this.apiKey,
+        username: this.username,
+        password: this.password,
+      });
 
       const controller = new AbortController();
       const timeoutId = setTimeout(