Rename app.py to app.js

app.js

@@ -0,0 +1,191 @@
+const http = require('http');
+const url = require('url');
+const fetch = require('node-fetch');
+
+const MODEL = 'claude-3-5-sonnet@20240620';
+
+const PROJECT_ID = process.env.PROJECT_ID;
+const CLIENT_ID = process.env.CLIENT_ID;
+const CLIENT_SECRET = process.env.CLIENT_SECRET;
+const REFRESH_TOKEN = process.env.REFRESH_TOKEN;
+const API_KEY = process.env.API_KEY;
+
+const TOKEN_URL = 'https://www.googleapis.com/oauth2/v4/token';
+
+let tokenCache = {
+  accessToken: '',
+  expiry: 0,
+  refreshPromise: null
+};
+
+async function getAccessToken() {
+  const now = Date.now() / 1000;
+
+  if (tokenCache.accessToken && now < tokenCache.expiry - 120) {
+    return tokenCache.accessToken;
+  }
+
+  if (tokenCache.refreshPromise) {
+    await tokenCache.refreshPromise;
+    return tokenCache.accessToken;
+  }
+
+  tokenCache.refreshPromise = (async () => {
+    try {
+      const response = await fetch(TOKEN_URL, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json'
+        },
+        body: JSON.stringify({
+          client_id: CLIENT_ID,
+          client_secret: CLIENT_SECRET,
+          refresh_token: REFRESH_TOKEN,
+          grant_type: 'refresh_token'
+        })
+      });
+
+      const data = await response.json();
+      tokenCache.accessToken = data.access_token;
+      tokenCache.expiry = now + data.expires_in;
+    } finally {
+      tokenCache.refreshPromise = null;
+    }
+  })();
+
+  await tokenCache.refreshPromise;
+  return tokenCache.accessToken;
+}
+
+function getLocation() {
+  const currentSeconds = new Date().getSeconds();
+  return currentSeconds < 30 ? 'europe-west1' : 'us-east5';
+}
+
+function constructApiUrl(location) {
+  return `https://${location}-aiplatform.googleapis.com/v1/projects/${PROJECT_ID}/locations/${location}/publishers/anthropic/models/${MODEL}:streamRawPredict`;
+}
+
+async function handleRequest(request) {
+  if (request.method === 'OPTIONS') {
+    return handleOptions();
+  }
+
+  const apiKey = request.headers['x-api-key'];
+  if (apiKey !== API_KEY) {
+    const errorResponse = {
+      status: 403,
+      headers: {
+        'Content-Type': 'application/json',
+        'Access-Control-Allow-Origin': '*',
+        'Access-Control-Allow-Methods': 'POST, GET, OPTIONS, DELETE, HEAD',
+        'Access-Control-Allow-Headers': 'Content-Type, Authorization, x-api-key, anthropic-version, model'
+      },
+      body: JSON.stringify({
+        type: "error",
+        error: {
+          type: "permission_error",
+          message: "Your API key does not have permission to use the specified resource."
+        }
+      })
+    };
+
+    return errorResponse;
+  }
+
+  const accessToken = await getAccessToken();
+  const location = getLocation();
+  const apiUrl = constructApiUrl(location);
+
+  let requestBody = JSON.parse(request.body);
+  
+  if (requestBody.anthropic_version) {
+    delete requestBody.anthropic_version;
+  }
+  
+  if (requestBody.model) {
+    delete requestBody.model;
+  }
+  
+  requestBody.anthropic_version = "vertex-2023-10-16";
+
+  const modifiedHeaders = {
+    ...request.headers,
+    'Authorization': `Bearer ${accessToken}`,
+    'Content-Type': 'application/json; charset=utf-8'
+  };
+  delete modifiedHeaders['anthropic-version'];
+
+  const modifiedRequest = {
+    headers: modifiedHeaders,
+    method: request.method,
+    body: JSON.stringify(requestBody),
+    redirect: 'follow'
+  };
+
+  const response = await fetch(apiUrl, modifiedRequest);
+  const responseBody = await response.text();
+  const modifiedResponse = {
+    status: response.status,
+    statusText: response.statusText,
+    headers: {
+      ...response.headers,
+      'Access-Control-Allow-Origin': '*',
+      'Access-Control-Allow-Methods': 'POST, GET, OPTIONS',
+      'Access-Control-Allow-Headers': 'Content-Type, Authorization, x-api-key, anthropic-version, model'
+    },
+    body: responseBody
+  };
+   
+  return modifiedResponse;
+}
+
+function handleOptions() {
+  const headers = {
+    'Access-Control-Allow-Origin': '*',
+    'Access-Control-Allow-Methods': 'POST, GET, OPTIONS',
+    'Access-Control-Allow-Headers': 'Content-Type, Authorization, x-api-key, anthropic-version, model'
+  };
+
+  return {
+    status: 204,
+    headers: headers
+  };
+}
+
+const server = http.createServer(async (req, res) => {
+  const parsedUrl = url.parse(req.url, true);
+  if (parsedUrl.pathname === '/ai/v1/messages') {
+    const request = {
+      method: req.method,
+      headers: req.headers,
+      body: await getRequestBody(req)
+    };
+
+    const response = await handleRequest(request);
+    res.writeHead(response.status, response.statusText, response.headers);
+    res.end(response.body);
+  } else {
+    res.writeHead(404, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ error: 'Not Found' }));
+  }
+});
+
+function getRequestBody(req) {
+  return new Promise((resolve, reject) => {
+    let body = '';
+    req.on('data', chunk => {
+      body += chunk.toString();
+    });
+    req.on('end', () => {
+      resolve(body);
+    });
+    req.on('error', err => {
+      reject(err);
+    });
+  });
+}
+
+server.listen(8080, () => {
+  console.log('Server is running on port 8080');
+});

app.py

@@ -1,113 +0,0 @@
-from flask import Flask, request, jsonify, Response, make_response
-import requests
-import threading
-import time
-import os
-
-app = Flask(__name__)
-
-MODEL = 'claude-3-5-sonnet@20240620'
-PROJECT_ID = os.getenv('PROJECT_ID')
-CLIENT_ID = os.getenv('CLIENT_ID')
-CLIENT_SECRET = os.getenv('CLIENT_SECRET')
-REFRESH_TOKEN = os.getenv('REFRESH_TOKEN')
-API_KEY = os.getenv('API_KEY')
-TOKEN_URL = 'https://www.googleapis.com/oauth2/v4/token'
-
-token_cache = {
-    'access_token': '',
-    'expiry': 0,
-    'refresh_promise': None
-}
-
-def get_access_token():
-    now = time.time()
-
-    if token_cache['access_token'] and now < token_cache['expiry'] - 120:
-        return token_cache['access_token']
-
-    if token_cache['refresh_promise']:
-        token_cache['refresh_promise'].join()
-        return token_cache['access_token']
-
-    def refresh_token():
-        try:
-            response = requests.post(TOKEN_URL, json={
-                'client_id': CLIENT_ID,
-                'client_secret': CLIENT_SECRET,
-                'refresh_token': REFRESH_TOKEN,
-                'grant_type': 'refresh_token'
-            })
-            data = response.json()
-            token_cache['access_token'] = data['access_token']
-            token_cache['expiry'] = now + data['expires_in']
-        finally:
-            token_cache['refresh_promise'] = None
-
-    token_cache['refresh_promise'] = threading.Thread(target=refresh_token)
-    token_cache['refresh_promise'].start()
-    token_cache['refresh_promise'].join()
-    return token_cache['access_token']
-
-def get_location():
-    current_seconds = time.localtime().tm_sec
-    return 'europe-west1' if current_seconds < 30 else 'us-east5'
-
-def construct_api_url(location):
-    return f'https://{location}-aiplatform.googleapis.com/v1/projects/{PROJECT_ID}/locations/{location}/publishers/anthropic/models/{MODEL}:streamRawPredict'
-
-@app.route('/ai/v1/messages', methods=['POST', 'OPTIONS'])
-def handle_request():
-    if request.method == 'OPTIONS':
-        return handle_options()
-
-    api_key = request.headers.get('x-api-key')
-    if api_key != API_KEY:
-        error_response = make_response(jsonify({
-            'type': 'error',
-            'error': {
-                'type': 'permission_error',
-                'message': 'Your API key does not have permission to use the specified resource.'
-            }
-        }), 403)
-        error_response.headers['Access-Control-Allow-Origin'] = '*'
-        error_response.headers['Access-Control-Allow-Methods'] = 'POST, GET, OPTIONS, DELETE, HEAD'
-        error_response.headers['Access-Control-Allow-Headers'] = 'Content-Type, Authorization, x-api-key, anthropic-version, model'
-        return error_response
-
-    access_token = get_access_token()
-    location = get_location()
-    api_url = construct_api_url(location)
-
-    request_body = request.json
-
-    if 'anthropic_version' in request_body:
-        del request_body['anthropic_version']
-    if 'model' in request_body:
-        del request_body['model']
-
-    request_body['anthropic_version'] = 'vertex-2023-10-16'
-
-    headers = {
-        'Authorization': f'Bearer {access_token}',
-        'Content-Type': 'application/json; charset=utf-8'
-    }
-
-    response = requests.post(api_url, headers=headers, json=request_body)
-    modified_response = make_response(response.content, response.status_code)
-    modified_response.headers['Access-Control-Allow-Origin'] = '*'
-    modified_response.headers['Access-Control-Allow-Methods'] = 'POST, GET, OPTIONS'
-    modified_response.headers['Access-Control-Allow-Headers'] = 'Content-Type, Authorization, x-api-key, anthropic-version, model'
-
-    return modified_response
-
-def handle_options():
-    headers = {
-        'Access-Control-Allow-Origin': '*',
-        'Access-Control-Allow-Methods': 'POST, GET, OPTIONS',
-        'Access-Control-Allow-Headers': 'Content-Type, Authorization, x-api-key, anthropic-version, model'
-    }
-    return '', 204, headers
-
-if __name__ == '__main__':
-    app.run(port=8080)