【GAS】Vertex AI APIでブログのパーマリンクを自動生成する

1
/**
2
 * @return {null}
3
*/
4
function logoutOauthSvcForVertexAi() {
5
  const oauthMgr = new OauthServiceMgr();
6
  const service = oauthMgr.getVertexAiService();
7
  service.reset();
8
  const body = `<p>Session has reset on Vertex AI API.</p>`;
9
  const template = HtmlService.createTemplate(body);
10
  const page = template.evaluate();
11
  SpreadsheetApp.getUi().showModalDialog(page, "Logged out from Google API");
12
}
13

14
/**
15
 * @param {string} request
16
 * @return {HtmlOutput}
17
*/
18
function authCallbackForVertexAi(request) {
19
  const oauthMgr = new OauthServiceMgr();
20
  const service = oauthMgr.getVertexAiService();
21
  const isAuthorized = service.handleCallback(request);
22
  console.log(`authCallbackForVertexAi: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx`);
23
  if (isAuthorized) {
24
    return HtmlService.createHtmlOutput("Success! You can close this tab. Redo autocreate a permalink.");
25
  } else {
26
    return HtmlService.createHtmlOutput("Denied. You can close this tab");
27
  }
28
}
29

30
/**
31
 * @class
32
*/
33
class OauthServiceMgr {
34
  /**
35
   * @constructor
36
   * @return {null}
37
  */
38
  constructor(){
39

40
  }
41
  /**
42
   * @classmethod
43
   * @return {OAuth2.Service_}
44
  */
45
  getVertexAiService(){
46
    const id = VERTEX_AI_CLIENT_ID;
47
    const secret = VERTEX_AI_CLIENT_SECRET;
48
    console.log(`getVertexAiService: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx`);
49
    return OAuth2.createService("VERTEX_AI_API")
50
      .setAuthorizationBaseUrl("https://accounts.google.com/o/oauth2/auth")
51
      .setTokenUrl("https://accounts.google.com/o/oauth2/token")
52
      .setClientId(id)
53
      .setClientSecret(secret)
54
      .setCallbackFunction("authCallbackForVertexAi")
55
      .setPropertyStore(PropertiesService.getScriptProperties())
56
      .setScope("https://www.googleapis.com/auth/cloud-platform")
57
      .setParam("login_hint", Session.getActiveUser().getEmail())
58
  }
59
  /**
60
   * @classmethod
61
   * @param {OAuth2.Service_} service
62
   * @return {null}
63
  */
64
  authenticateVertexAi(service){
65
    const authorizationUrl = service.getAuthorizationUrl();
66
    const body = `<a href="<?= authorizationUrl ?>" target="_blank">Authenticate</a>`;
67
    let template = HtmlService.createTemplate(body);
68
    template.authorizationUrl = authorizationUrl;
69
    let page = template.evaluate();
70
    SpreadsheetApp.getUi().showModalDialog(page, "Google API Authentication");
71
    console.log(`authenticateVertexAi: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx`);
72
  }
73
}
74

75
/**
76
 * @return {boolean}
77
*/
78
function createPermalinkWithLlm(){
79
  const myScriptName = MY_SCRIPT_NAME;
80
  const sheet1st = SHEET_NAME_DISSEMINATING_1ST;
81
   /**
82
   * @description Create a permalink with the generative AI on Vertex AI API.
83
   * @param {string} apiToken
84
   * @param {string} model
85
   * @param {string} prompt
86
   * @return {number} Return -1 if not duplicated.
87
  */
88
  function requestToVertexAi(apiToken, model, prompt){
89
    const projectId = GOOGLE_CLOUD_PROJECT_ID;
90
    const location = "us-central1";
91
    const endpoint = `https://${location}-aiplatform.googleapis.com/v1/projects/${projectId}/locations/${location}/publishers/google/models/${model}:streamGenerateContent`;
92
    const options = {
93
      "muteHttpExceptions": true
94
      , "method" : "post"
95
      , "headers" : {
96
        "Content-Type": "application/json"
97
        , "Authorization": `Bearer ${apiToken}`
98
      }
99
      , "payload" : JSON.stringify({
100
        "contents": {
101
          "role": "user"
102
          , "parts": [
103
            {
104
              "text": `${prompt}`
105
            }
106
          ]
107
        }
108
    })
109
    };
110
    const response = UrlFetchApp.fetch(endpoint, options);
111
    return JSON.parse(response.getContentText());
112
  }
113

114
  function promptToGenAi(token) {
115
    const model = "gemini-1.5-flash-001";
116
    // const model = "gemini-1.5-flash-002";
117
    const prompt = "Explain how AI works.";
118

119
    const result = requestToVertexAi(token, model, prompt);
120
    const lines = result.map(c => {
121
      return c["candidates"][0]["content"]["parts"][0]["text"];
122
    });
123
    const sep = " "; // half-width space
124
    const sentence = lines.join(sep);
125
    console.log(result);
126
    console.log(`promptToGenAi: 1111111111111111111111111111111111111111111111111`);
127
    console.log(result[0]["candidates"][0]["content"]["parts"][0]["text"]);
128
    console.log(`promptToGenAi: 77777777777777777777777777777777777777777777777777`);
129
    console.log(lines);
130
    console.log(sentence);
131
    return result;
132
  }
133

134
  const oauthMgr = new OauthServiceMgr();
135
  const svc = oauthMgr.getVertexAiService();
136
  if (!svc.hasAccess()) {
137
    oauthMgr.authenticateVertexAi(svc);
138
    return false;
139
  }
140

141
  const apiToken = svc.getAccessToken();
142
  promptToGenAi(apiToken);
143

144
  return true;
145
}

1
/**
2
 * @return {boolean}
3
*/
4
function createPermalinkWithLlm(){
5
  const myScriptName = MY_SCRIPT_NAME;
6
  const sheet1st = SHEET_NAME_DISSEMINATING_1ST;
7

8
  /**
9
   * @param {string} sheetName
10
   * @return {any[][]}
11
  */
12
  const getAllRecords = sheetName => {
13
    const sheet = SpreadsheetApp.getActive().getSheetByName(sheetName);
14
    const records = readGssRecords(sheet);
15
    return records;
16
  };
17
  /**
18
   * @param {any[][]} records
19
   * @return {string[]}
20
  */
21
  const getTitlesAndPermalinks = records => {
22
    const col1 = COLUMN_FOR_TITLE_1ST;
23
    const col2 = COLUMN_FOR_PERMALINK_1ST;
24
    const permalinks = records.map(r => {
25
      return [r[col1 - 1], r[col2 - 1]];
26
    })
27
    return permalinks;
28
  };
29
  /**
30
   * @description Check duplication to return index of duplicated string.
31
   * @param {string[]} arr
32
   * @param {string} target
33
   * @return {number} Return -1 if not duplicated.
34
  */
35
  const checkDuplicationInArray = (arr, target) => {
36
    const index = arr.indexOf(target);
37
    return index;
38
  };
39

40
   /**
41
   * @description Create a permalink with the generative AI on Vertex AI API.
42
   * @param {string} apiToken
43
   * @param {string} model
44
   * @param {string} prompt
45
   * @return {number} Return -1 if not duplicated.
46
  */
47
  function requestToVertexAi(apiToken, model, prompt){
48
    const projectId = GOOGLE_CLOUD_PROJECT_ID;
49
    const location = "us-central1";
50
    const endpoint = `https://${location}-aiplatform.googleapis.com/v1/projects/${projectId}/locations/${location}/publishers/google/models/${model}:streamGenerateContent`;
51
    const options = {
52
      "muteHttpExceptions": true
53
      , "method" : "post"
54
      , "headers" : {
55
        "Content-Type": "application/json"
56
        , "Authorization": `Bearer ${apiToken}`
57
      }
58
      , "payload" : JSON.stringify({
59
        "contents": {
60
          "role": "user"
61
          , "parts": [
62
            {
63
              "text": `${prompt}`
64
            }
65
          ]
66
        }
67
    })
68
    };
69
    const response = UrlFetchApp.fetch(endpoint, options);
70
    return JSON.parse(response.getContentText());
71
  }
72

73
  function promptToGenAi(token) {
74
    const model = "gemini-1.5-flash-001";
75
    // const model = "gemini-1.5-flash-002";
76
    const prompt = "Explain how AI works.";
77

78
    const result = requestToVertexAi(token, model, prompt);
79
    const lines = result.map(c => {
80
      return c["candidates"][0]["content"]["parts"][0]["text"];
81
    });
82
    const sep = " "; // half-width space
83
    const sentence = lines.join(sep);
84
    console.log(result);
85
    console.log(`promptToGenAi: 1111111111111111111111111111111111111111111111111`);
86
    console.log(lines);
87
    console.log(sentence);
88
    return sentence;
89
  }
90

91
  function createPermalinks(titlesAndPermalinks){
92
    let generatedPermalinks = promptToGenAi();
93
    const permalinks = titlesAndPermalinks.map(rec => {
94
      return rec[1];
95
    })
96
    const filteredPermalinks = generatedPermalinks.filter((p) => checkDuplicationInArray(permalinks, p) === -1);
97
    // const index = checkDuplicationInArray(permalinks, searchString);
98
    console.log(filteredPermalinks);
99
    return filteredPermalinks;
100
  }
101

102
  const oauthMgr = new OauthServiceMgr();
103
  const svc = oauthMgr.getVertexAiService();
104
  if (!svc.hasAccess()) {
105
    oauthMgr.authenticateVertexAi(svc);
106
    return false;
107
  }
108

109
  const records = getAllRecords(sheet1st);
110
  console.log(records);
111
  console.log(`createPermalinkWithLlm: 1111111111111111111111111111111111111111111111111`);
112
  const titlesAndPermalinks = getTitlesAndPermalinks(records);
113
  console.log(titlesAndPermalinks);
114
  console.log(`createPermalinkWithLlm: 3333333333333333333333333333333333333333333333333`);
115

116
  const apiToken = svc.getAccessToken();
117
  promptToGenAi(apiToken);
118
}

1
// The functions to authenticate with OAuth2.0: START ================================================================
2

3
/**
4
 * @return {null}
5
*/
6
function logoutOauthSvcForVertexAi() {
7
  /**
8
   * @param {string} body
9
   * @param {string} title
10
   * @return {null}
11
  */
12
  const displayHtmlPage = (body, title) => {
13
    const template = HtmlService.createTemplate(body);
14
    const page = template.evaluate();
15
    SpreadsheetApp.getUi().showModalDialog(page, title);
16
  }
17
  const oauthMgr = new OauthServiceMgr();
18
  const service = oauthMgr.getVertexAiService();
19
  service.reset();
20
  displayHtmlPage(`<p>Session has reset on Vertex AI API.</p>`, "Logged out from Google API");
21
}
22

23
/**
24
 * @param {string} request
25
 * @return {HtmlOutput}
26
*/
27
function authCallbackForVertexAi(request) {
28
  const oauthMgr = new OauthServiceMgr();
29
  const service = oauthMgr.getVertexAiService();
30
  const isAuthorized = service.handleCallback(request);
31
  console.log(`authCallbackForVertexAi: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx`);
32
  if (isAuthorized) {
33
    return HtmlService.createHtmlOutput("Success! You can close this tab. Redo autocreate a permalink.");
34
  } else {
35
    return HtmlService.createHtmlOutput("Denied. You can close this tab");
36
  }
37
}
38

39
/**
40
 * @class
41
*/
42
class OauthServiceMgr {
43
  /**
44
   * @constructor
45
   * @return {null}
46
  */
47
  constructor(){
48

49
  }
50
  /**
51
   * @classmethod
52
   * @return {OAuth2.Service_}
53
  */
54
  getVertexAiService(){
55
    const id = VERTEX_AI_CLIENT_ID;
56
    const secret = VERTEX_AI_CLIENT_SECRET;
57
    console.log(`getVertexAiService: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx`);
58
    return OAuth2.createService("VERTEX_AI_API")
59
      .setAuthorizationBaseUrl("https://accounts.google.com/o/oauth2/auth")
60
      .setTokenUrl("https://accounts.google.com/o/oauth2/token")
61
      .setClientId(id)
62
      .setClientSecret(secret)
63
      .setCallbackFunction("authCallbackForVertexAi")
64
      .setPropertyStore(PropertiesService.getScriptProperties())
65
      .setScope("https://www.googleapis.com/auth/cloud-platform")
66
      .setParam("login_hint", Session.getActiveUser().getEmail())
67
  }
68
  /**
69
   * @classmethod
70
   * @param {OAuth2.Service_} service
71
   * @return {null}
72
  */
73
  authenticateVertexAi(service){
74
    const authorizationUrl = service.getAuthorizationUrl();
75
    const body = `<a href="<?= authorizationUrl ?>" target="_blank">Authenticate</a>`;
76
    let template = HtmlService.createTemplate(body);
77
    template.authorizationUrl = authorizationUrl;
78
    let page = template.evaluate();
79
    SpreadsheetApp.getUi().showModalDialog(page, "Google API Authentication");
80
    console.log(`authenticateVertexAi: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx`);
81
  }
82
}
83

84
// The functions to authenticate with OAuth2.0: END ================================================================
85

86
// The functions to generate permalinks with Vertex AI: START ================================================================
87

88
/**
89
 * @return {boolean}
90
*/
91
function createPermalinkWithLlm(){
92
  const myScriptName = MY_SCRIPT_NAME;
93
  const sheet1st = SHEET_NAME_DISSEMINATING_1ST;
94

95
  /**
96
   * @param {string} sheetName
97
   * @return {any[][]}
98
  */
99
  const getAllRecords = sheetName => {
100
    const sheet = SpreadsheetApp.getActive().getSheetByName(sheetName);
101
    const records = readGssRecords(sheet);
102
    return records;
103
  };
104

105
   /**
106
   * @description Create a permalink with the generative AI on Vertex AI API.
107
   * @param {string} apiToken
108
   * @param {string} model
109
   * @param {string} prompt
110
   * @return {number} Return -1 if not duplicated.
111
  */
112
  const requestToVertexAi = (apiToken, model, prompt) => {
113
    const projectId = GOOGLE_CLOUD_PROJECT_ID;
114
    const location = "us-central1";
115
    const endpoint = `https://${location}-aiplatform.googleapis.com/v1/projects/${projectId}/locations/${location}/publishers/google/models/${model}:streamGenerateContent`;
116
    const options = {
117
      "muteHttpExceptions": true
118
      , "method" : "post"
119
      , "headers" : {
120
        "Content-Type": "application/json"
121
        , "Authorization": `Bearer ${apiToken}`
122
      }
123
      , "payload" : JSON.stringify({
124
        "contents": {
125
          "role": "user"
126
          , "parts": [
127
            {
128
              "text": `${prompt}`
129
            }
130
          ]
131
        }
132
    })
133
    };
134
    const response = UrlFetchApp.fetch(endpoint, options);
135
    return JSON.parse(response.getContentText());
136
  }
137

138
  /**
139
   * @param {string} apiToken
140
   * @param {string} prompt
141
   * @return {string}
142
  */
143
  const promptToGenAi = (apiToken, prompt) => {
144
    const model = "gemini-1.5-flash-001";
145
    // const model = "gemini-1.5-flash-002";
146

147
    const result = requestToVertexAi(apiToken, model, prompt);
148
    const lines = result.map(c => {
149
      return c["candidates"][0]["content"]["parts"][0]["text"];
150
    });
151
    const sep = " "; // half-width space
152
    const sentence = lines.join(sep);
153
    console.log(result);
154
    console.log(`promptToGenAi: 1111111111111111111111111111111111111111111111111`);
155
    console.log(lines);
156
    console.log(`promptToGenAi: 77777777777777777777777777777777777777777777777777`);
157
    console.log(sentence);
158
    return sentence;
159
  }
160
  /**
161
   * @param {string} apiToken
162
   * @param {string} newBlogTitle
163
   * @return {string[]}
164
  */
165
  const createPermalinks = (apiToken, newBlogTitle) => {
166
    /**
167
     * @param {any[][]} records
168
     * @return {string[][]}
169
    */
170
    const getTitlesAndPermalinks = records => {
171
      const col1 = COLUMN_FOR_TITLE_1ST;
172
      const col2 = COLUMN_FOR_PERMALINK_1ST;
173
      let tps = records.map(r => {
174
        return [r[col1 - 1], r[col2 - 1]];
175
      });
176
      tps = tps.filter(tp => tp[0] !== "" && tp[1] !== "");
177
      return tps;
178
    };
179
    /**
180
     * @description Check duplication to return index of duplicated string.
181
     * @param {string[]} arr
182
     * @param {string} target
183
     * @return {number} Return -1 if not duplicated.
184
    */
185
    const checkDuplicationInArray = (arr, target) => {
186
      const index = arr.indexOf(target);
187
      return index;
188
    };
189
    /**
190
     * @param {string} data
191
     * @return {string[]}
192
     * @example
193
     * data = '```[  "gas-gemini-api-autogenerate-permalink",  "gas-gemini-api-auto-permalink",  "gas-gemini-api-blog-permalink",  "gas-auto-generate-blog-permalink-gemini-api",  "gemini-api-for-blog-permalink-with-gas"]```'
194
     * elements = [ 'gas-gemini-api-autogenerate-permalink', 'gas-gemini-api-auto-permalink', 'gas-gemini-api-blog-permalink', 'gas-auto-generate-blog-permalink-gemini-api', 'gemini-api-for-blog-permalink-with-gas' ]
195
    */
196
    const extractElementsFromString = (data) => {
197
      const elements = data.match(/"([^"]+)"/g).map(item => item.replace(/"/g, ''));
198
      console.log(`LlmPrompter.extractElementsFromString: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx`);
199
      return elements;
200
    }
201

202
    const records = getAllRecords(sheet1st);
203
    console.log(records);
204
    console.log(`createPermalinks: 1111111111111111111111111111111111111111111111111`);
205
    const srcTitlesAndPermalinks = getTitlesAndPermalinks(records);
206
    const srcTitlesAndPermalinksToShow = srcTitlesAndPermalinks.map(tp => {
207
      return `[${tp[0]},${tp[1]}]`;
208
    });
209
    console.log(srcTitlesAndPermalinks);
210
    console.log(`createPermalinks: 3333333333333333333333333333333333333333333333333`);
211
    console.log(srcTitlesAndPermalinksToShow);
212
    console.log(`createPermalinks: 4444444444444444444444444444444444444444444444444`);
213

214
    const prompt = `今まで書いたブログ記事の[# 題名とパーマリンクのペアの一覧]を参考に、[# パーマリンクの要件]を満たしたパーマリンクを作成して。\n[# 題名とパーマリンクのペアの一覧]\n---\n${srcTitlesAndPermalinksToShow}\n---\n[# 新しいブログ記事の題名]\n---\n【GAS】Gemini APIでブログのパーマリンクを自動生成する\n---\n[# パーマリンクの要件]\n---\n- [# 新しいブログ記事の題名]に適している\n- 文字数は30文字以内である\n- 5通り作って、コードブロックの中に配列として出力する。その配列は1文字目の昇順にソートする。\n---\n`;
215
    const generatedPermalinkSentence = promptToGenAi(apiToken, prompt);
216
    console.log(generatedPermalinkSentence);
217
    console.log(`createPermalinks: 555555555555555555555555555555555555555555555555`);
218
    const generatedPermalinks = extractElementsFromString(generatedPermalinkSentence);
219
    console.log(generatedPermalinks);
220
    console.log(`createPermalinks: 6666666666666666666666666666666666666666666666666`);
221
    const srcPermalinks = srcTitlesAndPermalinks.map(rec => {
222
      return rec[1];
223
    })
224
    console.log(srcPermalinks);
225
    console.log(`createPermalinks: 777777777777777777777777777777777777777777777777`);
226

227
    const filteredPermalinks = generatedPermalinks.filter((p) => checkDuplicationInArray(srcPermalinks, p) === -1);
228
    filteredPermalinks.sort();
229
    console.log(`createPermalinks: 9999999999999999999999999999999999999999999999999`);
230
    console.log(filteredPermalinks);
231
    return filteredPermalinks;
232
  }
233

234
  /**
235
   * @param {string} body
236
   * @param {string} title
237
   * @return {null}
238
  */
239
  const displayHtmlPlainPage = (body, title) => {
240
    const template = HtmlService.createTemplate(body);
241
    const page = template.evaluate();
242
    SpreadsheetApp.getUi().showModalDialog(page, title);
243
  }
244

245
  const oauthMgr = new OauthServiceMgr();
246
  const svc = oauthMgr.getVertexAiService();
247
  if (!svc.hasAccess()) {
248
    oauthMgr.authenticateVertexAi(svc);
249
    return false;
250
  }
251
  console.log(`createPermalinkWithLlm: 222222222222222222222222222222222222222222222222`);
252

253
  const apiToken = svc.getAccessToken();
254
  const newTitle = "スプレッドシート上にダイアログを表示して入力するなり、シートから取得する。";
255
  let permalinks = createPermalinks(apiToken, newTitle);
256
  permalinks = permalinks.map(p => {
257
    return `"${p}"`;
258
  });
259
  const permalinkSentence = permalinks.reduce((prev, curr) => {
260
    return `${prev}\n${curr}`
261
  });
262
  console.log(permalinks);
263
  console.log(`createPermalinkWithLlm: 666666666666666666666666666666666666666666666666`);
264
  console.log(permalinkSentence);
265
  console.log(`createPermalinkWithLlm: 777777777777777777777777777777777777777777777777`);
266

267
  let text = `<p>Generated permalinks are following.</p>`;
268
  text = `${text}<pre><code>${permalinkSentence}</code></pre>`;
269

270
  displayHtml("index_html", "Create a permalink with Vertex AI is Terminated...", `${text}`);
271
  console.log(`createPermalinkWithLlm: ==============================================`);
272

273
  return true;
274
}
275

276
// The functions to generate permalinks with Vertex AI: END ================================================================