@withone/mcp 1.0.0

package/build/schemas.d.ts

@@ -0,0 +1,285 @@
+/**
+ * MCP Tool Schemas
+ *
+ * This file contains all tool schema definitions for MCP tools using zod.
+ * Centralizing schemas here improves maintainability and reusability.
+ *
+ * @fileoverview Complete tool schema definitions for all MCP tools
+ * @author Pica
+ */
+import { z } from 'zod';
+/**
+ * Schema for listing Pica integrations (no parameters required)
+ */
+export declare const listPicaIntegrationsInputSchema: {};
+/**
+ * Schema for searching platform actions
+ */
+export declare const searchPicaPlatformActionsInputSchema: {
+    platform: z.ZodString;
+    query: z.ZodString;
+    agentType: z.ZodOptional<z.ZodEnum<["execute", "knowledge"]>>;
+};
+/**
+ * Schema for getting action knowledge
+ */
+export declare const getPicaActionKnowledgeInputSchema: {
+    actionId: z.ZodString;
+    platform: z.ZodString;
+};
+/**
+ * Schema for executing Pica actions
+ */
+export declare const executePicaActionInputSchema: {
+    platform: z.ZodString;
+    actionId: z.ZodString;
+    connectionKey: z.ZodString;
+    data: z.ZodOptional<z.ZodAny>;
+    pathVariables: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+    queryParams: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    isFormData: z.ZodOptional<z.ZodBoolean>;
+    isFormUrlEncoded: z.ZodOptional<z.ZodBoolean>;
+};
+/**
+ * Output schemas for list_pica_integrations tool
+ */
+export declare const listPicaIntegrationsOutputSchema: {
+    connections: z.ZodArray<z.ZodObject<{
+        platform: z.ZodString;
+        key: z.ZodString;
+        tags: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        key: string;
+        platform: string;
+        tags: string[];
+    }, {
+        key: string;
+        platform: string;
+        tags: string[];
+    }>, "many">;
+    availablePlatforms: z.ZodArray<z.ZodObject<{
+        platform: z.ZodString;
+        name: z.ZodString;
+        category: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        platform: string;
+        name: string;
+        category: string;
+    }, {
+        platform: string;
+        name: string;
+        category: string;
+    }>, "many">;
+    summary: z.ZodObject<{
+        connectedCount: z.ZodNumber;
+        availableCount: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        connectedCount: number;
+        availableCount: number;
+    }, {
+        connectedCount: number;
+        availableCount: number;
+    }>;
+};
+/**
+ * Output schemas for search_pica_platform_actions tool
+ */
+export declare const searchPicaPlatformActionsOutputSchema: {
+    actions: z.ZodArray<z.ZodObject<{
+        actionId: z.ZodString;
+        title: z.ZodString;
+        method: z.ZodString;
+        path: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        method: string;
+        actionId: string;
+        path: string;
+        title: string;
+    }, {
+        method: string;
+        actionId: string;
+        path: string;
+        title: string;
+    }>, "many">;
+    metadata: z.ZodObject<{
+        platform: z.ZodString;
+        query: z.ZodString;
+        count: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        query: string;
+        platform: string;
+        count: number;
+    }, {
+        query: string;
+        platform: string;
+        count: number;
+    }>;
+};
+/**
+ * Tool configuration objects for registerTool
+ */
+export declare const listPicaIntegrationsToolConfig: {
+    title: string;
+    description: string;
+    inputSchema: {};
+    outputSchema: {
+        connections: z.ZodArray<z.ZodObject<{
+            platform: z.ZodString;
+            key: z.ZodString;
+            tags: z.ZodArray<z.ZodString, "many">;
+        }, "strip", z.ZodTypeAny, {
+            key: string;
+            platform: string;
+            tags: string[];
+        }, {
+            key: string;
+            platform: string;
+            tags: string[];
+        }>, "many">;
+        availablePlatforms: z.ZodArray<z.ZodObject<{
+            platform: z.ZodString;
+            name: z.ZodString;
+            category: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            platform: string;
+            name: string;
+            category: string;
+        }, {
+            platform: string;
+            name: string;
+            category: string;
+        }>, "many">;
+        summary: z.ZodObject<{
+            connectedCount: z.ZodNumber;
+            availableCount: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            connectedCount: number;
+            availableCount: number;
+        }, {
+            connectedCount: number;
+            availableCount: number;
+        }>;
+    };
+};
+export declare const searchPicaPlatformActionsToolConfig: {
+    title: string;
+    description: string;
+    inputSchema: {
+        platform: z.ZodString;
+        query: z.ZodString;
+        agentType: z.ZodOptional<z.ZodEnum<["execute", "knowledge"]>>;
+    };
+    outputSchema: {
+        actions: z.ZodArray<z.ZodObject<{
+            actionId: z.ZodString;
+            title: z.ZodString;
+            method: z.ZodString;
+            path: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            method: string;
+            actionId: string;
+            path: string;
+            title: string;
+        }, {
+            method: string;
+            actionId: string;
+            path: string;
+            title: string;
+        }>, "many">;
+        metadata: z.ZodObject<{
+            platform: z.ZodString;
+            query: z.ZodString;
+            count: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            query: string;
+            platform: string;
+            count: number;
+        }, {
+            query: string;
+            platform: string;
+            count: number;
+        }>;
+    };
+};
+export declare const getPicaActionKnowledgeToolConfig: {
+    title: string;
+    description: string;
+    inputSchema: {
+        actionId: z.ZodString;
+        platform: z.ZodString;
+    };
+};
+export declare const executePicaActionToolConfig: {
+    title: string;
+    description: string;
+    inputSchema: {
+        platform: z.ZodString;
+        actionId: z.ZodString;
+        connectionKey: z.ZodString;
+        data: z.ZodOptional<z.ZodAny>;
+        pathVariables: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+        queryParams: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        isFormData: z.ZodOptional<z.ZodBoolean>;
+        isFormUrlEncoded: z.ZodOptional<z.ZodBoolean>;
+    };
+};
+/**
+ * Zod object schemas for type inference (for internal use)
+ */
+export declare const listPicaIntegrationsZodSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+export declare const searchPicaPlatformActionsZodSchema: z.ZodObject<{
+    platform: z.ZodString;
+    query: z.ZodString;
+    agentType: z.ZodOptional<z.ZodEnum<["execute", "knowledge"]>>;
+}, "strip", z.ZodTypeAny, {
+    query: string;
+    platform: string;
+    agentType?: "execute" | "knowledge" | undefined;
+}, {
+    query: string;
+    platform: string;
+    agentType?: "execute" | "knowledge" | undefined;
+}>;
+export declare const getPicaActionKnowledgeZodSchema: z.ZodObject<{
+    actionId: z.ZodString;
+    platform: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    actionId: string;
+    platform: string;
+}, {
+    actionId: string;
+    platform: string;
+}>;
+export declare const executePicaActionZodSchema: z.ZodObject<{
+    platform: z.ZodString;
+    actionId: z.ZodString;
+    connectionKey: z.ZodString;
+    data: z.ZodOptional<z.ZodAny>;
+    pathVariables: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+    queryParams: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    isFormData: z.ZodOptional<z.ZodBoolean>;
+    isFormUrlEncoded: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    actionId: string;
+    connectionKey: string;
+    platform: string;
+    headers?: Record<string, string> | undefined;
+    data?: any;
+    pathVariables?: Record<string, string | number | boolean> | undefined;
+    queryParams?: Record<string, any> | undefined;
+    isFormData?: boolean | undefined;
+    isFormUrlEncoded?: boolean | undefined;
+}, {
+    actionId: string;
+    connectionKey: string;
+    platform: string;
+    headers?: Record<string, string> | undefined;
+    data?: any;
+    pathVariables?: Record<string, string | number | boolean> | undefined;
+    queryParams?: Record<string, any> | undefined;
+    isFormData?: boolean | undefined;
+    isFormUrlEncoded?: boolean | undefined;
+}>;

package/build/schemas.js

@@ -0,0 +1,110 @@
+/**
+ * MCP Tool Schemas
+ *
+ * This file contains all tool schema definitions for MCP tools using zod.
+ * Centralizing schemas here improves maintainability and reusability.
+ *
+ * @fileoverview Complete tool schema definitions for all MCP tools
+ * @author One
+ */
+import { z } from 'zod';
+/**
+ * Schema for listing One integrations (no parameters required)
+ */
+export const listOneIntegrationsInputSchema = {};
+/**
+ * Schema for searching platform actions
+ */
+export const searchOnePlatformActionsInputSchema = {
+    platform: z.string().describe("The platform name to search actions for (e.g., 'ship-station', 'shopify'). This is the kebab-case version of the platform name that comes from the list_one_integrations tool AVAILABLE PLATFORMS section."),
+    query: z.string().describe("The search query to find relevant actions (e.g., 'search contacts', 'create customer', 'send email'). Be specific about what you want to do."),
+    agentType: z.enum(["execute", "knowledge"]).optional().describe("The type of agent context: 'execute' if the user wants to execute an action, 'knowledge' if they want to get information or write code. Defaults to 'knowledge' if not specified.")
+};
+/**
+ * Schema for getting action knowledge
+ */
+export const getOneActionKnowledgeInputSchema = {
+    actionId: z.string().describe("The action ID to get knowledge for (from the actions list returned by search_one_platform_actions). REQUIRED: This tool must be called before execute_one_action to load the action's documentation into context."),
+    platform: z.string().describe("The platform name to get knowledge for (e.g., 'ship-station', 'shopify'). This is the kebab-case version of the platform name that comes from the list_one_integrations tool AVAILABLE PLATFORMS section.")
+};
+/**
+ * Schema for executing One actions
+ */
+export const executeOneActionInputSchema = {
+    platform: z.string().describe("Platform name"),
+    actionId: z.string().describe("Action ID from search_one_platform_actions"),
+    connectionKey: z.string().describe("Key of the connection to use"),
+    data: z.any().optional().describe("Request data (for POST, PUT, etc.)"),
+    pathVariables: z.record(z.union([z.string(), z.number(), z.boolean()])).optional().describe("Variables to replace in the path"),
+    queryParams: z.record(z.any()).optional().describe("Query parameters"),
+    headers: z.record(z.string()).optional().describe("Additional headers"),
+    isFormData: z.boolean().optional().describe("Whether to send data as multipart/form-data"),
+    isFormUrlEncoded: z.boolean().optional().describe("Whether to send data as application/x-www-form-urlencoded")
+};
+/**
+ * Output schemas for list_one_integrations tool
+ */
+export const listOneIntegrationsOutputSchema = {
+    connections: z.array(z.object({
+        platform: z.string(),
+        key: z.string(),
+        tags: z.array(z.string())
+    })).describe("Array of user's active connections"),
+    availablePlatforms: z.array(z.object({
+        platform: z.string(),
+        name: z.string(),
+        category: z.string()
+    })).describe("Array of available platforms that can be connected"),
+    summary: z.object({
+        connectedCount: z.number(),
+        availableCount: z.number()
+    }).describe("Summary statistics of connections and available platforms")
+};
+/**
+ * Output schemas for search_one_platform_actions tool
+ */
+export const searchOnePlatformActionsOutputSchema = {
+    actions: z.array(z.object({
+        actionId: z.string().describe("Unique identifier for the action"),
+        title: z.string().describe("Human-readable action name"),
+        method: z.string().describe("HTTP method (GET, POST, etc.)"),
+        path: z.string().describe("API endpoint path")
+    })).describe("Array of matching actions (max 5)"),
+    metadata: z.object({
+        platform: z.string().describe("Platform that was searched"),
+        query: z.string().describe("Search query used"),
+        count: z.number().describe("Number of results returned")
+    }).describe("Metadata about the search results")
+};
+/**
+ * Tool configuration objects for registerTool
+ */
+export const listOneIntegrationsToolConfig = {
+    title: "List One Integrations",
+    description: "List all available One integrations and platforms. ALWAYS call this tool first in any workflow to discover what platforms and connections are available. This returns the connections that the user has and all available One platforms in kebab-case format (e.g., 'ship-station', 'shopify') which you'll need for subsequent tool calls.",
+    inputSchema: listOneIntegrationsInputSchema,
+    outputSchema: listOneIntegrationsOutputSchema
+};
+export const searchOnePlatformActionsToolConfig = {
+    title: "Search Platform Actions",
+    description: "Search for relevant actions on a specific platform using a query. Call this after list_one_integrations to find actions that match your intent. Returns the top 5 most relevant actions based on your search query. Use the exact kebab-case platform name from the integrations list.",
+    inputSchema: searchOnePlatformActionsInputSchema,
+    outputSchema: searchOnePlatformActionsOutputSchema
+};
+export const getOneActionKnowledgeToolConfig = {
+    title: "Get Action Knowledge",
+    description: "Get comprehensive documentation for a specific action including parameters, requirements, and usage examples. MANDATORY: You MUST call this tool before execute_one_action to understand the action's requirements, parameter structure, caveats, and proper usage. This loads the action documentation into context and is required for successful execution.",
+    inputSchema: getOneActionKnowledgeInputSchema
+};
+export const executeOneActionToolConfig = {
+    title: "Execute One Action",
+    description: "Execute a One action to perform actual operations on third-party platforms. CRITICAL: Only call this when the user's intent is to EXECUTE an action (e.g., 'read my last Gmail email', 'fetch 5 contacts from HubSpot', 'create a task in Asana'). DO NOT call this when the user wants to BUILD or CREATE code/forms/applications - in those cases, stop after get_one_action_knowledge and provide implementation guidance instead. REQUIRED WORKFLOW: Must call get_one_action_knowledge first. If uncertain about execution intent or parameters, ask for confirmation before proceeding.",
+    inputSchema: executeOneActionInputSchema
+};
+/**
+ * Zod object schemas for type inference (for internal use)
+ */
+export const listOneIntegrationsZodSchema = z.object(listOneIntegrationsInputSchema);
+export const searchOnePlatformActionsZodSchema = z.object(searchOnePlatformActionsInputSchema);
+export const getOneActionKnowledgeZodSchema = z.object(getOneActionKnowledgeInputSchema);
+export const executeOneActionZodSchema = z.object(executeOneActionInputSchema);

package/build/server.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Pica MCP Server Factory
+ *
+ * Exports a factory function that registers all Pica tools on a provided McpServer instance.
+ *
+ * @fileoverview createPicaServer() factory for reuse across stdio and HTTP transports
+ * @author Pica
+ */
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { PermissionLevel } from './types.js';
+export interface CreatePicaServerOptions {
+    secret: string;
+    baseUrl?: string;
+    identity?: string;
+    identityType?: 'user' | 'team' | 'organization' | 'project';
+    permissions?: PermissionLevel;
+    connectionKeys?: string[];
+    actionIds?: string[];
+    knowledgeAgent?: boolean;
+}
+/**
+ * Registers all Pica MCP tools on the provided server instance.
+ *
+ * @param server - An McpServer instance to register tools on
+ * @param options - Configuration options (secret is required, rest have sensible defaults)
+ */
+export declare function createPicaServer(server: McpServer, options: CreatePicaServerOptions): Promise<void>;

package/build/server.js

@@ -0,0 +1,215 @@
+/**
+ * Pica MCP Server Factory
+ *
+ * Exports a factory function that registers all Pica tools on a provided McpServer instance.
+ *
+ * @fileoverview createPicaServer() factory for reuse across stdio and HTTP transports
+ * @author Pica
+ */
+import { ErrorCode, McpError, } from '@modelcontextprotocol/sdk/types.js';
+import { PicaClient } from './client.js';
+import { buildActionKnowledgeWithGuidance, filterByPermissions, isMethodAllowed, isActionAllowed, } from './helpers.js';
+import { listPicaIntegrationsToolConfig, searchPicaPlatformActionsToolConfig, getPicaActionKnowledgeToolConfig, executePicaActionToolConfig, } from './schemas.js';
+/**
+ * Registers all Pica MCP tools on the provided server instance.
+ *
+ * @param server - An McpServer instance to register tools on
+ * @param options - Configuration options (secret is required, rest have sensible defaults)
+ */
+export async function createPicaServer(server, options) {
+    const { secret, baseUrl, identity, identityType, permissions = 'admin', connectionKeys = ['*'], actionIds = ['*'], knowledgeAgent = false, } = options;
+    const picaClient = new PicaClient({
+        secret,
+        baseUrl,
+        identity,
+        identityType,
+        connectionKeys,
+    });
+    let picaInitialized = false;
+    let initializationPromise = null;
+    const initializePica = async () => {
+        if (picaInitialized) {
+            return;
+        }
+        if (initializationPromise) {
+            return initializationPromise;
+        }
+        initializationPromise = (async () => {
+            try {
+                await picaClient.initialize();
+                picaInitialized = true;
+            }
+            catch (error) {
+                console.error("Failed to initialize Pica client:", error);
+                initializationPromise = null;
+                throw error;
+            }
+        })();
+        return initializationPromise;
+    };
+    // --- Tool handlers ---
+    async function handleGetIntegrations(_args) {
+        try {
+            const connectedIntegrations = picaClient.getUserConnections();
+            const availableIntegrations = picaClient.getAvailableConnectors();
+            const activeConnections = connectedIntegrations.filter(conn => conn.active);
+            let activePlatforms = availableIntegrations.filter(def => def.active && !def.deprecated);
+            if (!connectionKeys.includes("*")) {
+                const connectedPlatforms = new Set(activeConnections.map(conn => conn.platform));
+                activePlatforms = activePlatforms.filter(def => connectedPlatforms.has(def.platform));
+            }
+            const structuredResponse = {
+                connections: activeConnections.map(conn => ({
+                    platform: conn.platform,
+                    key: conn.key,
+                    tags: conn.tags ?? [],
+                })),
+                availablePlatforms: activePlatforms.map(def => ({
+                    platform: def.platform,
+                    name: def.name,
+                    category: def.category,
+                })),
+                summary: {
+                    connectedCount: activeConnections.length,
+                    availableCount: activePlatforms.length,
+                },
+            };
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(structuredResponse, null, 2),
+                    },
+                ],
+                structuredContent: structuredResponse,
+            };
+        }
+        catch (error) {
+            throw new McpError(ErrorCode.InternalError, `Failed to retrieve integrations: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    async function handleSearchPlatformActions(args) {
+        try {
+            const agentType = knowledgeAgent ? "knowledge" : args.agentType;
+            let actions = await picaClient.searchAvailableActions(args.platform, args.query, agentType);
+            actions = filterByPermissions(actions, permissions);
+            actions = actions.filter(a => isActionAllowed(a.systemId, actionIds));
+            const cleanedActions = actions.map(action => ({
+                actionId: action.systemId,
+                title: action.title,
+                method: action.method,
+                path: action.path,
+            }));
+            if (cleanedActions.length === 0) {
+                const suggestionsText = `No actions found for platform '${args.platform}' matching query '${args.query}'.
+
+SUGGESTIONS:
+- Try a more general query (e.g., 'list', 'get', 'search', 'create')
+- Verify the platform name is correct
+- Check that actions exist for this platform using list_pica_integrations
+
+EXAMPLES OF GOOD QUERIES:
+- "search contacts"
+- "send email"
+- "create customer"
+- "list orders"`;
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: suggestionsText,
+                        },
+                    ],
+                };
+            }
+            const structuredResponse = {
+                actions: cleanedActions,
+                metadata: {
+                    platform: args.platform,
+                    query: args.query,
+                    count: cleanedActions.length,
+                },
+            };
+            const responseText = `Found ${cleanedActions.length} action(s) for platform '${args.platform}' matching query '${args.query}':
+
+${JSON.stringify(structuredResponse, null, 2)}
+
+NEXT STEP: Use get_pica_action_knowledge with an actionId to get detailed documentation before building requests or executing actions.`;
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: responseText,
+                    },
+                ],
+                structuredContent: structuredResponse,
+            };
+        }
+        catch (error) {
+            throw new McpError(ErrorCode.InternalError, `Failed to search platform actions: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    async function handleGetActionKnowledge(args) {
+        try {
+            const actionId = args.actionId;
+            if (!isActionAllowed(actionId, actionIds)) {
+                throw new McpError(ErrorCode.InvalidRequest, `Action "${actionId}" is not in the allowed action list`);
+            }
+            const { knowledge, method } = await picaClient.getActionKnowledge(actionId);
+            const knowledgeWithGuidance = buildActionKnowledgeWithGuidance(knowledge, method, picaClient.getBaseUrl(), args.platform, actionId);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: knowledgeWithGuidance,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            throw new McpError(ErrorCode.InternalError, `Failed to retrieve action knowledge: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    async function handleExecutePicaAction(args) {
+        try {
+            if (!isActionAllowed(args.actionId, actionIds)) {
+                throw new McpError(ErrorCode.InvalidRequest, `Action "${args.actionId}" is not in the allowed action list`);
+            }
+            const actionDetails = await picaClient.getActionDetails(args.actionId);
+            if (!isMethodAllowed(actionDetails.method, permissions)) {
+                throw new McpError(ErrorCode.InvalidRequest, `Method "${actionDetails.method}" is not allowed under "${permissions}" permission level`);
+            }
+            const result = await picaClient.executePassthroughRequest(args, actionDetails);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(result, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            throw new McpError(ErrorCode.InternalError, `Failed to execute Pica action: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    // --- Register tools ---
+    server.registerTool("list_pica_integrations", listPicaIntegrationsToolConfig, async (args) => {
+        await initializePica();
+        return await handleGetIntegrations(args);
+    });
+    server.registerTool("search_pica_platform_actions", searchPicaPlatformActionsToolConfig, async (args) => {
+        await initializePica();
+        return await handleSearchPlatformActions(args);
+    });
+    server.registerTool("get_pica_action_knowledge", getPicaActionKnowledgeToolConfig, async (args) => {
+        await initializePica();
+        return await handleGetActionKnowledge(args);
+    });
+    if (!knowledgeAgent) {
+        server.registerTool("execute_pica_action", executePicaActionToolConfig, async (args) => {
+            await initializePica();
+            return await handleExecutePicaAction(args);
+        });
+    }
+}