genaicode 0.0.37 → 0.2.0

package/src/ai-service/chat-gpt.js

@@ -1,126 +0,0 @@
-import OpenAI from 'openai';
-import { printTokenUsageAndCost, processFunctionCalls } from './common.js';
-
-/**
- * This function generates content using the OpenAI chat model.
- */
-export async function generateContent(prompt, functionDefs, requiredFunctionName, temperature, cheap = false) {
-  const openai = new OpenAI();
-
-  const messages = prompt
-    .map((item) => {
-      if (item.type === 'systemPrompt') {
-        return {
-          role: 'system',
-          content: item.systemPrompt,
-        };
-      } else if (item.type === 'user') {
-        return [
-          ...(item.functionResponses ?? []).map((response) => ({
-            role: 'tool',
-            name: response.name,
-            content: response.content ?? '',
-            tool_call_id: response.name,
-          })),
-          {
-            role: 'user',
-            content:
-              item.images?.length > 0
-                ? [
-                    ...item.images.map((image) => ({
-                      type: 'image_url',
-                      image_url: {
-                        url: 'data:' + image.mediaType + ';base64,' + image.base64url,
-                      },
-                    })),
-                    {
-                      type: 'text',
-                      text: item.text,
-                    },
-                  ]
-                : item.text,
-          },
-        ];
-      } else if (item.type === 'assistant') {
-        return {
-          role: 'assistant',
-          ...(item.text ? { content: item.text } : {}),
-          tool_calls: item.functionCalls.map((call) => ({
-            type: 'function',
-            function: { name: call.name, arguments: JSON.stringify(call.args ?? {}) },
-            id: call.name,
-          })),
-        };
-      }
-    })
-    .flat();
-
-  const model = cheap ? 'gpt-4o-mini' : 'gpt-4o-2024-08-06';
-  console.log(`Using OpenAI model: ${model}`);
-
-  let retryCount = 0;
-  let response;
-  while (retryCount < 3) {
-    try {
-      response = await openai.chat.completions.create({
-        model: model,
-        messages,
-        tools: functionDefs.map((funDef) => ({ type: 'function', function: funDef })),
-        tool_choice: requiredFunctionName ? { type: 'function', function: { name: requiredFunctionName } } : 'required',
-        temperature: temperature,
-      });
-      break; // Exit loop if successful
-    } catch (error) {
-      if (error.response?.headers?.['x-ratelimit-limit-tokens']) {
-        const rateLimitTokens = parseInt(error.response.headers['x-ratelimit-limit-tokens'], 10);
-        const retryAfter = error.response.headers['retry-after']
-          ? parseInt(error.response.headers['retry-after'], 10)
-          : 1;
-        console.log(
-          `Rate limited. Token limit: ${rateLimitTokens}. Retrying after ${retryAfter} seconds. Attempt ${retryCount + 1} of 3.`,
-        );
-        await new Promise((resolve) => setTimeout(resolve, retryAfter * 1000));
-        retryCount++;
-      } else {
-        console.error('An error occurred:', error);
-        throw error; // Re-throw the error if it's not a rate limit error
-      }
-    }
-  }
-
-  if (retryCount === 3) {
-    console.error('Failed to complete request after 3 attempts due to rate limiting.');
-    throw new Error('Rate limit exceeded. Operation aborted.');
-  }
-
-  // Print token usage for chat gpt
-  const usage = {
-    inputTokens: response.usage.prompt_tokens,
-    outputTokens: response.usage.completion_tokens,
-    totalTokens: response.usage.total_tokens,
-  };
-  printTokenUsageAndCost(usage, 0.000005, 0.000015);
-
-  const responseMessage = response.choices[0].message;
-
-  if (responseMessage.content?.message) {
-    console.log('Message', responseMessage.content.message);
-  }
-
-  const toolCalls = responseMessage.tool_calls;
-  if (responseMessage.tool_calls) {
-    const functionCalls = toolCalls.map((call) => {
-      const name = call.function.name;
-      const args = JSON.parse(call.function.arguments);
-
-      return {
-        name,
-        args,
-      };
-    });
-
-    return processFunctionCalls(functionCalls);
-  } else {
-    throw new Error('No tool calls found in response');
-  }
-}

package/src/ai-service/common.js

@@ -1,49 +0,0 @@
-import assert from 'node:assert';
-import { functionDefs } from '../prompt/function-calling.js';
-
-/**
- * Common function to print token usage and estimated cost
- * @param {Object} usage Token usage object
- * @param {number} inputCostPerToken Cost per input token
- * @param {number} outputCostPerToken Cost per output token
- */
-export function printTokenUsageAndCost(usage, inputCostPerToken, outputCostPerToken) {
-  console.log('Token Usage:');
-  console.log('  - Input tokens: ', usage.inputTokens);
-  console.log('  - Output tokens: ', usage.outputTokens);
-  console.log('  - Total tokens: ', usage.totalTokens);
-  if (usage.cacheCreateTokens) {
-    console.log('  - Cache create tokens: ', usage.cacheCreateTokens);
-  }
-  if (usage.cacheReadTokens) {
-    console.log('  - Cache read tokens: ', usage.cacheReadTokens);
-  }
-
-  const inputCost =
-    usage.inputTokens * inputCostPerToken +
-    (usage.cacheCreateTokens ?? 0) * inputCostPerToken * 1.25 +
-    (usage.cacheReadTokens ?? 0) * inputCostPerToken * 0.2;
-  const outputCost = usage.outputTokens * outputCostPerToken;
-  const totalCost = inputCost + outputCost;
-  console.log('  - Estimated cost: ', totalCost.toFixed(6), ' USD');
-}
-
-/**
- * Common function to process function calls and explanations
- * @param {Array} functionCalls Array of function calls
- * @returns {Array} Processed function calls
- */
-export function processFunctionCalls(functionCalls) {
-  const unknownFunctionCalls = functionCalls.filter((call) => !functionDefs.some((fd) => fd.name === call.name));
-  assert(
-    unknownFunctionCalls.length === 0,
-    'Unknown function name: ' + unknownFunctionCalls.map((call) => call.name).join(', '),
-  );
-
-  console.log(
-    'Explanations:',
-    functionCalls.filter((fn) => fn.name === 'explanation').map((call) => call.args.text),
-  );
-
-  return functionCalls; //.filter((fn) => fn.name !== 'explanation');
-}

package/src/ai-service/common.test.js

@@ -1,107 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { printTokenUsageAndCost, processFunctionCalls } from './common.js';
-import { functionDefs } from '../prompt/function-calling.js';
-
-// Mock cli-params.js
-vi.mock('../cli/cli-params.js', () => ({
-  chatGpt: true,
-  anthropic: false,
-  vertexAi: false,
-  vertexAiClaude: false,
-  temperature: 0.7,
-  cheap: false,
-  geminiBlockNone: false,
-  requireExplanations: false,
-  vision: false,
-}));
-
-describe('printTokenUsageAndCost', () => {
-  let consoleLogSpy;
-
-  beforeEach(() => {
-    consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-  });
-
-  afterEach(() => {
-    consoleLogSpy.mockRestore();
-  });
-
-  it('should correctly log token usage and estimated cost', () => {
-    const usage = {
-      inputTokens: 100,
-      outputTokens: 50,
-      totalTokens: 150,
-    };
-    const inputCostPerToken = 0.0001;
-    const outputCostPerToken = 0.0002;
-
-    printTokenUsageAndCost(usage, inputCostPerToken, outputCostPerToken);
-
-    expect(consoleLogSpy).toHaveBeenCalledTimes(5);
-    expect(consoleLogSpy).toHaveBeenCalledWith('Token Usage:');
-    expect(consoleLogSpy).toHaveBeenCalledWith('  - Input tokens: ', 100);
-    expect(consoleLogSpy).toHaveBeenCalledWith('  - Output tokens: ', 50);
-    expect(consoleLogSpy).toHaveBeenCalledWith('  - Total tokens: ', 150);
-    expect(consoleLogSpy).toHaveBeenCalledWith('  - Estimated cost: ', '0.020000', ' USD');
-  });
-
-  it('should handle zero tokens correctly', () => {
-    const usage = {
-      inputTokens: 0,
-      outputTokens: 0,
-      totalTokens: 0,
-    };
-    const inputCostPerToken = 0.0001;
-    const outputCostPerToken = 0.0002;
-
-    printTokenUsageAndCost(usage, inputCostPerToken, outputCostPerToken);
-
-    expect(consoleLogSpy).toHaveBeenCalledWith('  - Estimated cost: ', '0.000000', ' USD');
-  });
-});
-
-describe('processFunctionCalls', () => {
-  it('should process valid function calls correctly', () => {
-    const validFunctionCalls = [
-      { name: 'explanation', args: { text: 'This is an explanation' } },
-      { name: functionDefs[0].name, args: {} },
-    ];
-
-    const result = processFunctionCalls(validFunctionCalls);
-
-    expect(result).toEqual(validFunctionCalls);
-  });
-
-  it('should throw an error for unknown function names', () => {
-    const invalidFunctionCalls = [{ name: 'unknownFunction', args: {} }];
-
-    expect(() => processFunctionCalls(invalidFunctionCalls)).toThrow('Unknown function name: unknownFunction');
-  });
-
-  it('should correctly handle explanations', () => {
-    const consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-
-    const functionCallsWithExplanation = [
-      { name: 'explanation', args: { text: 'This is an explanation' } },
-      { name: functionDefs[0].name, args: {} },
-    ];
-
-    processFunctionCalls(functionCallsWithExplanation);
-
-    expect(consoleLogSpy).toHaveBeenCalledWith('Explanations:', ['This is an explanation']);
-
-    consoleLogSpy.mockRestore();
-  });
-
-  it('should return all function calls including explanations', () => {
-    const functionCalls = [
-      { name: 'explanation', args: { text: 'This is an explanation' } },
-      { name: functionDefs[0].name, args: {} },
-    ];
-
-    const result = processFunctionCalls(functionCalls);
-
-    expect(result).toEqual(functionCalls);
-    expect(result.length).toBe(2);
-  });
-});

package/src/ai-service/dall-e.js

@@ -1,50 +0,0 @@
-import OpenAI, { toFile } from 'openai';
-
-import { setTempBuffer } from '../files/temp-buffer.js';
-import { resizeImageBuffer } from '../images/resize-image.js';
-import { ensureAlpha } from '../images/ensure-alpha.js';
-
-/**
- * Generate an image using OpenAI's DALL-E model and save it to a file
- * @param {string} prompt - The description of the image to generate
- * @param {string|undefined} contextImagePath - The image to be used as a context
- * @param {{width: number, height: number}} size - The size of the image to generate
- * @param {boolean} cheap - Whether to use a cheaper model
- * @returns {Promise<string>} - The url of the image
- */
-export async function generateImage(prompt, contextImagePath, size, cheap = false) {
-  const openai = new OpenAI();
-
-  try {
-    const model = contextImagePath ? 'dall-e-2' : cheap ? 'dall-e-2' : 'dall-e-3';
-    console.log(`Using DALL-E model: ${model}`);
-
-    const options = {
-      model: model,
-      prompt: prompt,
-      n: 1,
-      size: '1024x1024',
-      response_format: 'url',
-    };
-    const response = contextImagePath
-      ? await openai.images.edit({ ...options, image: await toFile(await ensureAlpha(contextImagePath)) })
-      : await openai.images.generate(options);
-
-    let imageUrl = response.data[0].url;
-
-    if ((size.width !== 1024) | (size.height !== 1024)) {
-      console.log('Resizing image to desired size', size);
-      const imageResponse = await fetch(imageUrl);
-      const arrayBuffer = await imageResponse.arrayBuffer();
-      const buffer = Buffer.from(arrayBuffer);
-
-      imageUrl = setTempBuffer(await resizeImageBuffer(buffer, size));
-    }
-
-    console.log(`Image generated, url: ${imageUrl}`);
-    return imageUrl;
-  } catch (error) {
-    console.error('Error generating image:', error);
-    throw error;
-  }
-}

package/src/ai-service/vertex-ai-claude.js

@@ -1,99 +0,0 @@
-import { AnthropicVertex } from '@anthropic-ai/vertex-sdk';
-import { printTokenUsageAndCost, processFunctionCalls } from './common.js';
-
-/**
- * This function generates content using the Anthropic Claude model via Vertex AI.
- */
-export async function generateContent(prompt, functionDefs, requiredFunctionName, temperature, cheap = false) {
-  const projectId = process.env.GOOGLE_CLOUD_PROJECT;
-  const region = process.env.GOOGLE_CLOUD_REGION;
-
-  if (!projectId || !region) {
-    throw new Error('GOOGLE_CLOUD_PROJECT and GOOGLE_CLOUD_REGION environment variables must be set');
-  }
-
-  const client = new AnthropicVertex({
-    projectId,
-    region,
-  });
-
-  const messages = prompt
-    .filter((item) => item.type !== 'systemPrompt')
-    .map((item) => {
-      if (item.type === 'user') {
-        return {
-          role: 'user',
-          content: [
-            ...(item.functionResponses ?? []).map((response) => ({
-              type: 'tool_result',
-              tool_use_id: response.call_id ?? response.name,
-              content: response.content,
-              is_error: response.isError === true,
-            })),
-            ...(item.images ?? []).map((image) => ({
-              type: 'image',
-              source: {
-                type: 'base64',
-                media_type: image.mediaType,
-                data: image.base64url,
-              },
-            })),
-            { type: 'text', text: item.text },
-          ],
-        };
-      } else if (item.type === 'assistant') {
-        return {
-          role: 'assistant',
-          content: [
-            ...(item.text ? [{ type: 'text', text: item.text }] : []),
-            ...item.functionCalls.map((call) => ({
-              type: 'tool_use',
-              id: call.id ?? call.name,
-              name: call.name,
-              input: call.args ?? {},
-            })),
-          ],
-        };
-      }
-    });
-
-  const model = cheap ? 'claude-3-haiku@20240307' : 'claude-3-5-sonnet@20240620';
-  console.log(`Using Vertex AI Claude model: ${model}`);
-
-  const response = await client.messages.create({
-    model: model,
-    max_tokens: 4096,
-    temperature: temperature,
-    system: prompt.find((item) => item.type === 'systemPrompt').systemPrompt,
-    messages,
-    tools: functionDefs.map((fd) => ({
-      name: fd.name,
-      description: fd.description,
-      input_schema: fd.parameters,
-    })),
-    tool_choice: requiredFunctionName ? { type: 'tool', name: requiredFunctionName } : { type: 'any' },
-  });
-
-  // Print token usage for Anthropic Vertex AI
-  const usage = {
-    inputTokens: response.usage.input_tokens,
-    outputTokens: response.usage.output_tokens,
-    totalTokens: response.usage.input_tokens + response.usage.output_tokens,
-  };
-  printTokenUsageAndCost(usage, 3 / 1000 / 1000, 15 / 1000 / 1000);
-
-  const responseMessages = response.content.filter((item) => item.type !== 'tool_use');
-  if (responseMessages.length > 0) {
-    console.log('Response messages', responseMessages);
-  }
-
-  const functionCalls = response.content
-    .filter((item) => item.type === 'tool_use')
-    .map((item) => ({
-      id: item.id,
-      name: item.name,
-      args: item.input,
-    }));
-
-  return processFunctionCalls(functionCalls);
-}

package/src/ai-service/vertex-ai-imagen.js

@@ -1,78 +0,0 @@
-import fs from 'fs';
-import mime from 'mime-types';
-import { PredictionServiceClient, helpers } from '@google-cloud/aiplatform';
-import { setTempBuffer } from '../files/temp-buffer.js';
-import { resizeImageBuffer } from '../images/resize-image.js';
-
-/**
- * Generate an image using Vertex AI's Imagen model and return the image URL
- * @param {string} prompt - The description of the image to generate
- * @param {string|undefined} contextImagePath - The image to be used as a context
- * @param {{width: number, height: number}} size - The size of the image to generate
- * @param {boolean} cheap - Whether to use a cheaper model
- * @returns {Promise<string>} - The url of the generated image
- */
-export async function generateImage(prompt, contextImagePath, size, cheap = false) {
-  // Initialize the PredictionServiceClient
-  const client = new PredictionServiceClient({
-    apiEndpoint: `${process.env.GOOGLE_CLOUD_REGION}-aiplatform.googleapis.com`,
-  });
-
-  // Set the project and location
-  const projectId = process.env.GOOGLE_CLOUD_PROJECT;
-  const location = process.env.GOOGLE_CLOUD_REGION;
-
-  // Set the model name based on the cheap parameter
-  const modelName = contextImagePath
-    ? 'imagegeneration@002'
-    : cheap
-      ? 'imagen-3.0-fast-generate-001'
-      : 'imagen-3.0-generate-001';
-  console.log(`Using Vertex AI Imagen model: ${modelName}`);
-
-  try {
-    // Prepare the request
-    const request = {
-      endpoint: `projects/${projectId}/locations/${location}/publishers/google/models/${modelName}`,
-      instances: [
-        helpers.toValue({
-          prompt: prompt,
-          ...(contextImagePath
-            ? {
-                image: {
-                  bytesBase64Encoded: fs.readFileSync(contextImagePath, 'base64'),
-                  mediaType: mime.lookup(contextImagePath),
-                },
-              }
-            : {}),
-        }),
-      ],
-      parameters: helpers.toValue({
-        sampleCount: 1,
-        safetySetting: 'block_most',
-        personGeneration: 'allow_adult',
-        includeRaiReason: true,
-        language: 'auto',
-        aspectRatio: '1:1',
-        addWatermark: false,
-      }),
-    };
-
-    // Make the prediction request
-    const [response] = await client.predict(request);
-
-    if (response.predictions && response.predictions.length > 0) {
-      const prediction = helpers.fromValue(response.predictions[0]);
-      if (prediction.bytesBase64Encoded) {
-        console.log(`Image generated successfully, resizing to desired dimension`, size);
-        const buffer = Buffer.from(prediction.bytesBase64Encoded, 'base64');
-        return setTempBuffer(await resizeImageBuffer(buffer, size));
-      }
-    }
-
-    throw new Error('No image generated in the response');
-  } catch (error) {
-    console.error('Error generating image:', error);
-    throw error;
-  }
-}

package/src/ai-service/vertex-ai.js

@@ -1,156 +0,0 @@
-import assert from 'node:assert';
-import { VertexAI } from '@google-cloud/vertexai';
-import { printTokenUsageAndCost, processFunctionCalls } from './common.js';
-import { geminiBlockNone } from '../cli/cli-params.js';
-
-/**
- * This function generates content using the Gemini Pro model.
- */
-
-export async function generateContent(prompt, functionDefs, requiredFunctionName, temperature, cheap = false) {
-  const messages = prompt
-    .filter((item) => item.type !== 'systemPrompt')
-    .map((item) => {
-      if (item.type === 'user') {
-        return {
-          role: 'user',
-          parts: [
-            ...(item.functionResponses ?? []).map((response) => ({
-              functionResponse: {
-                name: response.name,
-                response: { name: response.name, content: response.content },
-              },
-            })),
-            ...(item.images ?? []).map((image) => ({
-              inlineData: {
-                mimeType: image.mediaType,
-                data: image.base64url,
-              },
-            })),
-            { text: item.text },
-          ],
-        };
-      } else if (item.type === 'assistant') {
-        return {
-          role: 'model',
-          parts: [
-            ...(item.text ? [{ text: item.text }] : []),
-            ...item.functionCalls.map((call) => ({
-              functionCall: {
-                name: call.name,
-                args: call.args ?? {},
-              },
-            })),
-          ],
-        };
-      }
-    });
-
-  const req = {
-    contents: messages,
-    tools: [
-      {
-        functionDeclarations: functionDefs,
-      },
-    ],
-    toolConfig: {
-      functionCallingConfig: {
-        mode: cheap ? undefined : 'ANY',
-        ...(!cheap && requiredFunctionName ? { allowedFunctionNames: [requiredFunctionName] } : {}),
-      },
-    },
-  };
-
-  const model = await getGenModel(prompt.find((item) => item.type === 'systemPrompt').systemPrompt, temperature, cheap);
-
-  assert(await verifyVertexMonkeyPatch(), 'Vertex AI Tool Config was not monkey patched');
-
-  const result = await model.generateContent(req);
-
-  // Print token usage
-  const usageMetadata = result.response.usageMetadata;
-  const usage = {
-    inputTokens: usageMetadata.promptTokenCount,
-    outputTokens: usageMetadata.candidatesTokenCount,
-    totalTokens: usageMetadata.totalTokenCount,
-  };
-  printTokenUsageAndCost(usage, 0.000125 / 1000, 0.000375 / 1000);
-
-  if (result.response.promptFeedback) {
-    console.log('Prompt feedback:');
-    console.log(JSON.stringify(result.response.promptFeedback, null, 2));
-  }
-
-  if (!result.response.candidates?.length > 0) {
-    console.log('Response:', result);
-    throw new Error('No candidates found');
-  }
-
-  const functionCalls = result.response.candidates
-    .map((candidate) => candidate.content.parts?.map((part) => part.functionCall))
-    .flat()
-    .filter((functionCall) => !!functionCall);
-
-  if (functionCalls.length === 0) {
-    const textResponse = result.response.candidates
-      .map((candidate) => candidate.content.parts?.map((part) => part.text))
-      .flat()
-      .filter((text) => !!text)
-      .join('\n');
-    console.log('No function calls, output text response if it exists:', textResponse);
-  }
-
-  return processFunctionCalls(functionCalls);
-}
-
-// A function to get the generative model
-// Modified to accept temperature parameter and cheap flag
-export function getGenModel(systemPrompt, temperature, cheap = false) {
-  // Initialize Vertex with your Cloud project and location
-  const vertex_ai = new VertexAI({});
-  const model = cheap ? 'gemini-1.5-flash-001' : 'gemini-1.5-pro-001';
-
-  console.log(`Using Vertex AI model: ${model}`);
-
-  // Instantiate the models
-  return vertex_ai.preview.getGenerativeModel({
-    model: model,
-    generationConfig: {
-      maxOutputTokens: 8192,
-      temperature: temperature,
-      topP: 0.95,
-    },
-    safetySettings: [
-      {
-        category: 'HARM_CATEGORY_HATE_SPEECH',
-        threshold: geminiBlockNone ? 'BLOCK_NONE' : 'BLOCK_LOW_AND_ABOVE',
-      },
-      {
-        category: 'HARM_CATEGORY_DANGEROUS_CONTENT',
-        threshold: geminiBlockNone ? 'BLOCK_NONE' : 'BLOCK_LOW_AND_ABOVE',
-      },
-      {
-        category: 'HARM_CATEGORY_SEXUALLY_EXPLICIT',
-        threshold: geminiBlockNone ? 'BLOCK_NONE' : 'BLOCK_LOW_AND_ABOVE',
-      },
-      {
-        category: 'HARM_CATEGORY_HARASSMENT',
-        threshold: geminiBlockNone ? 'BLOCK_NONE' : 'BLOCK_LOW_AND_ABOVE',
-      },
-    ],
-    systemInstruction: {
-      role: 'system',
-      parts: [
-        {
-          text: systemPrompt,
-        },
-      ],
-    },
-  });
-}
-
-export async function verifyVertexMonkeyPatch() {
-  return (await import('@google-cloud/vertexai/build/src/functions/generate_content.js')).generateContent
-    .toString()
-    .includes('// MONKEY PATCH TOOL_CONFIG');
-}