feat(core): add OAuth support to the built-in Anthropic transformer

packages/core/package.json

@@ -20,7 +20,9 @@
     "dev": "nodemon",
     "start": "node dist/cjs/server.cjs",
     "start:esm": "node dist/esm/server.mjs",
-    "lint": "eslint src --ext .ts,.tsx"
+    "lint": "eslint src --ext .ts,.tsx",
+    "test": "vitest run",
+    "test:watch": "vitest"
   },
   "keywords": [
     "llm",
@@ -54,6 +56,8 @@
     "@types/node": "^24.0.15",
     "esbuild": "^0.25.1",
     "tsx": "^4.20.3",
-    "typescript": "^5.8.2"
+    "typescript": "^5.8.2",
+    "vite-tsconfig-paths": "^5.1.4",
+    "vitest": "^3.0.0"
   }
 }

packages/core/src/api/routes.ts

@@ -309,8 +309,13 @@ async function sendRequestToProvider(
   const url = config.url || new URL(provider.baseUrl);
 
   // Handle authentication in passthrough mode
-  if (bypass && typeof transformer.auth === "function") {
-    const auth = await transformer.auth(requestBody, provider);
+  // Prefer provider's own transformer instance (may have options like OAuth:true) over the global one
+  const authTransformer =
+    bypass && provider.transformer?.use?.length === 1
+      ? provider.transformer.use[0]
+      : transformer;
+  if (bypass && typeof authTransformer.auth === "function") {
+    const auth = await authTransformer.auth(requestBody, provider, { headers: config.headers });
     if (auth.body) {
       requestBody = auth.body;
       let headers = config.headers || {};

packages/core/src/services/provider.ts

@@ -45,9 +45,20 @@ export class ProviderService {
               if (Array.isArray(providerConfig.transformer.use)) {
                 transformer.use = providerConfig.transformer.use.map((transformer) => {
                   if (Array.isArray(transformer) && typeof transformer[0] === 'string') {
-                    const Constructor = this.transformerService.getTransformer(transformer[0]);
-                    if (Constructor) {
-                      return new (Constructor as TransformerConstructor)(transformer[1]);
+                    const registered = this.transformerService.getTransformer(transformer[0]);
+                    if (registered) {
+                      if (typeof registered === 'function') {
+                        return new (registered as TransformerConstructor)(transformer[1]);
+                      }
+                      // Instance-registered transformer: create new from its constructor with options
+                      const Ctor = (registered as any).constructor;
+                      if (Ctor && typeof Ctor === 'function') {
+                        const instance = new Ctor(transformer[1]);
+                        if (instance && typeof instance === 'object') {
+                          (instance as any).logger = this.logger;
+                        }
+                        return instance;
+                      }
                     }
                   }
                   if (typeof transformer === 'string') {
@@ -64,9 +75,19 @@ export class ProviderService {
                 transformer[key] = {
                   use: providerConfig.transformer[key].use.map((transformer) => {
                     if (Array.isArray(transformer) && typeof transformer[0] === 'string') {
-                      const Constructor = this.transformerService.getTransformer(transformer[0]);
-                      if (Constructor) {
-                        return new (Constructor as TransformerConstructor)(transformer[1]);
+                      const registered = this.transformerService.getTransformer(transformer[0]);
+                      if (registered) {
+                        if (typeof registered === 'function') {
+                          return new (registered as TransformerConstructor)(transformer[1]);
+                        }
+                        const Ctor = (registered as any).constructor;
+                        if (Ctor && typeof Ctor === 'function') {
+                          const instance = new Ctor(transformer[1]);
+                          if (instance && typeof instance === 'object') {
+                            (instance as any).logger = this.logger;
+                          }
+                          return instance;
+                        }
                       }
                     }
                     if (typeof transformer === 'string') {