@optimizely-opal/opal-tool-ocp-sdk 1.0.0-beta.9 → 1.1.0-beta.1

package/README.md

@@ -6,45 +6,61 @@ A TypeScript SDK for building Opal tools in Optimizely Connect Platform. This SD
 
 ## Features
 
-- 🎯 **Decorator-based Tool Registration** - Use `@tool` and `@interaction` decorators to easily register functions
+- 🎯 **Decorator-based Tool Registration** - Use `@tool` decorator to easily register functions
 - 🌐 **Global and Regular Function Modes** - SDK can be used in either global or organization-scoped mode
 - 🔧 **Type-safe Development** - Full TypeScript support with comprehensive type definitions  
 - 🏗️ **Abstract Base Classes** - Extend `ToolFunction` or `GlobalToolFunction` for standardized request processing
-- 🔐 **Authentication Support** - OptiID authentication
+- 🔐 **Authentication Support** - OptiID authentication (default), custom auth providers supported
 - 🛡️ **Authorization Support** - OptiID token tool authorization
 - 📝 **Parameter Validation** - Define and validate tool parameters with types
 - ✅ **Automatic Validation** - SDK automatically validates parameters and returns RFC 9457 compliant error responses
 - 🧪 **Comprehensive Testing** - Fully tested with Jest
 
-## Installation
+## Quick Start
+
+The SDK extends the functionality of OCP apps. You need to have an OCP app to use this SDK. 
+Learn how to get started with OCP app development [here](https://docs.developers.optimizely.com/optimizely-connect-platform/docs/developer-platform-overview-ocp2).
 
+Start by adding the SDK to your existing OCP app. In your OCP app folder, execute: 
 ```bash
-npm install @optimizely-opal/opal-tool-ocp-sdk
+yarn add @optimizely-opal/opal-tool-ocp-sdk
 ```
 
-or
+To add an Opal too registry to your OCP app, 
+add a [function](https://docs.developers.optimizely.com/optimizely-connect-platform/docs/functions-ocp2) to your app manifest and mark it as an Opal tool function:
 
-```bash
-yarn add @optimizely-opal/opal-tool-ocp-sdk
+**`app.yml`**
+```yaml
+functions: 
+  opal_tool: # A unique key for your function. 
+    entry_point: OpalToolFunction # The name of the class implementing your tool. 
+    description: Opal tool function # A brief description of this function.
+    opal_tool: true
 ```
 
-## Quick Start
+Next, create and implement function class - both file name and class must match the value of `entry_point` property from app manifest. 
+Function class must extend either `ToolFunction` or `GlobalToolFunction` class from `@optimizely-opal/opal-tool-ocp-sdk` (See 'Function modes' section below).
 
-The SDK supports two function modes:
+**`src/functions/OpalToolFunction`**
+```typescript
+import { ToolFunction } from '@optimizely-opal/opal-tool-ocp-sdk';
 
-- **Regular Functions** (`ToolFunction`) - Organization-scoped functions that validate customer organization IDs
-- **Global Functions** (`GlobalToolFunction`) - Platform-wide functions that work across all organizations
+export class OpalToolFunction extends ToolFunction {
 
-### Regular Tool Function
+}
+```
 
-Create a tool function class by extending `ToolFunction` for organization-scoped functionality:
+Next, implement tools methods and annotate them with `@tool` decorator. Each such method is a tool in your registry. 
+You can define mulitple tool methods in your app. 
+Tool methods can be defined either as tool class instance methods or in separate classes. 
+If tools are defined in separate classes, these classes need to be imported into the function class. 
 
+**`src/functions/OpalToolFunction`**
 ```typescript
-import { ToolFunction, tool, interaction, ParameterType, InteractionResult, OptiIdAuthData } from '@optimizely-opal/opal-tool-ocp-sdk';
+import { ToolFunction } from '@optimizely-opal/opal-tool-ocp-sdk';
 
-export class MyToolFunction extends ToolFunction {
+export class OpalToolFunction extends ToolFunction {
 
-  // Register a simple tool without authentication
   @tool({
     name: 'create_task',
     description: 'Creates a new task in the system',
@@ -71,118 +87,42 @@ export class MyToolFunction extends ToolFunction {
       priority: params.priority || 'medium'
     };
   }
-
-  // Register a tool with OptiID authentication
-  @tool({
-    name: 'secure_task',
-    description: 'Creates a secure task with OptiID authentication',
-    endpoint: '/secure-task',
-    parameters: [
-      {
-        name: 'title',
-        type: ParameterType.String,
-        description: 'The task title',
-        required: true
-      }
-    ],
-    authRequirements: [
-      {
-        provider: 'OptiID',
-        scopeBundle: 'tasks',
-        required: true
-      }
-    ]
-  })
-  async createSecureTask(params: { title: string }, authData?: OptiIdAuthData) {
-    if (!authData) {
-      throw new Error('OptiID authentication required');
-    }
-
-    const { customer_id, instance_id, access_token } = authData.credentials;
-    return {
-      id: '456',
-      title: params.title,
-      customer_id,
-      instance_id
-    };
-  }
-
-  // Register an interaction
-  @interaction({
-    name: 'task_webhook',
-    endpoint: '/webhook/task'
-  })
-  async handleTaskWebhook(data: any): Promise<InteractionResult> {
-    return new InteractionResult(
-      `Task ${data.taskId} was updated`,
-      `https://app.example.com/tasks/${data.taskId}`
-    );
-  }
 }
 ```
 
-### Global Tool Function
+The format of `params` attribute matches the parameters defined in `@tool` decorator. 
 
-Create a global tool function by extending `GlobalToolFunction` for platform-wide functionality:
+When the function is called by Opal, the SDK automatically: 
 
-```typescript
-import { GlobalToolFunction, tool, interaction, ParameterType, InteractionResult, OptiIdAuthData } from '@optimizely-opal/opal-tool-ocp-sdk';
+- **Routes requests** to your registered tools based on endpoints
+- **Handles authentication** and OptiID token validation before calling your methods  
+- **Provides discovery** at `/discovery` endpoint for OCP platform integration
+- **Returns proper HTTP responses** with correct status codes and JSON formatting
 
-export class MyGlobalToolFunction extends GlobalToolFunction {
+Optionally, implement `ready` method to define when tool registry can be registered and called by Opal. 
+OCP will call this method to show tool readiness in the UI. Only functions marked as `ready` can be registered and called by Opal.
+The value of `reason` property from the response will be displayed in OCP UI to inform users why the tool is not ready to be registered. 
+```typescript
+  protected override async ready(): Promise<ReadyResponse> {
+    // validation logic
+    if (!isValid) {
+      return { ready: false, reason: 'Configure the app first.' };
+    }
 
-  @tool({
-    name: 'global_utility',
-    description: 'A utility tool available to all organizations',
-    endpoint: '/global-utility',
-    parameters: [
-      {
-        name: 'operation',
-        type: ParameterType.String,
-        description: 'The operation to perform',
-        required: true
-      }
-    ]
-  })
-  async globalUtility(params: { operation: string }, authData?: OptiIdAuthData) {
-    return {
-      result: `Performed ${params.operation} globally`,
-      organizationId: authData?.credentials.customer_id || 'unknown'
-    };
+    return { ready: true };
   }
-}
 ```
 
-### Function Modes
-
-The SDK operates in one of two modes based on the base class you extend:
-
-- **Regular Function Mode** (`ToolFunction`): All tools are organization-scoped and validate organization IDs
-- **Global Function Mode** (`GlobalToolFunction`): All tools are platform-wide.
-
-The discovery endpoint returns all tools registered within that function mode.
-
-Your function class inherits a `perform()` method from `ToolFunction` or `GlobalToolFunction` that serves as the main entry point for handling all incoming requests. When called, the SDK automatically:
-
-- **Routes requests** to your registered tools and interactions based on endpoints
-- **Handles authentication** and OptiID token validation before calling your methods  
-- **Provides discovery** at `/discovery` endpoint for OCP platform integration
-- **Returns proper HTTP responses** with correct status codes and JSON formatting
-
 ## Core Concepts
 
 ### Tools
 
-Tools are functions that can be discovered and executed through the OCP platform. They:
-
-- Have a name, description, and endpoint
-- Define parameters with types and validation
-- Can require authentication
-- Return structured responses
-- Are automatically registered based on the function mode you choose
+Each OCP app with an Opal too function is a tool registry in Opal. Tool registry constist of one or more tools. 
+Each tool have name, description and a list of input parameters.
 
 ### Function Modes
 
-#### Regular Functions (`ToolFunction`)
+#### Regular Functions (function extends `ToolFunction` class)
 
 Regular functions are scoped to specific organizations and validate that requests come from the same organization:
 
@@ -191,7 +131,7 @@ Regular functions are scoped to specific organizations and validate that request
 - **Per-Organization Configuration**: Can implement organization-specific configuration, authentication credentials, and API keys since they're tied to a single organization
 - **Per-Organization Authentication**: Can store and use organization-specific authentication tokens, connection strings, and other sensitive data securely
 
-#### Global Functions (`GlobalToolFunction`)
+#### Global Functions (function extends `GlobalToolFunction` class)
 
 Global functions work across all organizations without organization validation:
 
@@ -201,14 +141,6 @@ Global functions work across all organizations without organization validation:
 - **No Per-Organization Authentication**: Cannot store organization-specific credentials or authentication data
 - **Global Discovery**: Have a global discovery URL that can be used by any organization without requiring them to install the app first
 
-### Interactions
-
-Interactions are event handlers that process incoming data (like webhooks):
-
-- Have a name and endpoint
-- Process unstructured data
-- Return interaction results with messages and optional links
-
 ### Parameters
 
 Supported parameter types:
@@ -226,7 +158,9 @@ enum ParameterType {
 
 ### Parameter Validation
 
-The SDK automatically validates all incoming parameters against the parameter definitions you specify for your tools. When Opal sends requests to your tools, the SDK performs validation before calling your handler methods:
+The SDK automatically validates all incoming parameters against the parameter definitions you specify for your tools. 
+When Opal sends requests to your tools, the SDK performs validation before calling your handler methods and automatically returns an error message that Opal understands. 
+This allow Opal to auto-correct. 
 
 #### Automatic Validation Features
 
@@ -235,43 +169,13 @@ The SDK automatically validates all incoming parameters against the parameter de
 - **Early Error Response**: Returns validation errors immediately without calling your handler if validation fails
 - **RFC 9457 Compliance**: Error responses follow the RFC 9457 Problem Details for HTTP APIs specification
 
-#### Validation Error Response Format
-
-When parameter validation fails, the SDK returns a standardized error response with HTTP status 400 and `Content-Type: application/problem+json`:
-
-```json
-{
-  "title": "One or more validation errors occurred.",
-  "status": 400,
-  "detail": "See 'errors' field for details.",
-  "instance": "/your-tool-endpoint",
-  "errors": [
-    {
-      "field": "title",
-      "message": "Parameter 'title' must be a string, but received number"
-    },
-    {
-      "field": "priority",
-      "message": "Required parameter 'priority' is missing"
-    }
-  ]
-}
-```
-
-**Benefits:**
-
-- **Reduced Boilerplate**: No need to write parameter validation code in your handlers
-- **Consistent Error Format**: All validation errors follow the same RFC 9457 standard format
-- **Better Developer Experience**: Clear, actionable error messages for API consumers
-- **Type Safety**: Validation ensures your handlers receive correctly typed parameters
-
 ### Authentication
 
 The SDK supports authentication and authorization mechanisms:
 
-#### OptiID Authentication
+#### OptiID Authentication (Default)
 
-OptiID provides user authentication with type safety. This is the only user authentication provider currently supported in Opal:
+OptiID provides user authentication with type safety. When a tool does not declare any `authRequirements`, the SDK automatically adds OptiID as the default authentication provider:
 
 ```typescript
 interface AuthRequirementConfig {
@@ -317,6 +221,42 @@ export class MyToolFunction extends ToolFunction {
 }
 ```
 
+#### Custom Auth Providers
+
+Tools can declare custom authentication providers instead of using the default OptiID. When a tool specifies its own `authRequirements`, the SDK respects that choice and skips its built-in authentication validation:
+
+```typescript
+@tool({
+  name: 'external_api_tool',
+  description: 'Tool that uses external OAuth2 authentication',
+  endpoint: '/external-api',
+  parameters: [
+    { name: 'query', type: ParameterType.String, description: 'Search query', required: true }
+  ],
+  authRequirements: [{ provider: 'google', scopeBundle: 'calendar', required: true }]
+})
+async externalApiTool(params: { query: string }, authData?: any) {
+  // SDK does NOT validate oauth2 credentials
+  // Your handler must validate the auth credentials
+  // Validate token with your external provider
+  const isValid = await this.validateOAuth2Token(authData.credentials.access_token);
+  if (!isValid) {
+    throw new ToolError('Invalid OAuth2 token', 401);
+  }
+
+  return { results: await this.searchExternalApi(params.query) };
+}
+```
+
+**Important Security Considerations:**
+
+> **Warning**: Tools using non-OptiID authentication should NOT expose sensitive data from app settings (such as API keys, secrets, or organization-specific configuration).
+>
+> - **OptiID auth** guarantees the caller is authorized for the specific organization and the request is from a trusted Opal instance
+> - **Non-OptiID auth** only guarantees the credentials are valid for that provider - it does NOT guarantee the caller is authorized for the organization or app
+>
+> Only credentials for the declared auth provider are validated. If your tool declares `google` auth requirement, the SDK will pass through whatever credentials Opal sends without SDK-level validation. Your handler is fully responsible for credential validation and access control.
+
 ## Error Handling
 
 The SDK provides RFC 9457 Problem Details compliant error handling through the `ToolError` class. This allows you to throw errors with custom HTTP status codes and detailed error information.
@@ -434,16 +374,16 @@ This will return:
 
 ### Handler Function Signatures
 
-All tool and interaction handler methods follow this signature pattern:
+All tool handler methods follow this signature pattern:
 
 ```typescript
 async handlerMethod(
-  params: TParams,           // Tool parameters or interaction data
+  params: TParams,           // Tool parameters
   authData?: OptiIdAuthData  // OptiID user authentication data (if authenticated)
 ): Promise<TResult>
 ```
 
-- **params**: The input parameters for tools, or interaction data for webhooks
+- **params**: The input parameters for tools
 - **authData**: Available when OptiID user authentication is configured and successful
 
 
@@ -463,17 +403,6 @@ interface ToolConfig {
 }
 ```
 
-#### `@interaction(config: InteractionConfig)`
-
-Registers a method as an interaction handler.
-
-```typescript
-interface InteractionConfig {
-  name: string;
-  endpoint: string;
-}
-```
-
 ### Base Classes
 
 #### `ToolFunction`
@@ -507,10 +436,8 @@ Extend this class for tools that work across organizations. The `perform` method
 Key model classes with generic type support:
 
 - `Tool<TAuthData>` - Represents a registered tool with typed auth data
-- `Interaction<TAuthData>` - Represents an interaction handler with typed auth data
 - `Parameter` - Defines tool parameters
 - `AuthRequirement` - Defines authentication needs
-- `InteractionResult` - Response from interactions
 - `OptiIdAuthData` - OptiID specific authentication data
 - `ReadyResponse` - Response type for the ready method containing status and optional reason
 - `ToolError` - Custom error class for RFC 9457 Problem Details error responses with configurable HTTP status codes
@@ -639,7 +566,7 @@ yarn lint
 ### Function with Authentication
 
 ```typescript
-import { ToolFunction, tool, interaction, ParameterType, OptiIdAuthData, InteractionResult } from '@optimizely-opal/opal-ocp-sdk';
+import { ToolFunction, tool, ParameterType, OptiIdAuthData } from '@optimizely-opal/opal-ocp-sdk';
 
 export class AuthenticatedFunction extends ToolFunction {
 
@@ -659,24 +586,6 @@ export class AuthenticatedFunction extends ToolFunction {
     return { success: true, customer_id };
   }
 
-  // Interaction with authentication example
-  @interaction({
-    name: 'authenticated_webhook',
-    endpoint: '/secure-webhook'
-  })
-  async handleSecureWebhook(data: any, authData?: OptiIdAuthData): Promise<InteractionResult> {
-    if (!authData) {
-      return new InteractionResult('Authentication required for webhook processing');
-    }
-
-    const { customer_id } = authData.credentials;
-    
-    // Process webhook data with authentication context
-    return new InteractionResult(
-      `Webhook processed for customer ${customer_id}: ${data.eventType}`,
-      `https://app.example.com/events/${data.eventId}`
-    );
-  }
 }
 ```
 
@@ -748,7 +657,7 @@ export class TaskTool {
 
 **tools/NotificationTool.ts:**
 ```typescript
-import { tool, interaction, ParameterType, InteractionResult, OptiIdAuthData } from '@optimizely-opal/opal-ocp-sdk';
+import { tool, ParameterType, OptiIdAuthData } from '@optimizely-opal/opal-ocp-sdk';
 
 export class NotificationTool {
   @tool({
@@ -779,16 +688,6 @@ export class NotificationTool {
     };
   }
 
-  @interaction({
-    name: 'notification_webhook',
-    endpoint: '/webhook/notification'
-  })
-  async handleNotificationWebhook(data: any): Promise<InteractionResult> {
-    return new InteractionResult(
-      `Notification ${data.notificationId} was delivered`,
-      `https://app.example.com/notifications/${data.notificationId}`
-    );
-  }
 }
 ```
 
@@ -816,7 +715,7 @@ This approach provides several benefits:
 
 ## Decorator Behavior and Instance Context
 
-The `@tool` and `@interaction` decorators provide intelligent instance context management that behaves differently depending on where the decorated methods are defined:
+The `@tool` decorator provide intelligent instance context management that behaves differently depending on where the decorated methods are defined:
 
 ### ToolFunction Subclass Context
 

package/dist/function/GlobalToolFunction.d.ts

@@ -20,7 +20,10 @@ export declare abstract class GlobalToolFunction extends GlobalFunction {
     perform(): Promise<Response>;
     private handleRequest;
     /**
-     * Authenticate the incoming request by validating only the OptiID token
+     * Authenticate the incoming request based on the endpoint
+     * - /discovery: No auth required
+     * - /overrides: Internal auth (header-based token)
+     * - Tools/interactions: Global auth if OptiID is required
      *
      * @throws {ToolError} If authentication fails
      */

package/dist/function/GlobalToolFunction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GlobalToolFunction.d.ts","sourceRoot":"","sources":["../../src/function/GlobalToolFunction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,QAAQ,EAA4B,MAAM,mBAAmB,CAAC;AAKvF,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAEhD;;;GAGG;AACH,8BAAsB,kBAAmB,SAAQ,cAAc;IAE7D;;;;;OAKG;IACH,SAAS,CAAC,KAAK,IAAI,OAAO,CAAC,aAAa,GAAG,OAAO,CAAC;IAInD;;;;OAIG;IACU,OAAO,IAAI,OAAO,CAAC,QAAQ,CAAC;YAmB3B,aAAa;IAmC3B;;;;OAIG;YACW,gBAAgB;CAG/B"}
+{"version":3,"file":"GlobalToolFunction.d.ts","sourceRoot":"","sources":["../../src/function/GlobalToolFunction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,QAAQ,EAAmB,MAAM,mBAAmB,CAAC;AAI9E,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAGhD;;;GAGG;AACH,8BAAsB,kBAAmB,SAAQ,cAAc;IAE7D;;;;;OAKG;IACH,SAAS,CAAC,KAAK,IAAI,OAAO,CAAC,aAAa,GAAG,OAAO,CAAC;IAInD;;;;OAIG;IACU,OAAO,IAAI,OAAO,CAAC,QAAQ,CAAC;YAmB3B,aAAa;IAkB3B;;;;;;;OAOG;YACW,gBAAgB;CAiB/B"}

package/dist/function/GlobalToolFunction.js

@@ -5,7 +5,7 @@ const app_sdk_1 = require("@zaiusinc/app-sdk");
 const AuthUtils_1 = require("../auth/AuthUtils");
 const Service_1 = require("../service/Service");
 const ToolLogger_1 = require("../logging/ToolLogger");
-const ToolError_1 = require("../types/ToolError");
+const ErrorFormatter_1 = require("../utils/ErrorFormatter");
 /**
  * Abstract base class for global tool-based function execution
  * Provides a standard interface for processing requests through registered tools
@@ -40,21 +40,6 @@ class GlobalToolFunction extends app_sdk_1.GlobalFunction {
         return response;
     }
     async handleRequest() {
-        try {
-            await this.authorizeRequest();
-        }
-        catch (error) {
-            if (error instanceof ToolError_1.ToolError) {
-                return new app_sdk_1.Response(error.status, error.toProblemDetails(this.request.path), new app_sdk_1.Headers([['content-type', 'application/problem+json']]));
-            }
-            // Fallback for unexpected errors
-            return new app_sdk_1.Response(500, {
-                title: 'Internal Server Error',
-                status: 500,
-                detail: 'An unexpected error occurred during authentication',
-                instance: this.request.path
-            }, new app_sdk_1.Headers([['content-type', 'application/problem+json']]));
-        }
         if (this.request.path === '/ready') {
             const readyResult = await this.ready();
             const readyResponse = typeof readyResult === 'boolean'
@@ -62,15 +47,36 @@ class GlobalToolFunction extends app_sdk_1.GlobalFunction {
                 : readyResult;
             return new app_sdk_1.Response(200, readyResponse);
         }
-        return Service_1.toolsService.processRequest(this.request, this);
+        try {
+            await this.authorizeRequest();
+            return await Service_1.toolsService.processRequest(this.request, this);
+        }
+        catch (error) {
+            return (0, ErrorFormatter_1.formatErrorResponse)(error, this.request.path);
+        }
     }
     /**
-     * Authenticate the incoming request by validating only the OptiID token
+     * Authenticate the incoming request based on the endpoint
+     * - /discovery: No auth required
+     * - /overrides: Internal auth (header-based token)
+     * - Tools/interactions: Global auth if OptiID is required
      *
      * @throws {ToolError} If authentication fails
      */
     async authorizeRequest() {
-        await (0, AuthUtils_1.authenticateGlobalRequest)(this.request);
+        // Discovery endpoint doesn't require auth
+        if (this.request.path === '/discovery') {
+            return;
+        }
+        // Use internal authentication for overrides endpoint (header-based token)
+        if (this.request.path === '/overrides') {
+            await (0, AuthUtils_1.authenticateInternalRequest)(this.request);
+            return;
+        }
+        // Tool/interaction endpoints - authenticate only if OptiID is required
+        if (Service_1.toolsService.requiresOptiIdAuth(this.request.path)) {
+            await (0, AuthUtils_1.authenticateGlobalRequest)(this.request);
+        }
     }
 }
 exports.GlobalToolFunction = GlobalToolFunction;

package/dist/function/GlobalToolFunction.js.map

@@ -1 +1 @@
-{"version":3,"file":"GlobalToolFunction.js","sourceRoot":"","sources":["../../src/function/GlobalToolFunction.ts"],"names":[],"mappings":";;;AAAA,+CAAuF;AACvF,iDAA+E;AAC/E,gDAAkD;AAClD,sDAAmD;AACnD,kDAA+C;AAG/C;;;GAGG;AACH,MAAsB,kBAAmB,SAAQ,wBAAc;IAE7D;;;;;OAKG;IACO,KAAK;QACb,OAAO,OAAO,CAAC,OAAO,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;IAC1C,CAAC;IAED;;;;OAIG;IACI,KAAK,CAAC,OAAO;QAClB,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QAE7B,oEAAoE;QACpE,MAAM,QAAQ,GAAG,IAAA,2BAAe,EAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAC/C,MAAM,UAAU,GAAG,QAAQ,EAAE,QAAQ,EAAE,WAAW,EAAE,WAAW,CAAC;QAEhE,IAAA,yBAAe,EAAC;YACd,YAAY,EAAE,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,kBAAkB,CAAC,IAAI,EAAE;YAChE,UAAU,EAAE,UAAU,IAAI,EAAE;SAC7B,CAAC,CAAC;QAEH,uBAAU,CAAC,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAEpC,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,aAAa,EAAE,CAAC;QAC5C,uBAAU,CAAC,WAAW,CAAC,IAAI,CAAC,OAAO,EAAE,QAAQ,EAAE,IAAI,CAAC,GAAG,EAAE,GAAG,SAAS,CAAC,CAAC;QACvE,OAAO,QAAQ,CAAC;IAClB,CAAC;IAEO,KAAK,CAAC,aAAa;QACzB,IAAI,CAAC;YACH,MAAM,IAAI,CAAC,gBAAgB,EAAE,CAAC;QAChC,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,KAAK,YAAY,qBAAS,EAAE,CAAC;gBAC/B,OAAO,IAAI,kBAAQ,CACjB,KAAK,CAAC,MAAM,EACZ,KAAK,CAAC,gBAAgB,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,EACzC,IAAI,iBAAO,CAAC,CAAC,CAAC,cAAc,EAAE,0BAA0B,CAAC,CAAC,CAAC,CAC5D,CAAC;YACJ,CAAC;YACD,iCAAiC;YACjC,OAAO,IAAI,kBAAQ,CACjB,GAAG,EACH;gBACE,KAAK,EAAE,uBAAuB;gBAC9B,MAAM,EAAE,GAAG;gBACX,MAAM,EAAE,oDAAoD;gBAC5D,QAAQ,EAAE,IAAI,CAAC,OAAO,CAAC,IAAI;aAC5B,EACD,IAAI,iBAAO,CAAC,CAAC,CAAC,cAAc,EAAE,0BAA0B,CAAC,CAAC,CAAC,CAC5D,CAAC;QACJ,CAAC;QAED,IAAI,IAAI,CAAC,OAAO,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;YACnC,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC,KAAK,EAAE,CAAC;YACvC,MAAM,aAAa,GAAG,OAAO,WAAW,KAAK,SAAS;gBACpD,CAAC,CAAC,EAAE,KAAK,EAAE,WAAW,EAAE;gBACxB,CAAC,CAAC,WAAW,CAAC;YAChB,OAAO,IAAI,kBAAQ,CAAC,GAAG,EAAE,aAAa,CAAC,CAAC;QAC1C,CAAC;QAED,OAAO,sBAAY,CAAC,cAAc,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;IACzD,CAAC;IAED;;;;OAIG;IACK,KAAK,CAAC,gBAAgB;QAC5B,MAAM,IAAA,qCAAyB,EAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IAChD,CAAC;CACF;AA/ED,gDA+EC"}
+{"version":3,"file":"GlobalToolFunction.js","sourceRoot":"","sources":["../../src/function/GlobalToolFunction.ts"],"names":[],"mappings":";;;AAAA,+CAA8E;AAC9E,iDAA4G;AAC5G,gDAAkD;AAClD,sDAAmD;AAEnD,4DAA8D;AAE9D;;;GAGG;AACH,MAAsB,kBAAmB,SAAQ,wBAAc;IAE7D;;;;;OAKG;IACO,KAAK;QACb,OAAO,OAAO,CAAC,OAAO,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;IAC1C,CAAC;IAED;;;;OAIG;IACI,KAAK,CAAC,OAAO;QAClB,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QAE7B,oEAAoE;QACpE,MAAM,QAAQ,GAAG,IAAA,2BAAe,EAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAC/C,MAAM,UAAU,GAAG,QAAQ,EAAE,QAAQ,EAAE,WAAW,EAAE,WAAW,CAAC;QAEhE,IAAA,yBAAe,EAAC;YACd,YAAY,EAAE,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,kBAAkB,CAAC,IAAI,EAAE;YAChE,UAAU,EAAE,UAAU,IAAI,EAAE;SAC7B,CAAC,CAAC;QAEH,uBAAU,CAAC,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAEpC,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,aAAa,EAAE,CAAC;QAC5C,uBAAU,CAAC,WAAW,CAAC,IAAI,CAAC,OAAO,EAAE,QAAQ,EAAE,IAAI,CAAC,GAAG,EAAE,GAAG,SAAS,CAAC,CAAC;QACvE,OAAO,QAAQ,CAAC;IAClB,CAAC;IAEO,KAAK,CAAC,aAAa;QACzB,IAAI,IAAI,CAAC,OAAO,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;YACnC,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC,KAAK,EAAE,CAAC;YACvC,MAAM,aAAa,GAAG,OAAO,WAAW,KAAK,SAAS;gBACpD,CAAC,CAAC,EAAE,KAAK,EAAE,WAAW,EAAE;gBACxB,CAAC,CAAC,WAAW,CAAC;YAChB,OAAO,IAAI,kBAAQ,CAAC,GAAG,EAAE,aAAa,CAAC,CAAC;QAC1C,CAAC;QAED,IAAI,CAAC;YACH,MAAM,IAAI,CAAC,gBAAgB,EAAE,CAAC;YAE9B,OAAO,MAAM,sBAAY,CAAC,cAAc,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;QAC/D,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,IAAA,oCAAmB,EAAC,KAAK,EAAE,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QACvD,CAAC;IACH,CAAC;IAED;;;;;;;OAOG;IACK,KAAK,CAAC,gBAAgB;QAC5B,0CAA0C;QAC1C,IAAI,IAAI,CAAC,OAAO,CAAC,IAAI,KAAK,YAAY,EAAE,CAAC;YACvC,OAAO;QACT,CAAC;QAED,0EAA0E;QAC1E,IAAI,IAAI,CAAC,OAAO,CAAC,IAAI,KAAK,YAAY,EAAE,CAAC;YACvC,MAAM,IAAA,uCAA2B,EAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YAChD,OAAO;QACT,CAAC;QAED,uEAAuE;QACvE,IAAI,sBAAY,CAAC,kBAAkB,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC;YACvD,MAAM,IAAA,qCAAyB,EAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAChD,CAAC;IACH,CAAC;CACF;AA/ED,gDA+EC"}