@razzium/piece-aimwork-backend 0.0.1

package/.eslintrc.json

@@ -0,0 +1,33 @@
+{
+  "extends": [
+    "../../../../.eslintrc.base.json"
+  ],
+  "ignorePatterns": [
+    "!**/*"
+  ],
+  "overrides": [
+    {
+      "files": [
+        "*.ts",
+        "*.tsx",
+        "*.js",
+        "*.jsx"
+      ],
+      "rules": {}
+    },
+    {
+      "files": [
+        "*.ts",
+        "*.tsx"
+      ],
+      "rules": {}
+    },
+    {
+      "files": [
+        "*.js",
+        "*.jsx"
+      ],
+      "rules": {}
+    }
+  ]
+}

package/README.md

@@ -0,0 +1,7 @@
+# pieces-aimw
+
+This library was generated with [Nx](https://nx.dev).
+
+## Building
+
+Run `nx build pieces-aimw` to build the library.

package/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "@razzium/piece-aimwork-backend",
+  "version": "0.0.1",
+  "dependencies": {
+    "tiktoken": "1.0.11"
+  }
+}

package/project.json

@@ -0,0 +1,45 @@
+{
+  "name": "pieces-aimw",
+  "$schema": "../../../../node_modules/nx/schemas/project-schema.json",
+  "sourceRoot": "packages/pieces/custom/aimw/src",
+  "projectType": "library",
+  "release": {
+    "version": {
+      "generatorOptions": {
+        "packageRoot": "dist/{projectRoot}",
+        "currentVersionResolver": "git-tag"
+      }
+    }
+  },
+  "tags": [],
+  "targets": {
+    "build": {
+      "executor": "@nx/js:tsc",
+      "outputs": [
+        "{options.outputPath}"
+      ],
+      "options": {
+        "outputPath": "dist/packages/pieces/custom/aimw",
+        "tsConfig": "packages/pieces/custom/aimw/tsconfig.lib.json",
+        "packageJson": "packages/pieces/custom/aimw/package.json",
+        "main": "packages/pieces/custom/aimw/src/index.ts",
+        "assets": [
+          "packages/pieces/custom/aimw/*.md"
+        ],
+        "buildableProjectDepsInPackageJsonType": "dependencies",
+        "updateBuildableProjectDepsInPackageJson": true
+      }
+    },
+    "nx-release-publish": {
+      "options": {
+        "packageRoot": "dist/{projectRoot}"
+      }
+    },
+    "lint": {
+      "executor": "@nx/eslint:lint",
+      "outputs": [
+        "{options.outputFile}"
+      ]
+    }
+  }
+}

package/src/index.ts

@@ -0,0 +1,105 @@
+import {
+  AuthenticationType,
+  HttpMethod,
+  createCustomApiCallAction,
+  httpClient,
+} from '@activepieces/pieces-common';
+import { PieceAuth, createPiece } from '@activepieces/pieces-framework';
+import { PieceCategory } from '@activepieces/shared';
+import { askAssistant } from './lib/actions/ask-assistant';
+import { generateImage } from './lib/actions/generate-image';
+import { askOpenAI } from './lib/actions/send-prompt';
+import { textToSpeech } from './lib/actions/text-to-speech';
+import { transcribeAction } from './lib/actions/transcriptions';
+import { translateAction } from './lib/actions/translation';
+import { visionPrompt } from './lib/actions/vision-prompt';
+import { baseUrl } from './lib/common/common';
+import { extractStructuredDataAction } from './lib/actions/extract-structure-data.action';
+
+export const AI_PROVIDERS_MAKRDOWN = {
+  aimw: `Follow these instructions to get your aimw API Key:
+
+  1. Go to your aimw platform.
+  2. Click on User (at bottom of left menu) Settings > Account > API Keys and click on 'Show'.
+  3. On 'API Key' section, click on "Create new secret key".
+  4. Show & Copy API Key (use shorcut).
+  `,
+  openai: `Follow these instructions to get your OpenAI API Key:
+
+1. Visit the following website: https://platform.openai.com/account/api-keys.
+2. Once on the website, locate and click on the option to obtain your OpenAI API Key.
+
+It is strongly recommended that you add your credit card information to your OpenAI account and upgrade to the paid plan **before** generating the API Key. This will help you prevent 429 errors.
+`,
+  anthropic: `Follow these instructions to get your Claude API Key:
+
+1. Visit the following website: https://console.anthropic.com/settings/keys.
+2. Once on the website, locate and click on the option to obtain your Claude API Key.
+`,
+  replicate: `Follow these instructions to get your Replicate API Key:
+
+1. Visit the following website: https://replicate.com/account/api-tokens.
+2. Once on the website, locate and click on the option to obtain your Replicate API Key.
+`,
+};
+
+export const openaiAuth = PieceAuth.SecretText({
+  description: AI_PROVIDERS_MAKRDOWN.aimw,
+  displayName: 'API Key',
+  required: true,
+  validate: async (auth) => {
+    try {
+      await httpClient.sendRequest<{
+        data: { id: string }[];
+      }>({
+        url: `${baseUrl}/models`,
+        method: HttpMethod.GET,
+        authentication: {
+          type: AuthenticationType.BEARER_TOKEN,
+          token: auth.auth as string,
+          //token: "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6ImZjY2Y4NzQyLTUyZWItNDdmZS05YWNjLTFjYzUyZjc2ZDdkYiJ9.NSWnWMO0ERGRU3QT4are2u-fo7R1FJxb2byyIwInTj4",
+        },
+      });
+      return {
+        valid: true,
+      };
+    } catch (e) {
+      return {
+        valid: false,
+        error: 'Invalid API key',
+      };
+    }
+  },
+});
+
+export const openai = createPiece({
+  displayName: 'Aimw',
+  description: 'Use the many tools AIMW has to offer.',
+  minimumSupportedRelease: '0.36.1',
+  logoUrl: 'https://applyz-main-bucket.fra1.cdn.digitaloceanspaces.com/aimw/logo.png',
+  categories: [PieceCategory.ARTIFICIAL_INTELLIGENCE],
+  auth: openaiAuth,
+  actions: [
+    askOpenAI,
+    // askAssistant,
+    // generateImage,
+    // visionPrompt,
+    // textToSpeech,
+    // transcribeAction,
+    // translateAction,
+    // extractStructuredDataAction,
+    // createCustomApiCallAction({
+    //   auth: openaiAuth,
+    //   baseUrl: () => baseUrl,
+    //   authMapping: async (auth) => {
+    //     return {
+    //       Authorization: `Bearer ${auth}`,
+    //     };
+    //   },
+    // }),
+  ],
+  authors: [
+    'razzium',
+  ],
+  triggers: [],
+});

package/src/lib/actions/ask-assistant.ts

@@ -0,0 +1,122 @@
+import {
+  createAction,
+  Property,
+  StoreScope,
+} from '@activepieces/pieces-framework';
+import OpenAI from 'openai';
+import { openaiAuth } from '../..';
+import { sleep } from '../common/common';
+import { z } from 'zod';
+import { propsValidation } from '@activepieces/pieces-common';
+
+export const askAssistant = createAction({
+  auth: openaiAuth,
+  name: 'ask_assistant',
+  displayName: 'Ask Assistant',
+  description: 'Ask a GPT assistant anything you want!',
+  props: {
+    assistant: Property.Dropdown({
+      displayName: 'Assistant',
+      required: true,
+      description: 'The assistant which will generate the completion.',
+      refreshers: [],
+      options: async ({ auth }) => {
+        if (!auth) {
+          return {
+            disabled: true,
+            placeholder: 'Enter your API key first',
+            options: [],
+          };
+        }
+        try {
+          const openai = new OpenAI({
+            apiKey: auth as string,
+          });
+          const assistants = await openai.beta.assistants.list();
+
+          return {
+            disabled: false,
+            options: assistants.data.map((assistant: any) => {
+              return {
+                label: assistant.name,
+                value: assistant.id,
+              };
+            }),
+          };
+        } catch (error) {
+          return {
+            disabled: true,
+            options: [],
+            placeholder: "Couldn't load assistants, API key is invalid",
+          };
+        }
+      },
+    }),
+    prompt: Property.LongText({
+      displayName: 'Question',
+      required: true,
+    }),
+    memoryKey: Property.ShortText({
+      displayName: 'Memory Key',
+      description:
+        'A memory key that will keep the chat history shared across runs and flows. Keep it empty to leave your assistant without memory of previous messages.',
+      required: false,
+    }),
+  },
+  async run({ auth, propsValue, store }) {
+    await propsValidation.validateZod(propsValue, {
+      memoryKey: z.string().max(128).optional(),
+    });
+
+    const openai = new OpenAI({
+      apiKey: auth,
+    });
+    const { assistant, prompt, memoryKey } = propsValue;
+    const runCheckDelay = 1000;
+    let response: any;
+    let thread: any;
+
+    if (memoryKey) {
+      // Get existing thread ID or create a new thread for this memory key
+      thread = await store.get(memoryKey, StoreScope.PROJECT);
+      if (!thread) {
+        thread = await openai.beta.threads.create();
+
+        store.put(memoryKey, thread, StoreScope.PROJECT);
+      }
+    } else {
+      thread = await openai.beta.threads.create();
+    }
+
+    const message = await openai.beta.threads.messages.create(thread.id, {
+      role: 'user',
+      content: prompt,
+    });
+
+    const run = await openai.beta.threads.runs.create(thread.id, {
+      assistant_id: assistant,
+    });
+    // Wait at least 400ms for inference to finish before checking to save requests
+    await sleep(400);
+
+    while (!response) {
+      const runCheck = await openai.beta.threads.runs.retrieve(
+        thread.id,
+        run.id
+      );
+      if (runCheck.status == 'completed') {
+        const messages = await openai.beta.threads.messages.list(thread.id);
+        // Return only messages that are newer than the user's latest message
+        response = messages.data.splice(
+          0,
+          messages.data.findIndex((m) => m.id == message.id)
+        );
+        break;
+      }
+
+      await sleep(runCheckDelay);
+    }
+
+    return response;
+  },
+});

package/src/lib/actions/extract-structure-data.action.ts

@@ -0,0 +1,146 @@
+import { openaiAuth } from '../../';
+import { createAction, Property } from '@activepieces/pieces-framework';
+import OpenAI from 'openai';
+import { notLLMs } from '../common/common';
+
+export const extractStructuredDataAction = createAction({
+	auth: openaiAuth,
+	name: 'extract-structured-data',
+	displayName: 'Extract Structured Data from Text',
+	description: 'Returns structured data from provided unstructured text.',
+	props: {
+		model: Property.Dropdown({
+			displayName: 'Model',
+			required: true,
+			refreshers: [],
+			defaultValue: 'gpt-3.5-turbo',
+			options: async ({ auth }) => {
+				if (!auth) {
+					return {
+						disabled: true,
+						placeholder: 'Enter your API key first',
+						options: [],
+					};
+				}
+				try {
+					const openai = new OpenAI({
+						apiKey: auth as string,
+					});
+					const response = await openai.models.list();
+					// We need to get only LLM models
+					const models = response.data.filter((model) => !notLLMs.includes(model.id));
+					return {
+						disabled: false,
+						options: models.map((model) => {
+							return {
+								label: model.id,
+								value: model.id,
+							};
+						}),
+					};
+				} catch (error) {
+					return {
+						disabled: true,
+						options: [],
+						placeholder: "Couldn't load models, API key is invalid",
+					};
+				}
+			},
+		}),
+		text: Property.LongText({
+			displayName: 'Unstructured Text',
+			required: true,
+		}),
+		params: Property.Array({
+			displayName: 'Data Definition',
+			required: true,
+			properties: {
+				propName: Property.ShortText({
+					displayName: 'Name',
+					description:
+						'Provide the name of the value you want to extract from the unstructured text. The name should be unique and short. ',
+					required: true,
+				}),
+				propDescription: Property.LongText({
+					displayName: 'Description',
+					description:
+						'Brief description of the data, this hints for the AI on what to look for',
+					required: false,
+				}),
+				propDataType: Property.StaticDropdown({
+					displayName: 'Data Type',
+					description: 'Type of parameter.',
+					required: true,
+					defaultValue: 'string',
+					options: {
+						disabled: false,
+						options: [
+							{ label: 'Text', value: 'string' },
+							{ label: 'Number', value: 'number' },
+							{ label: 'Boolean', value: 'boolean' },
+						],
+					},
+				}),
+				propIsRequired: Property.Checkbox({
+					displayName: 'Fail if Not present?',
+					required: true,
+					defaultValue: false,
+				}),
+			},
+		}),
+	},
+	async run(context) {
+		const { model, text } = context.propsValue;
+		const paramInputArray = context.propsValue.params as ParamInput[];
+		const functionParams: Record<string, unknown> = {};
+		const requiredFunctionParams: string[] = [];
+		for (const param of paramInputArray) {
+			functionParams[param.propName] = {
+				type: param.propDataType,
+				description: param.propDescription ?? param.propName,
+			};
+			if (param.propIsRequired) {
+				requiredFunctionParams.push(param.propName);
+			}
+		}
+		const prompt = 'Extract the following data from the provided text'
+		const openai = new OpenAI({
+			apiKey: context.auth,
+		});
+
+		const response = await openai.chat.completions.create({
+			model: model,
+			messages: [{ role: 'user', content: text }],
+			tools: [
+				{
+					type: 'function',
+					function: {
+						name: 'extract_structured_data',
+						description: prompt,
+						parameters: {
+							type: 'object',
+							properties: functionParams,
+							required: requiredFunctionParams,
+						},
+					},
+				},
+			],
+		});
+
+		const toolCallsResponse = response.choices[0].message.tool_calls;
+		if (toolCallsResponse) {
+			return JSON.parse(toolCallsResponse[0].function.arguments);
+		} else {
+			throw new Error(JSON.stringify({
+				message: "OpenAI couldn't extract the fields from the above text."
+			}));
+		}
+	},
+});
+
+interface ParamInput {
+	propName: string;
+	propDescription: string;
+	propDataType: string;
+	propIsRequired: boolean;
+}

package/src/lib/actions/generate-image.ts

@@ -0,0 +1,116 @@
+import { createAction, Property } from '@activepieces/pieces-framework';
+import OpenAI from 'openai';
+import { openaiAuth } from '../..';
+
+export const generateImage = createAction({
+  auth: openaiAuth,
+  name: 'generate_image',
+  displayName: 'Generate Image',
+  description: 'Generate an image using text-to-image models',
+  props: {
+    model: Property.Dropdown({
+      displayName: 'Model',
+      required: true,
+      description: 'The model which will generate the image.',
+      defaultValue: 'dall-e-3',
+      refreshers: [],
+      options: async () => {
+        return {
+          options: [
+            {
+              label: 'dall-e-3',
+              value: 'dall-e-3',
+            },
+            {
+              label: 'dall-e-2',
+              value: 'dall-e-2',
+            },
+          ],
+        };
+      },
+    }),
+    prompt: Property.LongText({
+      displayName: 'Prompt',
+      required: true,
+    }),
+    resolution: Property.Dropdown({
+      displayName: 'Resolution',
+      description: 'The resolution to generate the image in.',
+      required: false,
+      refreshers: ['model'],
+      defaultValue: '1024x1024',
+      options: async ({ model }) => {
+        let options = [
+          {
+            label: '1024x1024',
+            value: '1024x1024',
+          },
+          {
+            label: '512x512',
+            value: '512x512',
+          },
+          {
+            label: '256x256',
+            value: '256x256',
+          },
+        ];
+        if (model == 'dall-e-3')
+          options = [
+            {
+              label: '1024x1024',
+              value: '1024x1024',
+            },
+            {
+              label: '1024x1792',
+              value: '1024x1792',
+            },
+            {
+              label: '1792x1024',
+              value: '1792x1024',
+            },
+          ];
+
+        return {
+          options: options,
+        };
+      },
+    }),
+    quality: Property.Dropdown({
+      displayName: 'Quality',
+      required: false,
+      description: 'Standard is faster, HD has better details.',
+      defaultValue: 'standard',
+      refreshers: [],
+      options: async () => {
+        return {
+          options: [
+            {
+              label: 'standard',
+              value: 'standard',
+            },
+            {
+              label: 'hd',
+              value: 'hd',
+            },
+          ],
+        };
+      },
+    }),
+  },
+  async run({ auth, propsValue }) {
+    const openai = new OpenAI({
+      apiKey: auth,
+    });
+
+    const { quality, resolution, model, prompt } = propsValue;
+
+    const image = await openai.images.generate({
+      model: model,
+      prompt: prompt,
+      quality: quality as any,
+      size: resolution as any,
+    });
+
+    return image;
+  },
+});