# JEB MCP Tools

- get_project_information
- list_units
- list_apk_resources
- get_apk_text_artifact
- find_dynamic_library
- get_unit_description
- list_comments
- set_comments
- list_code_items
- get_type_information
- list_cross_references
- list_code_strings
- decompile_code_item
- get_disassembly_snippet
- rename_code_items
- rename_pseudo_code_variables
- bulk_auto_rename_dex_items
- create_dex_package
- move_dex_item_to_package
- get_ui_fragment_information

## `get_project_information`

description:
```
Retrieve high-level information about the project, such as its name, creation time, top-level artifact files, and units to work on.
```

inputSchema:
```
{
  "type" : "object",
  "properties" : { },
  "required" : [ ]
}
```

outputSchema:
```
{
  "type" : "object",
  "properties" : {
    "creation_datetime" : {
      "type" : "string",
      "description" : "The local date and time at which the project was created"
    },
    "input_files" : {
      "description" : "The list of top-level artifact files that make up this project",
      "type" : "array",
      "items" : {
        "type" : "object",
        "properties" : {
          "contents_sha256_hash" : {
            "type" : "string",
            "description" : "The SHA-256 hash of the file contents"
          },
          "file_name" : {
            "type" : "string",
            "description" : "The name of the file"
          },
          "file_size" : {
            "type" : "integer",
            "description" : "The file size in bytes"
          }
        },
        "required" : [ "contents_sha256_hash", "file_name", "file_size" ]
      }
    },
    "message" : {
      "type" : "string",
      "description" : "Optional human-readable status, warning, or error message."
    },
    "name" : {
      "type" : "string",
      "description" : "The name of the project"
    },
    "success" : {
      "type" : "boolean",
      "description" : "True if the tool call completed successfully; false otherwise."
    },
    "units" : {
      "description" : "High-level units in the project, such as APKs, DEX bytecode, native binaries, XML files, and text files.",
      "type" : "array",
      "items" : {
        "type" : "object",
        "properties" : {
          "unit_path" : {
            "type" : "string",
            "description" : "Stable unit path to pass to tools that inspect or modify this unit."
          },
          "unit_type" : {
            "type" : "string",
            "description" : "A short descriptive name such as: apk, dex, pe, elf, x86, arm64, xml, txt, etc."
          }
        },
        "required" : [ "unit_path", "unit_type" ]
      }
    }
  },
  "required" : [ "success" ]
}
```

## `list_units`

description:
```
Retrieve project units, including units not listed by get_project_information. Returns unit paths and unit types.
```

inputSchema:
```
{
  "type" : "object",
  "properties" : {
    "count" : {
      "type" : "integer",
      "description" : "Maximum number of results to return. The maximum value is 100."
    },
    "filter" : {
      "type" : "string",
      "description" : "Optional filter matched against unit paths. The '*' wildcard is allowed."
    },
    "index" : {
      "type" : "integer",
      "description" : "Zero-based index of the first result to return."
    },
    "parent_unit_path" : {
      "type" : "string",
      "description" : "Optional parent unit path. If specified, only descendant units of the parent unit are returned."
    }
  },
  "required" : [ "count", "index" ]
}
```

outputSchema:
```
{
  "type" : "object",
  "properties" : {
    "message" : {
      "type" : "string",
      "description" : "Optional human-readable status, warning, or error message."
    },
    "success" : {
      "type" : "boolean",
      "description" : "True if the tool call completed successfully; false otherwise."
    },
    "units" : {
      "description" : "Retrieved units, including their unit paths and unit types.",
      "type" : "array",
      "items" : {
        "type" : "object",
        "properties" : {
          "unit_path" : {
            "type" : "string",
            "description" : "Stable unit path to pass to tools that inspect or modify this unit."
          },
          "unit_type" : {
            "type" : "string",
            "description" : "A short descriptive name such as: apk, dex, pe, elf, x86, arm64, xml, txt, etc."
          }
        },
        "required" : [ "unit_path", "unit_type" ]
      }
    }
  },
  "required" : [ "success" ]
}
```

## `list_apk_resources`

description:
```
List APK resource paths for layouts, strings, images, and other structured resources.
```

inputSchema:
```
{
  "type" : "object",
  "properties" : {
    "count" : {
      "type" : "integer",
      "description" : "Maximum number of results to return. The maximum value is 100."
    },
    "filter" : {
      "type" : "string",
      "description" : "Optional filter matched against resource paths. The '*' wildcard is allowed. Example: 'pub*.xml' matches 'values/public.xml'."
    },
    "index" : {
      "type" : "integer",
      "description" : "Zero-based index of the first result to return."
    },
    "unit_path" : {
      "type" : "string",
      "description" : "Path of the target APK unit, as returned by get_project_information or list_units. If omitted, the first APK unit in the project is used."
    }
  },
  "required" : [ "count", "index" ]
}
```

outputSchema:
```
{
  "type" : "object",
  "properties" : {
    "message" : {
      "type" : "string",
      "description" : "Optional human-readable status, warning, or error message."
    },
    "resource_paths" : {
      "description" : "Resource paths that can be passed to get_apk_text_artifact with artifact_kind='resource'.",
      "type" : "array",
      "items" : {
        "type" : "string"
      }
    },
    "success" : {
      "type" : "boolean",
      "description" : "True if the tool call completed successfully; false otherwise."
    }
  },
  "required" : [ "success" ]
}
```

## `get_apk_text_artifact`

description:
```
Retrieve a text artifact such as the Android Manifest, APK certificate, or an APK resource
```

inputSchema:
```
{
  "type" : "object",
  "properties" : {
    "artifact_kind" : {
      "type" : "string",
      "enum" : [ "manifest", "certificate", "resource" ],
      "description" : "Text artifact to retrieve: 'manifest' for AndroidManifest.xml, 'certificate' for the APK signing certificate summary, or 'resource' for a structured APK resource."
    },
    "resource_path" : {
      "type" : "string",
      "description" : "Required when artifact_kind is 'resource'. Resource path as returned by list_apk_resources, such as 'values-v30/strings.xml' or 'layout/main_activity.xml'."
    },
    "unit_path" : {
      "type" : "string",
      "description" : "Path of the target APK unit, as returned by get_project_information or list_units. If omitted, the first APK unit in the project is used."
    }
  },
  "required" : [ "artifact_kind" ]
}
```

outputSchema:
```
{
  "type" : "object",
  "properties" : {
    "message" : {
      "type" : "string",
      "description" : "Optional human-readable status, warning, or error message."
    },
    "success" : {
      "type" : "boolean",
      "description" : "True if the tool call completed successfully; false otherwise."
    },
    "text" : {
      "type" : "string",
      "description" : "The requested text artifact. For manifest and resource artifacts, this is XML text. For certificate artifacts, this is a human-readable certificate summary."
    }
  },
  "required" : [ "success" ]
}
```

## `find_dynamic_library`

description:
```
Find a dynamic library loaded by the dex bytecode of an APK, and provide the path to its associated code unit
```

inputSchema:
```
{
  "type" : "object",
  "properties" : {
    "library_name" : {
      "type" : "string",
      "description" : "Simple library name as passed to System.loadLibrary(), for example 'foo' for 'libfoo.so'. Do not include a platform-specific prefix, file extension, or path."
    },
    "unit_path" : {
      "type" : "string",
      "description" : "Path of the target APK unit, as returned by get_project_information or list_units. If omitted, the first APK unit in the project is used."
    }
  },
  "required" : [ "library_name" ]
}
```

outputSchema:
```
{
  "type" : "object",
  "properties" : {
    "message" : {
      "type" : "string",
      "description" : "Optional human-readable status, warning, or error message."
    },
    "success" : {
      "type" : "boolean",
      "description" : "True if the tool call completed successfully; false otherwise."
    },
    "unit_path" : {
      "type" : "string",
      "description" : "Unit path of the matching dynamic library code unit."
    }
  },
  "required" : [ "success" ]
}
```

## `get_unit_description`

description:
```
Retrieve a high-level textual description of a project unit.
```

inputSchema:
```
{
  "type" : "object",
  "properties" : {
    "unit_path" : {
      "type" : "string",
      "description" : "Path of the target unit, as returned by get_project_information or list_units."
    }
  },
  "required" : [ "unit_path" ]
}
```

outputSchema:
```
{
  "type" : "object",
  "properties" : {
    "message" : {
      "type" : "string",
      "description" : "Optional human-readable status, warning, or error message."
    },
    "success" : {
      "type" : "boolean",
      "description" : "True if the tool call completed successfully; false otherwise."
    },
    "unit_description" : {
      "type" : "string",
      "description" : "Human-readable description of the unit, including its contents, notable metadata, interesting properties, and relevant strings when available."
    }
  },
  "required" : [ "success" ]
}
```

## `list_comments`

description:
```
List inline text comments stored in project units that support comments.
```

inputSchema:
```
{
  "type" : "object",
  "properties" : {
    "count" : {
      "type" : "integer",
      "description" : "Maximum number of comments to return across all matching units. The maximum value is 100."
    },
    "filter" : {
      "type" : "string",
      "description" : "Optional filter matched against comment values. The '*' wildcard is allowed."
    },
    "index" : {
      "type" : "integer",
      "description" : "Zero-based index of the first matching comment to return."
    },
    "unit_path" : {
      "type" : "string",
      "description" : "Optional path of the target unit for which comments are to be retrieved, as returned by get_project_information or list_units. If omitted, comments from all units in the project are returned."
    }
  },
  "required" : [ "count", "index" ]
}
```

outputSchema:
```
{
  "type" : "object",
  "properties" : {
    "message" : {
      "type" : "string",
      "description" : "Optional human-readable status, warning, or error message."
    },
    "success" : {
      "type" : "boolean",
      "description" : "True if the tool call completed successfully; false otherwise."
    },
    "unit_comments" : {
      "description" : "A list of comments.",
      "type" : "array",
      "items" : {
        "type" : "object",
        "properties" : {
          "comments" : {
            "description" : "The comments attached to the unit.",
            "type" : "array",
            "items" : {
              "type" : "object",
              "properties" : {
                "comment_address" : {
                  "type" : "string",
                  "description" : "The address where the comment is located in its owner unit."
                },
                "comment_value" : {
                  "type" : "string",
                  "description" : "The value of the comment."
                }
              },
              "required" : [ "comment_address", "comment_value" ]
            }
          },
          "unit_path" : {
            "type" : "string",
            "description" : "The unit path to which the comments belong."
          }
        },
        "required" : [ "comments", "unit_path" ]
      }
    }
  },
  "required" : [ "success" ]
}
```

## `set_comments`

description:
```
Add, update, or remove inline text comments in project units that support comments. All code units support comments. This is a mutating operation.
```

inputSchema:
```
{
  "type" : "object",
  "properties" : {
    "unit_comments" : {
      "description" : "A list of comments.",
      "type" : "array",
      "items" : {
        "type" : "object",
        "properties" : {
          "comments" : {
            "description" : "The list of comments to set or remove.",
            "type" : "array",
            "items" : {
              "type" : "object",
              "properties" : {
                "comment_address" : {
                  "type" : "string",
                  "description" : "Address where the comment is located in its owner unit."
                },
                "comment_value" : {
                  "type" : "string",
                  "description" : "Comment text to set. Required when operation is 'set'; ignored when operation is 'remove'."
                },
                "operation" : {
                  "type" : "string",
                  "enum" : [ "set", "remove" ],
                  "description" : "Operation to perform. Use 'set' to add or update a comment, or 'remove' to delete the comment at comment_address."
                }
              },
              "required" : [ "comment_address", "operation" ]
            }
          },
          "unit_path" : {
            "type" : "string",
            "description" : "The unit path to which the comments belong."
          }
        },
        "required" : [ "comments", "unit_path" ]
      }
    }
  },
  "required" : [ "unit_comments" ]
}
```

outputSchema:
```
{
  "type" : "object",
  "properties" : {
    "count_comments_added" : {
      "type" : "integer",
      "description" : "The count of comments that were added to a unit."
    },
    "count_comments_removed" : {
      "type" : "integer",
      "description" : "The count of comments that were removed from a unit."
    },
    "count_errors" : {
      "type" : "integer",
      "description" : "The count of errors that occurred when attempting to add or remove a comment."
    },
    "message" : {
      "type" : "string",
      "description" : "Optional human-readable status, warning, or error message."
    },
    "success" : {
      "type" : "boolean",
      "description" : "True if the tool call completed successfully; false otherwise."
    },
    "unprocessable_unit_paths" : {
      "description" : "Unit paths ignored because they were invalid, did not support comments, or could not be processed.",
      "type" : "array",
      "items" : {
        "type" : "string"
      }
    }
  },
  "required" : [ "success" ]
}
```

## `list_code_items`

description:
```
Retrieve the list of types, methods and fields defined in a code unit, such as a Dex, PE, ELF, etc.
```

inputSchema:
```
{
  "type" : "object",
  "properties" : {
    "count" : {
      "type" : "integer",
      "description" : "Maximum number of results to return. The maximum value is 100."
    },
    "filter" : {
      "type" : "string",
      "description" : "Optional filter matched against item addresses. The '*' wildcard is allowed."
    },
    "index" : {
      "type" : "integer",
      "description" : "Zero-based index of the first result to return."
    },
    "item_kind" : {
      "type" : "string",
      "enum" : [ "type", "method", "field" ],
      "description" : "Kind of code item to list."
    },
    "unit_path" : {
      "type" : "string",
      "description" : "Path of the target code unit, as returned by get_project_information or list_units. If omitted, the first code unit in the project is used."
    }
  },
  "required" : [ "count", "index", "item_kind" ]
}
```

outputSchema:
```
{
  "type" : "object",
  "properties" : {
    "message" : {
      "type" : "string",
      "description" : "Optional human-readable status, warning, or error message."
    },
    "results" : {
      "description" : "Code item addresses. These addresses can be passed to decompile_code_item and other tools, as appropriate.",
      "type" : "array",
      "items" : {
        "type" : "string"
      }
    },
    "success" : {
      "type" : "boolean",
      "description" : "True if the tool call completed successfully; false otherwise."
    }
  },
  "required" : [ "success" ]
}
```

## `get_type_information`

description:
```
Retrieve information about a class or interface, such as its super types or implemented interfaces
```

inputSchema:
```
{
  "type" : "object",
  "properties" : {
    "type_address" : {
      "type" : "string",
      "description" : "Type address, such as one returned by list_code_items with item_kind='type'. For DEX units, this is a JVM type descriptor such as 'Lcom/example/MyClass;'."
    },
    "unit_path" : {
      "type" : "string",
      "description" : "Path of the target code unit, as returned by get_project_information or list_units. If omitted, the first code unit in the project is used."
    }
  },
  "required" : [ "type_address" ]
}
```

outputSchema:
```
{
  "type" : "object",
  "properties" : {
    "implemented_interfaces" : {
      "description" : "Interfaces implemented by the type.",
      "type" : "array",
      "items" : {
        "type" : "string"
      }
    },
    "message" : {
      "type" : "string",
      "description" : "Optional human-readable status, warning, or error message."
    },
    "success" : {
      "type" : "boolean",
      "description" : "True if the tool call completed successfully; false otherwise."
    },
    "super_types" : {
      "description" : "Direct supertypes of the type.",
      "type" : "array",
      "items" : {
        "type" : "string"
      }
    }
  },
  "required" : [ "success" ]
}
```

## `list_cross_references`

description:
```
Retrieve cross-references to an address in a code unit, that is, the users or callers of the item at the provided address.
```

inputSchema:
```
{
  "type" : "object",
  "properties" : {
    "address" : {
      "type" : "string",
      "description" : "Address of the item whose incoming cross-references should be returned."
    },
    "count" : {
      "type" : "integer",
      "description" : "Maximum number of results to return. The maximum value is 100."
    },
    "index" : {
      "type" : "integer",
      "description" : "Zero-based index of the first result to return."
    },
    "unit_path" : {
      "type" : "string",
      "description" : "Path of the target code unit, as returned by get_project_information or list_units. If omitted, the first code unit in the project is used."
    }
  },
  "required" : [ "address", "count", "index" ]
}
```

outputSchema:
```
{
  "type" : "object",
  "properties" : {
    "message" : {
      "type" : "string",
      "description" : "Optional human-readable status, warning, or error message."
    },
    "success" : {
      "type" : "boolean",
      "description" : "True if the tool call completed successfully; false otherwise."
    },
    "xref_addresses" : {
      "description" : "Addresses of items that reference the requested address.",
      "type" : "array",
      "items" : {
        "type" : "string"
      }
    }
  },
  "required" : [ "success" ]
}
```

## `list_code_strings`

description:
```
Retrieve the list of strings present in a code unit such as a dex, pe, elf, etc.
```

inputSchema:
```
{
  "type" : "object",
  "properties" : {
    "count" : {
      "type" : "integer",
      "description" : "Maximum number of results to return. The maximum value is 100."
    },
    "filter" : {
      "type" : "string",
      "description" : "Optional filter matched against string contents. The '*' wildcard is allowed. Example: 'Ren*ma' matches 'Rendezvous with Rama'."
    },
    "index" : {
      "type" : "integer",
      "description" : "Zero-based index of the first result to return."
    },
    "unit_path" : {
      "type" : "string",
      "description" : "Path of the target code unit, as returned by get_project_information or list_units. If omitted, the first code unit in the project is used."
    }
  },
  "required" : [ "count", "index" ]
}
```

outputSchema:
```
{
  "type" : "object",
  "properties" : {
    "message" : {
      "type" : "string",
      "description" : "Optional human-readable status, warning, or error message."
    },
    "strings" : {
      "description" : "A list of strings.",
      "type" : "array",
      "items" : {
        "type" : "string"
      }
    },
    "success" : {
      "type" : "boolean",
      "description" : "True if the tool call completed successfully; false otherwise."
    }
  },
  "required" : [ "success" ]
}
```

## `decompile_code_item`

description:
```
Decompile a class/type or method to pseudo-code.
```

inputSchema:
```
{
  "type" : "object",
  "properties" : {
    "item_address" : {
      "type" : "string",
      "description" : "The address of the type or method to be decompiled, such as one provided by list_code_items"
    },
    "item_kind" : {
      "type" : "string",
      "enum" : [ "type", "method" ],
      "description" : "The kind of item to be decompiled"
    },
    "unit_path" : {
      "type" : "string",
      "description" : "Path of the target code unit, as returned by get_project_information or list_units. If omitted, the first code unit in the project is used."
    }
  },
  "required" : [ "item_address", "item_kind" ]
}
```

outputSchema:
```
{
  "type" : "object",
  "properties" : {
    "message" : {
      "type" : "string",
      "description" : "Optional human-readable status, warning, or error message."
    },
    "success" : {
      "type" : "boolean",
      "description" : "True if the tool call completed successfully; false otherwise."
    },
    "text" : {
      "type" : "string",
      "description" : "Pseudo-code generated for the requested type or method."
    }
  },
  "required" : [ "success" ]
}
```

## `get_disassembly_snippet`

description:
```
Retrieve a chunk of disassembly code around a provided address.
```

inputSchema:
```
{
  "type" : "object",
  "properties" : {
    "address" : {
      "type" : "string",
      "description" : "Address around which to retrieve disassembly."
    },
    "line_count_after" : {
      "type" : "integer",
      "description" : "Number of disassembly lines to return at and after the requested address. Use a small value, typically 30 or less."
    },
    "line_count_before" : {
      "type" : "integer",
      "description" : "Number of disassembly lines to return before the requested address. Use a small value, typically 20 or less."
    },
    "unit_path" : {
      "type" : "string",
      "description" : "Path of the target code unit, as returned by get_project_information or list_units. If omitted, the first code unit in the project is used."
    }
  },
  "required" : [ "address", "line_count_after", "line_count_before" ]
}
```

outputSchema:
```
{
  "type" : "object",
  "properties" : {
    "message" : {
      "type" : "string",
      "description" : "Optional human-readable status, warning, or error message."
    },
    "success" : {
      "type" : "boolean",
      "description" : "True if the tool call completed successfully; false otherwise."
    },
    "text" : {
      "type" : "string",
      "description" : "Disassembly text around the requested address."
    }
  },
  "required" : [ "success" ]
}
```

## `rename_code_items`

description:
```
Rename one or more code items (types, methods, fields, packages) to names which may be better or more descriptive than their current names.
```

inputSchema:
```
{
  "type" : "object",
  "properties" : {
    "items" : {
      "description" : "Explicit rename operations to apply.",
      "type" : "array",
      "items" : {
        "type" : "object",
        "properties" : {
          "current_item_address" : {
            "type" : "string",
            "description" : "Address of the class, method, field, or package to rename. For DEX: a class address is a type descriptor such as 'Lcom/example/Foo;'; a method address is 'class_descriptor->method_name(arg_types)return_type'; a field address is 'class_descriptor->field_name:field_type'."
          },
          "item_kind" : {
            "type" : "string",
            "enum" : [ "type", "method", "field", "package" ],
            "description" : "Kind of item to rename."
          },
          "new_simple_name" : {
            "type" : "string",
            "description" : "New simple name for the item. For packages, provide only the final package segment, not the fully qualified package name. Do not include class descriptors, method prototypes, or field types."
          }
        },
        "required" : [ "current_item_address", "item_kind", "new_simple_name" ]
      }
    },
    "unit_path" : {
      "type" : "string",
      "description" : "Path of the target code unit, as returned by get_project_information or list_units. If omitted, the first code unit in the project is used."
    }
  },
  "required" : [ "items" ]
}
```

outputSchema:
```
{
  "type" : "object",
  "properties" : {
    "count_failures" : {
      "type" : "integer",
      "description" : "The number of failures."
    },
    "count_items_renamed" : {
      "type" : "integer",
      "description" : "The count of items that were successfully renamed."
    },
    "failures" : {
      "description" : "The list of renaming actions that failed. On a fully successful call, this list will be empty.",
      "type" : "array",
      "items" : {
        "type" : "object",
        "properties" : {
          "failure_reason" : {
            "type" : "string",
            "description" : "The reason why renaming failed."
          },
          "item_address" : {
            "type" : "string",
            "description" : "The address of the item for which renaming failed."
          }
        },
        "required" : [ "failure_reason", "item_address" ]
      }
    },
    "message" : {
      "type" : "string",
      "description" : "Optional human-readable status, warning, or error message."
    },
    "success" : {
      "type" : "boolean",
      "description" : "True if the tool call completed successfully; false otherwise."
    }
  },
  "required" : [ "success" ]
}
```

## `rename_pseudo_code_variables`

description:
```
Rename one or more local variables or parameters defined in the decompiled pseudo-code of a method. The method must have been decompiled first.
```

inputSchema:
```
{
  "type" : "object",
  "properties" : {
    "items" : {
      "description" : "Local-variable and parameter rename operations to apply to a previously decompiled method.",
      "type" : "array",
      "items" : {
        "type" : "object",
        "properties" : {
          "current_local_name" : {
            "type" : "string",
            "description" : "Current local variable or parameter name as it appears in the decompiled pseudo-code."
          },
          "new_local_name" : {
            "type" : "string",
            "description" : "New local variable or parameter name."
          }
        },
        "required" : [ "current_local_name", "new_local_name" ]
      }
    },
    "method_address" : {
      "type" : "string",
      "description" : "Address of a method that was previously decompiled with decompile_code_item. For DEX, use 'type_descriptor->method_name(arg_types)return_type', for example 'Lcom/abc;->someFunction([I)V'."
    },
    "unit_path" : {
      "type" : "string",
      "description" : "Path of the target code unit, as returned by get_project_information or list_units. If omitted, the first code unit in the project is used."
    }
  },
  "required" : [ "items", "method_address" ]
}
```

outputSchema:
```
{
  "type" : "object",
  "properties" : {
    "count_failures" : {
      "type" : "integer",
      "description" : "The number of failures."
    },
    "count_items_renamed" : {
      "type" : "integer",
      "description" : "The count of items that were successfully renamed."
    },
    "failures" : {
      "description" : "The list of renaming actions that failed. On a fully successful call, this list will be empty.",
      "type" : "array",
      "items" : {
        "type" : "object",
        "properties" : {
          "failure_reason" : {
            "type" : "string",
            "description" : "The reason why renaming failed."
          },
          "local_name" : {
            "type" : "string",
            "description" : "The name of the local variable or parameter for which renaming failed."
          }
        },
        "required" : [ "failure_reason", "local_name" ]
      }
    },
    "message" : {
      "type" : "string",
      "description" : "Optional human-readable status, warning, or error message."
    },
    "success" : {
      "type" : "boolean",
      "description" : "True if the tool call completed successfully; false otherwise."
    }
  },
  "required" : [ "success" ]
}
```

## `bulk_auto_rename_dex_items`

description:
```
Automatically rename DEX classes, methods, and fields to shorter readable names. This is a mutating bulk operation; use it only when the user explicitly asks for automatic bulk renaming or cleanup.
```

inputSchema:
```
{
  "type" : "object",
  "properties" : {
    "unit_path" : {
      "type" : "string",
      "description" : "Path of the target DEX unit, as returned by get_project_information or list_units."
    }
  },
  "required" : [ "unit_path" ]
}
```

outputSchema:
```
{
  "type" : "object",
  "properties" : {
    "message" : {
      "type" : "string",
      "description" : "Optional human-readable status, warning, or error message."
    },
    "success" : {
      "type" : "boolean",
      "description" : "True if the tool call completed successfully; false otherwise."
    }
  },
  "required" : [ "success" ]
}
```

## `create_dex_package`

description:
```
Create a new DEX package
```

inputSchema:
```
{
  "type" : "object",
  "properties" : {
    "fully_qualified_name" : {
      "type" : "string",
      "description" : "The fully-qualified dot-separated package name, example: com.some.foo"
    },
    "unit_path" : {
      "type" : "string",
      "description" : "Path of the target DEX unit, as returned by get_project_information or list_units. If omitted, the first DEX unit in the project is used."
    }
  },
  "required" : [ "fully_qualified_name" ]
}
```

outputSchema:
```
{
  "type" : "object",
  "properties" : {
    "message" : {
      "type" : "string",
      "description" : "Optional human-readable status, warning, or error message."
    },
    "success" : {
      "type" : "boolean",
      "description" : "True if the tool call completed successfully; false otherwise."
    }
  },
  "required" : [ "success" ]
}
```

## `move_dex_item_to_package`

description:
```
Move a DEX class or package into an existing destination package.
```

inputSchema:
```
{
  "type" : "object",
  "properties" : {
    "dst_address" : {
      "type" : "string",
      "description" : "Address of the destination package. The destination package must already exist; use create_dex_package first if needed."
    },
    "item_kind" : {
      "type" : "string",
      "enum" : [ "type", "package" ],
      "description" : "The kind of item to be moved"
    },
    "src_address" : {
      "type" : "string",
      "description" : "Address of the source type or package to move. For a DEX class, use its type descriptor, such as 'Lcom/example/Foo;'. For a DEX package, use a slash-terminated package descriptor such as 'Lcom/example/'."
    },
    "unit_path" : {
      "type" : "string",
      "description" : "Path of the target DEX unit, as returned by get_project_information or list_units. If omitted, the first DEX unit in the project is used."
    }
  },
  "required" : [ "dst_address", "item_kind", "src_address" ]
}
```

outputSchema:
```
{
  "type" : "object",
  "properties" : {
    "message" : {
      "type" : "string",
      "description" : "Optional human-readable status, warning, or error message."
    },
    "success" : {
      "type" : "boolean",
      "description" : "True if the tool call completed successfully; false otherwise."
    }
  },
  "required" : [ "success" ]
}
```

## `get_ui_fragment_information`

description:
```
Retrieve information about the active UI fragment, such as the fragment name, associated unit, caret address, or current text selection.
```

inputSchema:
```
{
  "type" : "object",
  "properties" : { },
  "required" : [ ]
}
```

outputSchema:
```
{
  "type" : "object",
  "properties" : {
    "address" : {
      "type" : "string",
      "description" : "The caret address in the active GUI fragment, if any."
    },
    "fragment_name" : {
      "type" : "string",
      "description" : "The name of the active GUI fragment, if any."
    },
    "message" : {
      "type" : "string",
      "description" : "Optional human-readable status, warning, or error message."
    },
    "success" : {
      "type" : "boolean",
      "description" : "True if the tool call completed successfully; false otherwise."
    },
    "text_selection" : {
      "type" : "string",
      "description" : "The selected text in the active GUI fragment, if any."
    },
    "unit_path" : {
      "type" : "string",
      "description" : "The path of the unit rendered in the active GUI fragment, if any."
    }
  },
  "required" : [ "success" ]
}
```