@crowdin/app-project-module 0.55.0 → 0.56.1

package/out/index.js

@@ -62,6 +62,7 @@ const customMTApp = __importStar(require("./modules/custom-mt"));
 const spellCheckApp = __importStar(require("./modules/custom-spell-check"));
 const aiProvider = __importStar(require("./modules/ai-provider"));
 const aiPromptProvider = __importStar(require("./modules/ai-prompt-provider"));
+const aiToolCalls = __importStar(require("./modules/ai-tools"));
 const editorRightPanelApp = __importStar(require("./modules/editor-right-panel"));
 const editorThemesApp = __importStar(require("./modules/editor-themes"));
 const fileProcessingApps = __importStar(require("./modules/file-processing"));
@@ -167,6 +168,8 @@ function addCrowdinEndpoints(app, clientConfig) {
     apiApp.register({ config, app });
     aiProvider.register({ config, app });
     aiPromptProvider.register({ config, app });
+    aiToolCalls.registerAiToolCalls({ config, app });
+    aiToolCalls.registerAiToolCallWidgets({ config, app });
     addFormSchema({ config, app });
     return Object.assign(Object.assign({}, exports.metadataStore), { establishCrowdinConnection: (authRequest) => {
             let jwtToken = '';

package/out/modules/ai-tools/handlers/tool-calls.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="qs" />
+import { Response } from 'express';
+import { CrowdinClientRequest } from '../../../types';
+import { AiToolCall } from '../types';
+export default function handle(aiToolCall: AiToolCall): (req: CrowdinClientRequest | import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>, res: Response<any, Record<string, any>>, next: Function) => void;

package/out/modules/ai-tools/handlers/tool-calls.js

@@ -0,0 +1,48 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = require("../../../util");
+const logger_1 = require("../../../util/logger");
+function handle(aiToolCall) {
+    return (0, util_1.runAsyncWrapper)((req, res) => __awaiter(this, void 0, void 0, function* () {
+        try {
+            const { crowdinApiClient: client, crowdinContext: context, body: payload } = req;
+            const { function: { arguments: stringArgs = '' }, } = payload;
+            const { jwtPayload: { context: { project_id: projectId }, }, } = context;
+            let args = null;
+            try {
+                args = JSON.parse(stringArgs);
+            }
+            catch (e) { }
+            const { content, error: message } = yield aiToolCall.handle({
+                client,
+                args,
+                projectId,
+                payload,
+                context,
+                req,
+            });
+            res.send({
+                data: {
+                    content: typeof content === 'string' ? content : JSON.stringify(content),
+                    error: message ? { message } : undefined,
+                },
+            });
+        }
+        catch (e) {
+            if (req.logError) {
+                req.logError(e);
+            }
+            res.send({ error: { message: (0, logger_1.getErrorMessage)(e) } });
+        }
+    }));
+}
+exports.default = handle;

package/out/modules/ai-tools/index.d.ts

@@ -0,0 +1,10 @@
+import { Express } from 'express';
+import { Config } from '../../types';
+export declare function registerAiToolCalls({ config, app }: {
+    config: Config;
+    app: Express;
+}): void;
+export declare function registerAiToolCallWidgets({ config, app }: {
+    config: Config;
+    app: Express;
+}): void;

package/out/modules/ai-tools/index.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerAiToolCallWidgets = exports.registerAiToolCalls = void 0;
+const json_response_1 = __importDefault(require("../../middlewares/json-response"));
+const tool_calls_1 = __importDefault(require("./handlers/tool-calls"));
+const ui_module_1 = __importDefault(require("../../middlewares/ui-module"));
+const render_ui_module_1 = __importDefault(require("../../middlewares/render-ui-module"));
+const crowdin_client_1 = __importDefault(require("../../middlewares/crowdin-client"));
+function getToolKey(tool) {
+    return tool.function.name;
+}
+function registerAiToolCalls({ config, app }) {
+    if (config.aiToolCalls) {
+        const tools = Array.isArray(config.aiToolCalls) ? config.aiToolCalls : [config.aiToolCalls];
+        for (const tool of tools) {
+            app.post(`/ai-tool-calls/${getToolKey(tool)}`, json_response_1.default, (0, crowdin_client_1.default)(config), (0, tool_calls_1.default)(tool));
+        }
+    }
+}
+exports.registerAiToolCalls = registerAiToolCalls;
+function registerAiToolCallWidgets({ config, app }) {
+    if (config.aiToolCallWidgets) {
+        const tools = Array.isArray(config.aiToolCallWidgets) ? config.aiToolCallWidgets : [config.aiToolCallWidgets];
+        for (const tool of tools) {
+            app.use(`/ai-tool-call-widgets/${getToolKey(tool)}`, (0, ui_module_1.default)(config), (0, render_ui_module_1.default)(tool));
+        }
+    }
+}
+exports.registerAiToolCallWidgets = registerAiToolCallWidgets;

package/out/modules/ai-tools/types.d.ts

@@ -0,0 +1,63 @@
+import { CrowdinClientRequest, CrowdinContextInfo, Environments, UiModule } from '../../types';
+import Crowdin from '@crowdin/crowdin-api-client';
+export interface AiToolCallWidget extends AiTool, UiModule {
+}
+export interface AiToolCall extends AiTool {
+    /**
+     * function to handle requests
+     */
+    handle: (options: AiToolCallArguments) => Promise<AiToolCallResponse>;
+}
+interface AiTool extends Environments {
+    /**
+     * Tool type, default is 'function'
+     */
+    toolType: string;
+    /**
+     * describe function object
+     */
+    function: AiToolCallFunction;
+}
+interface AiToolCallFunction {
+    /**
+     * The name of the function to be called. Must be a-z, A-Z, 0-9, or contain underscores and dashes.
+     */
+    name: string;
+    /**
+     * A description of what the function does, used by the AI model to choose when and how to call the function.
+     */
+    description: string;
+    /**
+     * Describe as a JSON Schema object
+     */
+    parameters?: {
+        type: string;
+        properties: object;
+        required?: string[];
+    };
+}
+interface AiToolCallArguments {
+    client: Crowdin;
+    args: object | null;
+    projectId: number;
+    payload: AiToolCallPayload;
+    context: CrowdinContextInfo;
+    req: CrowdinClientRequest;
+}
+interface AiToolCallPayload {
+    function: {
+        name: string;
+        arguments: string;
+    };
+    organization: {
+        [key: string]: unknown;
+    };
+    project: {
+        [key: string]: unknown;
+    };
+}
+interface AiToolCallResponse {
+    content: string | object;
+    error?: string;
+}
+export {};

package/out/modules/ai-tools/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/out/modules/integration/util/cron.js

@@ -86,6 +86,7 @@ function filesCron({ config, integration, period, }) {
         (0, logger_1.log)(`Starting files cron job with period [${period}]`);
         const syncSettingsList = yield (0, storage_1.getStorage)().getAllSyncSettingsByType('schedule');
         for (const syncSettings of syncSettingsList) {
+            let projectData;
             let files = JSON.parse(syncSettings.files);
             let newFiles = [];
             const crowdinCredentials = yield (0, storage_1.getStorage)().getCrowdinCredentials(syncSettings.crowdinId);
@@ -131,8 +132,14 @@ function filesCron({ config, integration, period, }) {
                 (0, logger_1.log)(`Subscription expired. Skipping job [${period}] for organization ${crowdinCredentials.id}`);
                 continue;
             }
-            const projectData = (yield crowdinClient.projectsGroupsApi.getProject(projectId))
-                .data;
+            try {
+                projectData = (yield crowdinClient.projectsGroupsApi.getProject(projectId))
+                    .data;
+            }
+            catch (e) {
+                (0, logger_1.logError)(e);
+                continue;
+            }
             // eslint-disable-next-line @typescript-eslint/camelcase
             context.jwtPayload.context.project_identifier = projectData.identifier;
             const rootFolder = yield (0, defaults_1.getRootFolder)(config, integration, crowdinClient, projectId);

package/out/modules/manifest.js

@@ -188,6 +188,26 @@ function handle(config) {
                 : {})),
         ];
     }
+    if (config.aiToolCalls) {
+        const tools = Array.isArray(config.aiToolCalls) ? config.aiToolCalls : [config.aiToolCalls];
+        modules['ai-tool-calls'] = [];
+        for (const tool of tools) {
+            const key = tool.function.name;
+            modules['ai-tool-calls'].push(Object.assign({ key, toolType: 'function', function: tool.function, url: `/ai-tool-calls/${key}` }, (!!tool.environments && {
+                environments: normalizeEnvironments(tool.environments),
+            })));
+        }
+    }
+    if (config.aiToolCallWidgets) {
+        const tools = Array.isArray(config.aiToolCallWidgets) ? config.aiToolCallWidgets : [config.aiToolCallWidgets];
+        modules['ai-tool-call-widgets'] = [];
+        for (const tool of tools) {
+            const key = tool.function.name;
+            modules['ai-tool-call-widgets'].push(Object.assign({ key, toolType: 'function', function: tool.function, url: `/ai-tool-call-widgets/${key}/${tool.fileName || 'index.html'}` }, (!!tool.environments && {
+                environments: normalizeEnvironments(tool.environments),
+            })));
+        }
+    }
     const events = {
         installed: '/installed',
         uninstall: '/uninstall',

package/out/types.d.ts

@@ -14,6 +14,7 @@ import { ApiModule } from './modules/api/types';
 import { LogErrorFunction, LogFunction } from './util/logger';
 import { AiProviderModule } from './modules/ai-provider/types';
 import { AiPromptProviderModule } from './modules/ai-prompt-provider/types';
+import { AiToolCall, AiToolCallWidget } from './modules/ai-tools/types';
 export interface ClientConfig extends ImagePath {
     /**
      * Authentication Crowdin App type: "authorization_code", "crowdin_app". Default: "crowdin_app"
@@ -185,6 +186,14 @@ export interface ClientConfig extends ImagePath {
      * ai prompt provider module
      */
     aiPromptProvider?: AiPromptProviderModule & ImagePath;
+    /**
+     * AI tool_calls modules
+     */
+    aiToolCalls?: AiToolCall | AiToolCall[];
+    /**
+     * AI tool_calls modules with UI widgets
+     */
+    aiToolCallWidgets?: AiToolCallWidget | AiToolCallWidget[];
 }
 export interface Environments {
     environments?: Environment | Environment[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@crowdin/app-project-module",
-  "version": "0.55.0",
+  "version": "0.56.1",
   "description": "Module that generates for you all common endpoints for serving standalone Crowdin App",
   "main": "out/index.js",
   "types": "out/index.d.ts",