@crowdin/app-project-module 0.56.2 → 0.56.3

package/out/index.js

@@ -62,7 +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 aiTools = __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"));
@@ -168,8 +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 });
+    aiTools.registerAiTools({ config, app });
+    aiTools.registerAiToolWidgets({ 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

@@ -1,5 +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;
+import { AiTool } from '../types';
+export default function handle(aiTool: AiTool): (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

@@ -11,7 +11,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 const util_1 = require("../../../util");
 const logger_1 = require("../../../util/logger");
-function handle(aiToolCall) {
+function handle(aiTool) {
     return (0, util_1.runAsyncWrapper)((req, res) => __awaiter(this, void 0, void 0, function* () {
         try {
             const { crowdinApiClient: client, crowdinContext: context, body: payload } = req;
@@ -21,8 +21,12 @@ function handle(aiToolCall) {
             try {
                 args = JSON.parse(stringArgs);
             }
-            catch (e) { }
-            const { content, error: message } = yield aiToolCall.handle({
+            catch (e) {
+                if (req.logError) {
+                    req.logError(e);
+                }
+            }
+            const { content, error: message } = yield aiTool.toolCalls({
                 client,
                 args,
                 projectId,

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

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

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

@@ -3,30 +3,40 @@ 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;
+exports.registerAiToolWidgets = exports.registerAiTools = 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));
+const util_1 = require("./util");
+function registerAiTools({ config, app }) {
+    if (!config.aiTools) {
+        return;
+    }
+    const tools = Array.isArray(config.aiTools) ? config.aiTools : [config.aiTools];
+    for (const tool of tools) {
+        if ((0, util_1.isUniqueFunctionName)(tool)) {
+            app.post((0, util_1.getAiToolUrl)(tool), json_response_1.default, (0, crowdin_client_1.default)(config), (0, tool_calls_1.default)(tool));
+        }
+        else {
+            throw new Error(`The function name '${tool.function.name}' is not unique within aiTools and aiToolsWidget`);
         }
     }
 }
-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.registerAiTools = registerAiTools;
+function registerAiToolWidgets({ config, app }) {
+    if (!config.aiToolsWidget) {
+        return;
+    }
+    const tools = Array.isArray(config.aiToolsWidget) ? config.aiToolsWidget : [config.aiToolsWidget];
+    for (const tool of tools) {
+        if ((0, util_1.isUniqueFunctionName)(tool)) {
+            app.use((0, util_1.getAiToolWidgetUrl)(tool), (0, ui_module_1.default)(config), (0, render_ui_module_1.default)(tool));
+        }
+        else {
+            throw new Error(`The function name '${tool.function.name}' is not unique within aiTools and aiToolsWidget`);
         }
     }
 }
-exports.registerAiToolCallWidgets = registerAiToolCallWidgets;
+exports.registerAiToolWidgets = registerAiToolWidgets;

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

@@ -1,14 +1,14 @@
 import { CrowdinClientRequest, CrowdinContextInfo, Environments, UiModule } from '../../types';
 import Crowdin from '@crowdin/crowdin-api-client';
-export interface AiToolCallWidget extends AiTool, UiModule {
+export interface AiToolWidget extends BaseAiTool, UiModule {
 }
-export interface AiToolCall extends AiTool {
+export interface AiTool extends BaseAiTool {
     /**
      * function to handle requests
      */
-    handle: (options: AiToolCallArguments) => Promise<AiToolCallResponse>;
+    toolCalls: (options: AiToolArguments) => Promise<AiToolResponse>;
 }
-interface AiTool extends Environments {
+interface BaseAiTool extends Environments {
     /**
      * Tool type, default is 'function'
      */
@@ -16,9 +16,9 @@ interface AiTool extends Environments {
     /**
      * describe function object
      */
-    function: AiToolCallFunction;
+    function: AiToolFunction;
 }
-interface AiToolCallFunction {
+interface AiToolFunction {
     /**
      * The name of the function to be called. Must be a-z, A-Z, 0-9, or contain underscores and dashes.
      */
@@ -36,27 +36,27 @@ interface AiToolCallFunction {
         required?: string[];
     };
 }
-interface AiToolCallArguments {
+interface AiToolArguments {
     client: Crowdin;
     args: object | null;
     projectId: number;
-    payload: AiToolCallPayload;
+    payload: AiToolPayload;
     context: CrowdinContextInfo;
     req: CrowdinClientRequest;
 }
-interface AiToolCallPayload {
+interface AiToolPayload {
     function: {
         name: string;
         arguments: string;
     };
     organization: {
-        [key: string]: unknown;
+        [key: string]: any;
     };
     project: {
-        [key: string]: unknown;
+        [key: string]: any;
     };
 }
-interface AiToolCallResponse {
+interface AiToolResponse {
     content: string | object;
     error?: string;
 }

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

@@ -0,0 +1,5 @@
+import { AiTool, AiToolWidget } from '../types';
+export declare function isUniqueFunctionName(tool: AiTool | AiToolWidget): boolean;
+export declare function getAiToolName(tool: AiTool | AiToolWidget): string;
+export declare function getAiToolUrl(tool: AiTool): string;
+export declare function getAiToolWidgetUrl(tool: AiToolWidget, isFull?: boolean): string;

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAiToolWidgetUrl = exports.getAiToolUrl = exports.getAiToolName = exports.isUniqueFunctionName = void 0;
+const uniqueNames = [];
+function isUniqueFunctionName(tool) {
+    if (uniqueNames.includes(tool.function.name)) {
+        return false;
+    }
+    uniqueNames.push(tool.function.name);
+    return true;
+}
+exports.isUniqueFunctionName = isUniqueFunctionName;
+function getAiToolName(tool) {
+    return tool.function.name;
+}
+exports.getAiToolName = getAiToolName;
+function getAiToolUrl(tool) {
+    return `/ai-tools/${getAiToolName(tool)}`;
+}
+exports.getAiToolUrl = getAiToolUrl;
+function getAiToolWidgetUrl(tool, isFull = false) {
+    const suffix = isFull ? `/${tool.fileName || 'index.html'}` : '';
+    return `/ai-tools-widget/${getAiToolName(tool)}${suffix}`;
+}
+exports.getAiToolWidgetUrl = getAiToolWidgetUrl;

package/out/modules/manifest.js

@@ -4,6 +4,7 @@ const types_1 = require("../types");
 const util_1 = require("../util");
 const subscription_1 = require("../util/subscription");
 const api_1 = require("./api/api");
+const util_2 = require("./ai-tools/util");
 function normalizeEnvironments(environments) {
     if (Array.isArray(environments)) {
         return environments;
@@ -188,22 +189,20 @@ function handle(config) {
                 : {})),
         ];
     }
-    if (config.aiToolCalls) {
-        const tools = Array.isArray(config.aiToolCalls) ? config.aiToolCalls : [config.aiToolCalls];
-        modules['ai-tool-calls'] = [];
+    if (config.aiTools) {
+        const tools = Array.isArray(config.aiTools) ? config.aiTools : [config.aiTools];
+        modules['ai-tools'] = [];
         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 && {
+            modules['ai-tools'].push(Object.assign({ key: config.identifier + '-' + (0, util_2.getAiToolName)(tool), toolType: tool.toolType || 'function', function: tool.function, url: (0, util_2.getAiToolUrl)(tool) }, (!!tool.environments && {
                 environments: normalizeEnvironments(tool.environments),
             })));
         }
     }
-    if (config.aiToolCallWidgets) {
-        const tools = Array.isArray(config.aiToolCallWidgets) ? config.aiToolCallWidgets : [config.aiToolCallWidgets];
-        modules['ai-tool-call-widgets'] = [];
+    if (config.aiToolsWidget) {
+        const tools = Array.isArray(config.aiToolsWidget) ? config.aiToolsWidget : [config.aiToolsWidget];
+        modules['ai-tools-widget'] = [];
         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 && {
+            modules['ai-tools-widget'].push(Object.assign({ key: config.identifier + '-' + (0, util_2.getAiToolName)(tool), toolType: tool.toolType || 'function', function: tool.function, url: (0, util_2.getAiToolWidgetUrl)(tool, true) }, (!!tool.environments && {
                 environments: normalizeEnvironments(tool.environments),
             })));
         }

package/out/types.d.ts

@@ -14,7 +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';
+import { AiTool, AiToolWidget } from './modules/ai-tools/types';
 export interface ClientConfig extends ImagePath {
     /**
      * Authentication Crowdin App type: "authorization_code", "crowdin_app". Default: "crowdin_app"
@@ -189,11 +189,11 @@ export interface ClientConfig extends ImagePath {
     /**
      * AI tool_calls modules
      */
-    aiToolCalls?: AiToolCall | AiToolCall[];
+    aiTools?: AiTool | AiTool[];
     /**
      * AI tool_calls modules with UI widgets
      */
-    aiToolCallWidgets?: AiToolCallWidget | AiToolCallWidget[];
+    aiToolsWidget?: AiToolWidget | AiToolWidget[];
 }
 export interface Environments {
     environments?: Environment | Environment[];

package/package.json

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